/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <returns></returns> public T ReadGeneric <T>() { ITypeSerializer <T> serializer = InternalTypeCache <T> .Serializer; if (serializer is IBuiltinTypeSerializer) { return(serializer.Deserialize(ref this)); } else { ObjectType type = ReadTypeFromCachedTag(); int len = ReadLengthByType(type); if (len < 0) { throw new InvalidCastException(string.Format(Resources.InvalidCastFormat, type, typeof(T).AssemblyQualifiedName)); } if (m_ReadCount + len > m_Size) { throw new StreamTooShortException(Resources.StreamTooShort); } AccelReader reader = new AccelReader(m_Source + m_ReadCount, len, m_Encoding, m_IsLittleEndian); m_ReadCount += len; return(serializer.Deserialize(ref reader)); } }
public T ContentAs <T>() { //basic GET operation if (OpCode == OpCode.Get) { var bodyOffset = Header.BodyOffset; var length = _contentBytes.Length - Header.BodyOffset; return(_transcoder.Decode <T>(_contentBytes, bodyOffset, length, Flags, OpCode)); } //oh mai, its a projection ParseSpecs(); var root = new JObject(); foreach (var spec in _specs) { var content = _serializer.Deserialize <JToken>(spec.Bytes, 0, spec.Bytes.Length); var projection = CreateProjection(spec.Path, content); try { root.Add(projection.First); //hacky should be improved later } catch (Exception e) { //ignore for now - these are cases where a root attribute is already mapped //for example "attributes" and "attributes.hair" will cause exceptions } } return(root.ToObject <T>()); }
public T ContentAs <T>(int index) { EnsureNotDisposed(); var response = _bytes.Memory.Slice(HeaderOffsets.HeaderLength); var operationSpecs = new List <OperationSpec>(); for (;;) { var bodyLength = ByteConverter.ToInt32(response.Span.Slice(2)); var payLoad = response.Slice(6, bodyLength); var command = new MutateInSpec { Status = (ResponseStatus)ByteConverter.ToUInt16(response.Span), ValueIsJson = payLoad.Span.IsJson(), Bytes = payLoad }; operationSpecs.Add(command); response = response.Slice(6 + bodyLength); if (response.Length <= 0) { break; } } var spec = operationSpecs[index]; return(_serializer.Deserialize <T>(spec.Bytes)); }
void ICustomDataItem.Deserialize(ITypeSerializer handler, DataCollection data) { DataItem items = (DataItem)data.Extract("Items"); handler.Deserialize(this, data); IProgressMonitor monitor = handler.SerializationContext.ProgressMonitor; if (monitor == null) { monitor = new MonoDevelop.Core.ProgressMonitoring.NullProgressMonitor(); } if (items != null) { string baseDir = Path.GetDirectoryName(handler.SerializationContext.BaseFile); monitor.BeginTask(null, items.ItemData.Count); try { foreach (DataValue item in items.ItemData) { string file = Path.Combine(baseDir, item.Value); WorkspaceItem it = Services.ProjectService.ReadWorkspaceItem(monitor, file); if (it != null) { Items.Add(it); } monitor.Step(1); } } finally { monitor.EndTask(); } } }
public override Array Deserialize(System.IO.Stream stream) { int length = stream.ReadByte(); if (length == 254) { ushort t; ReadValue(stream, out t); length = t; } if (length == 255) { ReadValue(stream, out length); } var array = Array.CreateInstance(baseType, length); if (length > 0) { int index = 0; while (index < length) { var obj = serializer.Deserialize(stream); array.SetValue(obj, index++); } } return(array); }
public void Deserialize(object obj, ITypeSerializer handler, DataCollection data) { //find whether is was marked as FileCopy DataValue value = data ["buildaction"] as DataValue; bool isFileCopy = value != null && value.Value == "FileCopy"; handler.Deserialize(obj, data); ProjectFile file = (ProjectFile)obj; //if it wasn't, no fancy migrations to do if (!isFileCopy) { return; } //if there were any deploy settings remaining in the project file, then the file isn't "copy to output" //but instead should be marked to deploy foreach (string key in keys) { if (file.ExtendedProperties.Contains(key)) { file.CopyToOutputDirectory = FileCopyMode.None; file.ExtendedProperties ["DeployService.Deploy"] = true; return; } } }
public void Deserialize(ITypeSerializer handler, DataCollection data) { DataItem filtersItem = data.Extract("filters") as DataItem; if ((filtersItem != null) && (filtersItem.HasItemData)) { foreach (DataItem item in filtersItem.ItemData) { string filter = ((DataValue)item.ItemData ["string"]).Value; string typeString = ((DataValue)item.ItemData ["type"]).Value; ToolboxItemFilterType type = (ToolboxItemFilterType)Enum.Parse(typeof(ToolboxItemFilterType), typeString); itemFilters.Add(new ToolboxItemFilterAttribute(filter, type)); } } DataItem iconItem = data.Extract("icon") as DataItem; if (iconItem != null) { DataValue iconData = (DataValue)iconItem ["enc"]; this.icon = new Gdk.Pixbuf(Convert.FromBase64String(iconData.Value)); } handler.Deserialize(this, data); }
protected T SerializeDeserialize <T>(ITypeSerializer serializer, T value) { var buffer = new BMSByte(); serializer.Serialize(value, buffer); buffer.MoveStartIndex(-buffer.StartIndex()); return((T)serializer.Deserialize(buffer)); }
public void Deserialize(ITypeSerializer handler, DataCollection data) { handler.Deserialize(this, data); Init(); referenceCollection.InitRefCollection(tempProjectDependencies, tempIncludes); }
public T ContentAs <T>() { EnsureNotDisposed(); //basic GET or other non-projection operation if (OpCode == OpCode.Get || OpCode == OpCode.ReplicaRead || OpCode == OpCode.GetL || OpCode == OpCode.GAT) { return(_transcoder.Decode <T>(_contentBytes.Memory.Slice(Header.BodyOffset), Flags, OpCode)); } //oh mai, its a projection ParseSpecs(); // normal GET if (_specs.Count == 1 && _projectList?.Count == 0) { var spec = _specs[0]; return(_transcoder.Decode <T>(spec.Bytes, Flags, OpCode.Get)); } var root = new JObject(); foreach (var spec in _specs) { var content = _serializer.Deserialize <JToken>(spec.Bytes); if (spec.OpCode == OpCode.Get) { //a full doc is returned if the projection count exceeds the server limit //so we remove any non-requested fields from the content returned. if (_projectList?.Count > 16) { foreach (var child in content.Children()) { if (_projectList.Contains(child.Path)) { root.Add(child); } } //root projection for empty path return(root.ToObject <T>()); } } var projection = CreateProjection(spec.Path, content); try { root.Add(projection.First); } catch (Exception e) { //these are cases where a root attribute is already mapped //for example "attributes" and "attributes.hair" will cause exceptions Log.LogInformation(e, "Deserialization failed."); } } return(root.ToObject <T>()); }
public T ContentAs <T>(int index) { if (index < 0 || index >= _specs.Count) { throw new InvalidIndexException($"The index provided is out of range: {index}."); } var spec = _specs[index]; return(_serializer.Deserialize <T>(spec.Bytes)); }
public static Serializer FromTypeSerializer<T>(ITypeSerializer<T> serializer) { return new Serializer() { TargetType = typeof(T), IsGeneral = false, SerializeFunction = obj => serializer.Serialize((T)obj), DeserializeFunction = (data, _) => serializer.Deserialize(data) }; }
public void Deserialize(ITypeSerializer handler, DataCollection data) { handler.Deserialize(this, data); foreach (var p in tempIncludes) { LocalIncludeCache.Add(p); } // Parse local includes DCompilerConfiguration.UpdateParseCacheAsync(LocalIncludeCache); }
public void TypeSerializer(Type type, ITypeSerializer typeSerializer) { for (var i = 0; i < 100000; i++) { var serializedType = typeSerializer.Serialize(type); _testOutputHelper.WriteLine(serializedType); var deserializedType = typeSerializer.Deserialize(serializedType); Assert.Equal(type, deserializedType); } }
public void Deserialize(ITypeSerializer handler, DataCollection data) { handler.Deserialize((object)this, data); foreach (DataNode dataNode in data) { DataItem dataItem = dataNode as DataItem; if (dataItem != null) { this.Timelines.Add(handler.SerializationContext.Serializer.DataContext.GetConfigurationDataType(dataNode.Name).Deserialize(handler.SerializationContext, (object)null, (DataNode)dataItem) as TimelineData); } } this.ExtendedProperties.Clear(); }
public object ReadArray(System.IO.Stream stream, int length, ITypeSerializer serializer) { int index = 0; var array = new BTCls[length]; while (index < length) { var obj = serializer.Deserialize(stream); array[index++] = (BTCls)obj; } return(array); }
void ICustomDataItem.Deserialize (ITypeSerializer handler, DataCollection data) { handler.Deserialize (this, data); if (data["Url"] == null) { string dir = ((DataValue)data ["Dir"]).Value; string user = ((DataValue)data ["User"]).Value; string server = ((DataValue)data ["Server"]).Value; string method = ((DataValue)data ["Method"]).Value; int port = int.Parse (((DataValue)data ["Port"]).Value); UriBuilder ub = new UriBuilder (method, server, port, dir); url = ub.ToString (); } CreateUri (); }
public void Deserialize(ITypeSerializer handler, DataCollection data) { handler.Deserialize(this, data); foreach (DataNode dataNode in data) { DataItem dataItem = dataNode as DataItem; if (dataItem != null) { DataType configurationDataType = handler.SerializationContext.Serializer.DataContext.GetConfigurationDataType(dataNode.Name); TimelineData item = configurationDataType.Deserialize(handler.SerializationContext, null, dataItem) as TimelineData; this.Timelines.Add(item); } } base.ExtendedProperties.Clear(); }
void ICustomDataItem.Deserialize(ITypeSerializer handler, DataCollection data) { handler.Deserialize(this, data); if (data["Url"] == null) { string dir = ((DataValue)data ["Dir"]).Value; string user = ((DataValue)data ["User"]).Value; string server = ((DataValue)data ["Server"]).Value; string method = ((DataValue)data ["Method"]).Value; int port = int.Parse(((DataValue)data ["Port"]).Value); UriBuilder ub = new UriBuilder(method, server, port, dir); url = ub.ToString(); } CreateUri(); }
/// <summary> /// 将Base64字符串反序列化成对象 /// </summary> /// <param name="base64String"></param> /// <returns></returns> public static T GetSerializerData(string base64String) { try { var data = Base64Serialzier.FromBase64String(base64String); data = instance.Decode(data); using (var stream = new MemoryStream(data)) { return(serializer.Deserialize(stream) as T); } } catch //(Exception ex) { } return(null); }
/// <summary> /// Adds the objects found in the stream to given model /// </summary> /// <param name="reader"></param> public List <IModelObject> Deserialize(StreamReader reader) { var ret = new List <IModelObject>(); var strm = new SectionedStreamReader(reader); while (strm.CurrentSection == ObjectsSection) { var id = int.Parse(strm.ReadLine()); var typeName = strm.ReadLine(); var type = typeSerializer.Deserialize(typeName); if (type == null) { Console.WriteLine("Unexisting type: " + typeName); continue; } try { var obj = (IModelObject)Activator.CreateInstance(type); myObjectDictionary.setObjectID(obj, id); ret.Add(obj); } catch (Exception ex) { DI.Get <IErrorLogger>().Log(ex, "Cant create model object"); } } while (strm.CurrentSection == AttributesSection) { var id = int.Parse(strm.ReadLine()); var obj = myObjectDictionary.getObjectByID(id); if (obj == null) { Console.WriteLine("Unknown object with ID: " + id); // Can be caused by corrupt save, or by an unexisting type for which the object was not loaded. continue; } DeserializeAttributes(obj, strm); } return(ret); }
protected virtual void DeserializeAttribMember(XmlReader reader, TypeInfo info, Dictionary <TypeMemberInfo, object> memberValues) { if (reader == null) { throw new ArgumentNullException("reader"); } if (info == null) { throw new ArgumentNullException("info"); } if (memberValues == null) { throw new ArgumentNullException("memberValues"); } if (!info.MemberInfoByEntityName.ContainsKey(reader.Name)) { return; } if (!info.MemberInfoByEntityName[reader.Name].IsAttribute) { return; } var memberInfo = info.MemberInfoByEntityName[reader.Name]; // Attempt to fetch a custom type serializer ITypeSerializer typeSerializer = Factory.CallMethod(new[] { memberInfo.DataType }, "GetTypeSerializer") as ITypeSerializer; if (typeSerializer != null) { memberValues[memberInfo] = typeSerializer.Deserialize(reader, memberInfo.DataType); } else // Since there was no bound custom type serializer we default to the GenericTypeSerializer { var defaultSerializer = Factory.GetDefaultSerializer(); memberValues[memberInfo] = defaultSerializer.Deserialize(reader, memberInfo.DataType); } }
public object ReadBody(VoxBinaryReader reader) { var length = reader.ReadVariableInt(); reader.HandleEnterInnerBuffer(length); try { var slotCount = reader.ReadVariableInt(); var readerThing = new ReaderThing(thisIsTotesTheRealLegitThingReaderWriterThing, reader, slotCount); try { var subject = Activator.CreateInstance(typeof(TUserType)); userTypeSerializer.Deserialize(readerThing, (TUserType)subject); return(subject); } catch (Exception e) { logger.Error($"Failed to instantiate or deserialize instance of type {typeof(TUserType).Name}."); throw; } } finally { reader.HandleLeaveInnerBuffer(); } }
public void Deserialize(ITypeSerializer handler, DataCollection data) { string baseFile = handler.SerializationContext.BaseFile; handler.Deserialize((object)this, data); handler.SerializationContext.BaseFile = (string)this.BaseDirectory.Combine(new string[1] { "TempAppendFileName.Folder" }); foreach (DataNode dataNode in data) { DataItem dataItem = dataNode as DataItem; if (dataItem != null) { this.Items.Add(handler.SerializationContext.Serializer.DataContext.GetConfigurationDataType(dataNode.Name).Deserialize(handler.SerializationContext, (object)null, (DataNode)dataItem) as ResourceItem); } } this.ExtendedProperties.Clear(); handler.SerializationContext.BaseFile = baseFile; }
public void Deserialize(ITypeSerializer handler, DataCollection data) { DataItem item = new DataItem(); item.Name = "SolutionConfiguration"; DataCollection col = item.ItemData; foreach (DataNode val in data) { if (val.Name != "name" && val.Name != "ctype" && val.Name != "Entry") { col.Add(val); } } handler.Deserialize(this, data); if (data.Count > 0) { solutionConfiguration = new SolutionConfiguration(name); handler.SerializationContext.Serializer.Deserialize(solutionConfiguration, item); } }
public T ContentAs <T>(int index) { var response = _bytes; var statusOffset = 24;//Header.BodyOffset; var valueLengthOffset = statusOffset + 2; var valueOffset = statusOffset + 6; var operationSpecs = new List <OperationSpec>(); for (;;) { var bodyLength = _converter.ToInt32(response, valueLengthOffset); var payLoad = new byte[bodyLength]; Buffer.BlockCopy(response, valueOffset, payLoad, 0, bodyLength); var command = new OperationSpec { Status = (ResponseStatus)_converter.ToUInt16(response, statusOffset), ValueIsJson = payLoad.IsJson(0, bodyLength - 1), Bytes = payLoad }; operationSpecs.Add(command); statusOffset = valueOffset + bodyLength; valueLengthOffset = statusOffset + 2; valueOffset = statusOffset + 6; if (valueOffset >= response.Length) { break; } } var spec = operationSpecs[index]; return(_serializer.Deserialize <T>(spec.Bytes, 0, spec.Bytes.Length)); }
// if MtouchDebug element is not present, this handler migrates args // and sets default values for the new Mtouch* properties public void Deserialize(ITypeSerializer handler, DataCollection data) { var argsToMigrate = data.Extract("ExtraMtouchArgs") as DataValue; var mtouchDebugData = data.Extract("MtouchDebug") as DataValue; handler.Deserialize(this, data); if (mtouchDebugData == null || string.IsNullOrEmpty(mtouchDebugData.Value)) { if (Name == "Debug") { MtouchDebug = true; if (IsSimPlatform) { MtouchLink = MtouchLinkMode.None; } } if (argsToMigrate != null && string.IsNullOrEmpty(argsToMigrate.Value)) { if (argsToMigrate.Value.Contains("-debug")) { MtouchDebug = true; } if (argsToMigrate.Value.Contains("-nolink")) { MtouchLink = MtouchLinkMode.None; } MtouchExtraArgs = new StringBuilder(argsToMigrate.Value) .Replace("-nolink", "").Replace("-linksdkonly", "").Replace("-debug", "").Replace(" ", " ") .ToString(); } } else { MtouchDebug = mtouchDebugData.Value.Equals("true", StringComparison.OrdinalIgnoreCase); } }
public void Deserialize (object obj, ITypeSerializer handler, DataCollection data) { handler.Deserialize (obj, data); }
// if MtouchDebug element is not present, this handler migrates args // and sets default values for the new Mtouch* properties public void Deserialize (ITypeSerializer handler, DataCollection data) { var argsToMigrate = data.Extract ("ExtraMtouchArgs") as DataValue; var mtouchDebugData = data.Extract ("MtouchDebug") as DataValue; handler.Deserialize (this, data); if (mtouchDebugData == null || string.IsNullOrEmpty (mtouchDebugData.Value)) { if (Name == "Debug") { MtouchDebug = true; if (Platform == IPhoneProject.PLAT_SIM) MtouchLink = MtouchLinkMode.None; } if (argsToMigrate != null && string.IsNullOrEmpty (argsToMigrate.Value)) { if (argsToMigrate.Value.Contains ("-debug")) MtouchDebug = true; if (argsToMigrate.Value.Contains ("-nolink")) MtouchLink = MtouchLinkMode.None; MtouchExtraArgs = new StringBuilder (argsToMigrate.Value) .Replace ("-nolink", "").Replace ("-linksdkonly", "").Replace ("-debug", "").Replace (" ", " ") .ToString (); } } else { MtouchDebug = mtouchDebugData.Value.Equals ("true", StringComparison.OrdinalIgnoreCase); } }
public virtual void Deserialize(ITypeSerializer handler, DataCollection data) { DataValue ac = null; DataItem confItem = data ["Configurations"] as DataItem; if (confItem != null) ac = (DataValue) confItem.ItemData.Extract ("active"); handler.Deserialize (this, data); if (ac != null) activeConfiguration = GetConfiguration (ac.Value); }
public static T?Deserialize <T>(this ITypeSerializer typeSerializer, byte[] buffer, int offset, int length) { return(typeSerializer.Deserialize <T>(buffer.AsMemory(offset, length))); }
public void Deserialize(ITypeSerializer handler, DataCollection data) { handler.Deserialize(this, data); foreach (var p in tempIncludes) LocalIncludeCache.Add(p); // Parse local includes DCompilerConfiguration.UpdateParseCacheAsync(LocalIncludeCache); }
public T ContentAs <T>(int index) { var spec = _specs[index]; return(_serializer.Deserialize <T>(spec.Bytes)); }
void ICustomDataItem.Deserialize(ITypeSerializer handler, DataCollection data) { DataValue refto = data.Extract ("refto") as DataValue; handler.Deserialize (this, data); if (refto != null) { reference = refto.Value; if (referenceType == ReferenceType.Assembly) { string basePath = Path.GetDirectoryName (handler.SerializationContext.BaseFile); reference = Runtime.FileUtilityService.RelativeToAbsolutePath (basePath, reference); } } }
public void Deserialize (ITypeSerializer handler, DataCollection data) { DataItem item = new DataItem (); item.Name = "SolutionConfiguration"; DataCollection col = item.ItemData; foreach (DataNode val in data) { if (val.Name != "name" && val.Name != "ctype" && val.Name != "Entry") col.Add (val); } handler.Deserialize (this, data); if (data.Count > 0) { solutionConfiguration = new SolutionConfiguration (name); handler.SerializationContext.Serializer.Deserialize (solutionConfiguration, item); } }
public void Deserialize (object obj, ITypeSerializer handler, DataCollection data) { //find whether is was marked as FileCopy DataValue value = data ["buildaction"] as DataValue; bool isFileCopy = value != null && value.Value == "FileCopy"; handler.Deserialize (obj, data); ProjectFile file = (ProjectFile) obj; //if it wasn't, no fancy migrations to do if (!isFileCopy) return; //if there were any deploy settings remaining in the project file, then the file isn't "copy to output" //but instead should be marked to deploy foreach (string key in keys) { if (file.ExtendedProperties.Contains (key)) { file.CopyToOutputDirectory = FileCopyMode.None; file.ExtendedProperties ["DeployService.Deploy"] = true; return; } } }
public virtual void Deserialize(object obj, ITypeSerializer handler, DataCollection data) { if (obj is ProjectFile) { ProjectFile pf = (ProjectFile)obj; //Map the old FileCopy action to the Content BuildAction with CopyToOutputDirectory set to "always" //BuildActionDataType handles mapping the BuildAction to "Content" DataValue value = data ["buildaction"] as DataValue; bool isFileCopy = value != null && value.Value == "FileCopy"; DataValue resourceId = data.Extract("resource_id") as DataValue; handler.Deserialize(obj, data); if (isFileCopy) { pf.CopyToOutputDirectory = FileCopyMode.Always; } if (resourceId != null) { pf.ResourceId = resourceId.Value; } } else if (obj is SolutionEntityItem) { DataValue ac = null; DataItem confItem = data ["Configurations"] as DataItem; if (confItem != null) { ac = (DataValue)confItem.ItemData.Extract("active"); } DataItem items = data.Extract("Items") as DataItem; if (items != null) { ReadItems(handler, (SolutionEntityItem)obj, items); } handler.Deserialize(obj, data); if (ac != null) { SolutionEntityItem item = (SolutionEntityItem)obj; item.DefaultConfigurationId = ac.Value; } DotNetProject np = obj as DotNetProject; if (np != null) { // Import the framework version TargetFrameworkMoniker fx = null; DataValue vfx = data["targetFramework"] as DataValue; if (vfx != null) { fx = TargetFrameworkMoniker.Parse(vfx.Value); } else { vfx = data ["clr-version"] as DataValue; if (vfx != null && vfx.Value == "Net_2_0") { fx = TargetFrameworkMoniker.NET_2_0; } else if (vfx != null && vfx.Value == "Net_1_1") { fx = TargetFrameworkMoniker.NET_1_1; } } if (fx != null) { np.TargetFramework = Runtime.SystemAssemblyService.GetTargetFramework(fx); } // Get the compile target from one of the configurations if (np.Configurations.Count > 0) { np.CompileTarget = (CompileTarget)Enum.Parse(typeof(CompileTarget), (string)np.Configurations [0].ExtendedProperties ["Build/target"]); } } } else if (obj is ProjectReference) { ProjectReference pref = (ProjectReference)obj; DataValue refto = data.Extract("refto") as DataValue; handler.Deserialize(obj, data); if (refto != null) { pref.Reference = refto.Value; if (pref.ReferenceType == ReferenceType.Assembly) { string basePath = Path.GetDirectoryName(handler.SerializationContext.BaseFile); pref.Reference = FileService.RelativeToAbsolutePath(basePath, pref.Reference); } } } else { handler.Deserialize(obj, data); } }
public void Deserialize(ITypeSerializer handler, DataCollection data) { handler.Deserialize(this, data); }
public void Deserialize(ITypeSerializer handler, DataCollection data) { handler.Deserialize (this, data); foreach (var p in tempIncludes) LocalIncludeCache.ParsedDirectories.Add (ProjectBuilder.EnsureCorrectPathSeparators (p)); }
public virtual void Deserialize (object obj, ITypeSerializer handler, DataCollection data) { if (obj is ProjectFile) { ProjectFile pf = (ProjectFile) obj; //Map the old FileCopy action to the Content BuildAction with CopyToOutputDirectory set to "always" //BuildActionDataType handles mapping the BuildAction to "Content" DataValue value = data ["buildaction"] as DataValue; bool isFileCopy = value != null && value.Value == "FileCopy"; DataValue resourceId = data.Extract ("resource_id") as DataValue; handler.Deserialize (obj, data); if (isFileCopy) pf.CopyToOutputDirectory = FileCopyMode.Always; if (resourceId != null) pf.ResourceId = resourceId.Value; } else if (obj is SolutionEntityItem) { DataValue ac = null; DataItem confItem = data ["Configurations"] as DataItem; if (confItem != null) ac = (DataValue) confItem.ItemData.Extract ("active"); DataItem items = data.Extract ("Items") as DataItem; if (items != null) ReadItems (handler, (SolutionEntityItem)obj, items); handler.Deserialize (obj, data); if (ac != null) { SolutionEntityItem item = (SolutionEntityItem) obj; item.DefaultConfigurationId = ac.Value; } DotNetProject np = obj as DotNetProject; if (np != null) { // Import the framework version TargetFrameworkMoniker fx = null; DataValue vfx = data["targetFramework"] as DataValue; if (vfx != null) fx = TargetFrameworkMoniker.Parse (vfx.Value); else { vfx = data ["clr-version"] as DataValue; if (vfx != null && vfx.Value == "Net_2_0") fx = TargetFrameworkMoniker.NET_2_0; else if (vfx != null && vfx.Value == "Net_1_1") fx = TargetFrameworkMoniker.NET_1_1; } if (fx != null) np.TargetFramework = Runtime.SystemAssemblyService.GetTargetFramework (fx); // Get the compile target from one of the configurations if (np.Configurations.Count > 0) np.CompileTarget = (CompileTarget) Enum.Parse (typeof(CompileTarget), (string) np.Configurations [0].ExtendedProperties ["Build/target"]); } } else if (obj is ProjectReference) { ProjectReference pref = (ProjectReference) obj; DataValue refto = data.Extract ("refto") as DataValue; handler.Deserialize (obj, data); if (refto != null) { pref.Reference = refto.Value; if (pref.ReferenceType == ReferenceType.Assembly) { string basePath = Path.GetDirectoryName (handler.SerializationContext.BaseFile); pref.Reference = FileService.RelativeToAbsolutePath (basePath, pref.Reference); } } } else handler.Deserialize (obj, data); }
/// <summary> /// Maps a single row. /// </summary> /// <typeparam name="T">The <see cref="IViewResult{T}"/>'s Type paramater.</typeparam> /// <param name="stream">The <see cref="Stream"/> results of the query.</param> /// <returns>An object deserialized to it's T type.</returns> public T Map <T>(Stream stream) { return(_serializer.Deserialize <T>(stream)); }
public void Deserialize(ITypeSerializer handler, DataCollection data) { handler.Deserialize (this, data); referenceCollection.InitRefCollection (tempProjectDependencies, tempIncludes); }
void ICustomDataItem.Deserialize (ITypeSerializer handler, DataCollection data) { DataItem items = (DataItem) data.Extract ("Items"); handler.Deserialize (this, data); ProgressMonitor monitor = handler.SerializationContext.ProgressMonitor; if (monitor == null) monitor = new ProgressMonitor (); if (items != null) { string baseDir = Path.GetDirectoryName (handler.SerializationContext.BaseFile); monitor.BeginTask (null, items.ItemData.Count); try { foreach (DataValue item in items.ItemData) { string file = Path.Combine (baseDir, item.Value); WorkspaceItem it = Services.ProjectService.ReadWorkspaceItem (monitor, file).Result; if (it != null) Items.Add (it); monitor.Step (1); } } finally { monitor.EndTask (); } } }