public override void ReadSlnData (DataItem item)
{
// Remove the default configuration, since new ones will be loaded
CompiledAssemblyProject project = (CompiledAssemblyProject) EntityItem;
project.Configurations.Clear ();
DataSerializer ser = new DataSerializer (MSBuildProjectService.DataContext);
ser.SerializationContext.BaseFile = EntityItem.FileName;
ser.SerializationContext.DirectorySeparatorChar = '\\';
ser.Deserialize (project, item);
}
public void Deserialize(ITypeSerializer handler, DataCollection data)
{
handler.Deserialize((object)this, data);
foreach (DataNode dataNode in data)
{
MonoDevelop.Core.Serialization.DataItem dataItem = dataNode as MonoDevelop.Core.Serialization.DataItem;
if (dataItem != null)
{
this.Frames.Add(handler.SerializationContext.Serializer.DataContext.GetConfigurationDataType(dataNode.Name).Deserialize(handler.SerializationContext, (object)null, (DataNode)dataItem) as FrameData);
}
}
this.ExtendedProperties.Clear();
}
public void Deserialize(ITypeSerializer handler, DataCollection data)
{
handler.Deserialize(this, data);
foreach (DataNode dataNode in data)
{
MonoDevelop.Core.Serialization.DataItem dataItem = dataNode as MonoDevelop.Core.Serialization.DataItem;
if (dataItem != null)
{
DataType configurationDataType = handler.SerializationContext.Serializer.DataContext.GetConfigurationDataType(dataNode.Name);
FrameData item = configurationDataType.Deserialize(handler.SerializationContext, null, dataItem) as FrameData;
this.Frames.Add(item);
}
}
base.ExtendedProperties.Clear();
}
internal void UpdateFromItem (DataItem item, HashSet<DataItem> removedItems)
{
var counter = new Dictionary<string, int> ();
foreach (var d in item.ItemData) {
DataNode current = null;
DataCollection col;
if (!counter.ContainsKey (d.Name))
counter [d.Name] = 0;
var index = ItemData.FindData (d.Name, out col, false, counter[d.Name]);
counter [d.Name]++;
if (index != -1) {
current = col [index];
}
if (current != null) {
if (d.IsDefaultValue || d is DataDeletedNode) {
if (current is DataItem)
removedItems.Add ((DataItem)current);
ItemData.Remove (current);
} else if (current.GetType () != d.GetType () || current is DataValue) {
var i = ItemData.IndexOf (current);
ItemData [i] = d;
if (current is DataItem)
removedItems.Add ((DataItem)current);
} else if (current is DataItem) {
((DataItem)current).UpdateFromItem ((DataItem)d, removedItems);
}
} else if (!d.IsDefaultValue && !(d is DataDeletedNode)) {
var dataItem = d as DataItem;
if (dataItem != null) {
var newDataItem = new DataItem () {
Name = d.Name,
UniqueNames = dataItem.UniqueNames
};
newDataItem.UpdateFromItem (dataItem, removedItems);
ItemData.Add (newDataItem);
} else {
ItemData.Add (d);
}
}
}
}
internal void UpdateFromItem (DataItem item, HashSet<DataItem> removedItems)
{
foreach (var d in item.ItemData) {
var current = ItemData[d.Name];
if (current != null) {
if (d.IsDefaultValue || d is DataDeletedNode) {
if (current is DataItem)
removedItems.Add ((DataItem)current);
ItemData.Remove (current);
}
else if (current.GetType () != d.GetType () || current is DataValue) {
var i = ItemData.IndexOf (current);
ItemData [i] = d;
if (current is DataItem)
removedItems.Add ((DataItem)current);
} else if (current is DataItem) {
((DataItem)current).UpdateFromItem ((DataItem)d, removedItems);
}
} else if (!d.IsDefaultValue && !(d is DataDeletedNode)) {
ItemData.Add (d);
}
}
}
void WriteDataItem (StreamWriter sw, DataItem item)
{
int id = 0;
foreach (DataNode val in item.ItemData)
WriteDataNode (sw, "", val, ref id);
}
protected virtual DataNode ReadChild (XmlElement elem, DataItem parent)
{
return GetChildReader (parent).Read (elem);
}
protected virtual XmlConfigurationReader GetChildReader (DataItem parent)
{
return this;
}
public void Deserialize(object obj, DataItem data)
{
dataContext.SetConfigurationItemData(serializationContext, obj, data);
}
public DataNode Read (XmlReader reader)
{
DataItem item = new DataItem ();
item.UniqueNames = false;
reader.MoveToContent ();
string name = reader.LocalName;
item.Name = name;
while (reader.MoveToNextAttribute ()) {
if (reader.LocalName == "xmlns")
continue;
DataNode data = ReadAttribute (reader.LocalName, reader.Value);
if (data != null) {
DataValue val = data as DataValue;
if (val != null)
val.StoreAsAttribute = true;
item.ItemData.Add (data);
}
}
reader.MoveToElement ();
if (reader.IsEmptyElement) {
reader.Skip ();
return item;
}
reader.ReadStartElement ();
reader.MoveToContent ();
string text = "";
while (reader.NodeType != XmlNodeType.EndElement) {
if (reader.NodeType == XmlNodeType.Element) {
DataNode data = ReadChild (reader, item);
if (data != null) item.ItemData.Add (data);
} else if (reader.NodeType == XmlNodeType.Text) {
text += reader.Value;
reader.Skip ();
} else {
reader.Skip ();
}
}
reader.ReadEndElement ();
if (!item.HasItemData && text != "")
return new DataValue (name, text);
return item;
}
public void SetConfigurationItemData (SerializationContext serCtx, object obj, DataItem data)
{
ClassDataType dataType = (ClassDataType) GetConfigurationDataType (obj.GetType ());
dataType.Deserialize (serCtx, null, data, obj);
}
protected virtual DataNode ReadChild(XmlReader reader, DataItem parent)
{
return(GetChildReader(parent).Read(reader));
}
public void SetConfigurationItemData(SerializationContext serCtx, object obj, DataItem data)
{
ClassDataType dataType = (ClassDataType)GetConfigurationDataType(obj.GetType());
dataType.Deserialize(serCtx, null, data, obj);
}
public void Deserialize (object obj, DataItem data)
{
dataContext.SetConfigurationItemData (serializationContext, obj, data);
}
void Deserialize(SerializationContext serCtx, object obj, DataCollection itemData, DataItem ukwnDataRoot, string baseName)
{
Hashtable expandedCollections = null;
foreach (DataNode value in itemData)
{
ItemProperty prop = (ItemProperty)properties [baseName + value.Name];
if (prop == null)
{
if (value is DataItem)
{
DataItem root = new DataItem();
root.Name = value.Name;
root.UniqueNames = ((DataItem)value).UniqueNames;
if (ukwnDataRoot != null)
{
ukwnDataRoot.ItemData.Add(root);
}
Deserialize(serCtx, obj, ((DataItem)value).ItemData, root, baseName + value.Name + "/");
// If no unknown data has been added, there is no need to keep this
// in the unknown items list.
if (ukwnDataRoot != null && !root.HasItemData)
{
ukwnDataRoot.ItemData.Remove(root);
}
}
else if (obj is IExtendedDataItem && (value.Name != "ctype" || baseName.Length > 0))
{
// store unreadable raw data to a special property so it can be
// serialized back an the original format is kept
// The ctype attribute don't need to be stored for the root object, since
// it is generated by the serializer
ukwnDataRoot.ItemData.Add(value);
}
continue;
}
if (prop.WriteOnly || !prop.CanDeserialize(serCtx, obj))
{
continue;
}
try {
if (prop.ExpandedCollection)
{
ICollectionHandler handler = prop.ExpandedCollectionHandler;
if (expandedCollections == null)
{
expandedCollections = new Hashtable();
}
object pos, col;
if (!expandedCollections.ContainsKey(prop))
{
col = handler.CreateCollection(out pos, -1);
}
else
{
pos = expandedCollections [prop];
col = prop.GetValue(obj);
}
handler.AddItem(ref col, ref pos, prop.Deserialize(serCtx, obj, value));
expandedCollections [prop] = pos;
prop.SetValue(obj, col);
}
else
{
if (prop.HasSetter && prop.DataType.CanCreateInstance)
{
prop.SetValue(obj, prop.Deserialize(serCtx, obj, value));
}
else if (prop.DataType.CanReuseInstance)
{
object pval = prop.GetValue(obj);
if (pval == null)
{
if (prop.HasSetter)
{
throw new InvalidOperationException("The property '" + prop.Name + "' is null and a new instance of '" + prop.PropertyType + "' can't be created.");
}
else
{
throw new InvalidOperationException("The property '" + prop.Name + "' is null and it does not have a setter.");
}
}
prop.Deserialize(serCtx, obj, value, pval);
}
else
{
throw new InvalidOperationException("The property does not have a setter.");
}
}
}
catch (Exception ex) {
throw new InvalidOperationException("Could not set property '" + prop.Name + "' in type '" + Name + "'", ex);
}
}
}
protected virtual XmlConfigurationReader GetChildReader(DataItem parent)
{
return(this);
}
internal protected override object OnDeserialize(SerializationContext serCtx, object mapData, DataNode data)
{
DataItem item = data as DataItem;
if (item == null)
{
throw new InvalidOperationException("Invalid value found for type '" + Name + "' " + data);
}
DataValue ctype = item ["ctype"] as DataValue;
if (ctype != null && ctype.Value != Name)
{
bool isFallbackType;
DataType stype = FindDerivedType(ctype.Value, mapData, out isFallbackType);
if (isFallbackType)
{
// Remove the ctype attribute, to make sure it is not checked again
// by the fallback type
item.ItemData.Remove(ctype);
}
if (stype != null)
{
DataNode desData = data;
if (stype.IsSimpleType)
{
desData = item.ItemData ["Value"];
if (desData == null)
{
throw new InvalidOperationException("Value node not found");
}
}
object sobj = stype.Deserialize(serCtx, mapData, desData);
// Store the original data type, so it can be serialized back
if (isFallbackType && sobj is IExtendedDataItem)
{
((IExtendedDataItem)sobj).ExtendedProperties ["__raw_ctype"] = ctype.Value;
}
return(sobj);
}
else
{
throw new InvalidOperationException("Type not found: " + ctype.Value);
}
}
ConstructorInfo ctor = ValueType.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, Type.EmptyTypes, null);
if (ctor == null)
{
throw new InvalidOperationException("Default constructor not found for type '" + ValueType + "'");
}
object obj = ctor.Invoke(null);
Deserialize(serCtx, null, item, obj);
return(obj);
}
internal DataCollection Serialize(SerializationContext serCtx, object obj)
{
DataCollection itemCol = new DataCollection();
foreach (ItemProperty prop in Properties)
{
if (prop.ReadOnly || !prop.CanSerialize(serCtx, obj))
{
continue;
}
object val = prop.GetValue(obj);
if (val == null)
{
continue;
}
if (!serCtx.IsDefaultValueSerializationForced(prop) && val.Equals(prop.DefaultValue))
{
continue;
}
DataCollection col = itemCol;
if (prop.IsNested)
{
col = GetNestedCollection(col, prop.NameList, 0);
}
if (prop.ExpandedCollection)
{
ICollectionHandler handler = prop.ExpandedCollectionHandler;
object pos = handler.GetInitialPosition(val);
while (handler.MoveNextItem(val, ref pos))
{
object item = handler.GetCurrentItem(val, pos);
if (item == null)
{
continue;
}
DataNode data = prop.Serialize(serCtx, obj, item);
data.Name = prop.SingleName;
col.Add(data);
}
}
else
{
DataNode data = prop.Serialize(serCtx, obj, val);
if (data == null)
{
continue;
}
col.Add(data);
}
}
if (obj is IExtendedDataItem)
{
// Serialize raw data which could not be deserialized
DataItem uknData = (DataItem)((IExtendedDataItem)obj).ExtendedProperties ["__raw_data"];
if (uknData != null)
{
itemCol.Merge(uknData.ItemData);
}
}
return(itemCol);
}
public object CreateInstance(Type type, DataItem data)
{
return(dataContext.CreateConfigurationData(serializationContext, type, data));
}
bool ReadDataNode (DataItem item, List<string> lines, int lastLine, string prefix, ref int lineNum)
{
string s = lines [lineNum].Trim (' ','\t');
if (s.Length == 0) {
lineNum++;
return true;
}
// Check if the line belongs to the current item
if (prefix.Length > 0) {
if (!s.StartsWith (prefix + "."))
return false;
s = s.Substring (prefix.Length + 1);
} else {
if (s.StartsWith ("$"))
return false;
}
int i = s.IndexOf ('=');
if (i == -1) {
lineNum++;
return true;
}
string name = s.Substring (0, i).Trim (' ','\t');
if (name.Length == 0) {
lineNum++;
return true;
}
string value = s.Substring (i+1).Trim (' ','\t');
if (value.StartsWith ("$")) {
// New item
DataItem child = new DataItem ();
child.Name = name;
lineNum++;
while (lineNum <= lastLine) {
if (!ReadDataNode (child, lines, lastLine, value, ref lineNum))
break;
}
item.ItemData.Add (child);
}
else {
value = DecodeString (value);
DataValue val = new DataValue (name, value);
item.ItemData.Add (val);
lineNum++;
}
return true;
}
void ReadItems (ITypeSerializer handler, SolutionEntityItem item, DataItem items)
{
foreach (DataNode node in items.ItemData) {
DataType dtype = handler.SerializationContext.Serializer.DataContext.GetConfigurationDataType (node.Name);
if (dtype != null && typeof(ProjectItem).IsAssignableFrom (dtype.ValueType)) {
ProjectItem it = (ProjectItem) handler.SerializationContext.Serializer.Deserialize (dtype.ValueType, node);
item.Items.Add (it);
}
}
}
protected virtual DataNode ReadChild(XmlElement elem, DataItem parent)
{
return(GetChildReader(parent).Read(elem));
}
internal protected override DataNode OnSerialize (SerializationContext serCtx, object mdata, object collection)
{
MapData mapData = (mdata != null) ? (MapData) mdata : GetDefaultData ();
DataItem colItem = new DataItem ();
colItem.Name = Name;
colItem.UniqueNames = false;
IDictionary dict = (IDictionary) collection;
foreach (DictionaryEntry e in dict) {
DataItem item = new DataItem ();
item.Name = mapData.ItemName;
item.UniqueNames = true;
DataNode key = mapData.KeyType.Serialize (serCtx, null, e.Key);
key.Name = mapData.KeyName;
DataNode value = mapData.ValueType.Serialize (serCtx, null, e.Value);
value.Name = mapData.ValueName;
item.ItemData.Add (key);
item.ItemData.Add (value);
colItem.ItemData.Add (item);
}
return colItem;
}
public void SetTypeInfo (DataItem item, Type type)
{
item.ItemData.Add (new DataValue ("ctype", GetConfigurationDataType (type).Name));
}
protected virtual void WriteAttributes (XmlWriter writer, DataItem item)
{
foreach (DataNode data in item.ItemData) {
DataValue val = data as DataValue;
if (val != null && (item.UniqueNames || val.StoreAsAttribute) && StoreAsAttribute (val))
WriteAttribute (writer, val.Name, val.Value);
}
}
public void SetTypeInfo(DataItem item, Type type)
{
item.ItemData.Add(new DataValue("ctype", GetConfigurationDataType(type).Name));
}
internal int FindData(string name, out DataCollection colec, bool buildTree, int skipCount)
{
if (name.IndexOf('/') == -1)
{
for (int n = 0; n < Items.Count; n++)
{
DataNode data = Items [n];
if (data.Name == name)
{
if (skipCount > 0)
{
skipCount--;
continue;
}
colec = this;
return(n);
}
}
colec = this;
return(-1);
}
else
{
string[] names = name.Split('/');
int pos = -1;
colec = this;
DataNode data = null;
for (int p = 0; p < names.Length; p++)
{
if (p > 0)
{
DataItem item = data as DataItem;
if (item != null)
{
colec = item.ItemData;
}
else if (buildTree)
{
item = new DataItem();
item.Name = names [p - 1];
colec.Add(item);
colec = item.ItemData;
}
else
{
colec = null;
return(-1);
}
}
pos = -1;
for (int n = 0; n < colec.Count; n++)
{
data = colec [n];
if (data.Name == names [p])
{
pos = n; break;
}
}
}
return(pos);
}
}
public object CreateInstance (Type type, DataItem data)
{
return dataContext.CreateConfigurationData (serializationContext, type, data);
}
protected override XmlConfigurationReader GetChildReader(MonoDevelop.Core.Serialization.DataItem parent)
{
// Don't reuse this serializer for children, since it has solution-specific serialization code
return(XmlConfigurationReader.DefaultReader);
}
void WriteItems (ITypeSerializer handler, SolutionEntityItem item, DataCollection data)
{
DataItem items = new DataItem ();
items.Name = "Items";
foreach (object it in item.Items) {
if (it is ProjectFile || it is ProjectReference)
continue; // Already handled by serializer
DataNode node = handler.SerializationContext.Serializer.Serialize (it, it.GetType ());
items.ItemData.Add (node);
}
if (items.HasItemData)
data.Add (items);
}
static void WriteDataItem (SlnSection pset, DataItem item)
{
HashSet<DataItem> removedItems = new HashSet<DataItem> ();
Dictionary<DataNode,int> ids = new Dictionary<DataNode, int> ();
// First of all read the existing data item, since we want to keep data that has not been modified
// The ids collection is filled with a map of items and their ids
var currentItem = ReadDataItem (pset, ids);
// UpdateFromItem will add new data to the item, it will remove the data that has been removed, and
// will ignore unknown data that has not been set or removed
currentItem.UpdateFromItem (item, removedItems);
// List of IDs that are not used anymore and can be reused when writing the item
var unusedIds = new Queue<int> (removedItems.Select (it => ids[it]).OrderBy (i => i));
// Calculate the next free id, to be used when adding new items
var usedIds = ids.Where (p => !removedItems.Contains (p.Key)).Select (p => p.Value).ToArray ();
int nextId = usedIds.Length > 0 ? usedIds.Max () + 1 : 0;
var newSet = new List<KeyValuePair<string, string>> ();
foreach (DataNode val in currentItem.ItemData)
WriteDataNode (newSet, "", val, ids, unusedIds, ref nextId);
pset.SetContent (newSet);
}
protected virtual void WriteAttributes (XmlElement elem, DataItem item)
{
if (StoreAllInElements)
return;
foreach (DataNode data in item.ItemData) {
DataValue val = data as DataValue;
if (val != null && (item.UniqueNames || val.StoreAsAttribute))
WriteAttribute (elem, val.Name, val.Value);
}
}
static DataItem ReadDataItem (SlnSection pset, Dictionary<DataNode,int> ids)
{
DataItem it = new DataItem ();
var lines = pset.GetContent ().ToArray ();
int lineNum = 0;
int lastLine = lines.Length - 1;
while (lineNum <= lastLine) {
if (!ReadDataNode (it, lines, lastLine, "", ids, ref lineNum))
lineNum++;
}
return it;
}
protected virtual void WriteChildren (XmlElement elem, DataItem item)
{
if (item.UniqueNames) {
foreach (DataNode data in item.ItemData) {
if (!(data is DataValue) || !StoreAsAttribute ((DataValue)data))
WriteChild (elem, data);
}
} else {
foreach (DataNode data in item.ItemData) {
DataValue dval = data as DataValue;
if (dval == null || !dval.StoreAsAttribute || !StoreAsAttribute (dval))
WriteChild (elem, data);
}
}
}
static bool ReadDataNode (DataItem item, KeyValuePair<string,string>[] lines, int lastLine, string prefix, Dictionary<DataNode,int> ids, ref int lineNum)
{
var s = lines [lineNum];
string name = s.Key;
if (name.Length == 0) {
lineNum++;
return true;
}
// Check if the line belongs to the current item
if (prefix.Length > 0) {
if (!s.Key.StartsWith (prefix + ".", StringComparison.Ordinal))
return false;
name = s.Key.Substring (prefix.Length + 1);
} else {
if (s.Key.StartsWith ("$", StringComparison.Ordinal))
return false;
}
string value = s.Value;
if (value.StartsWith ("$", StringComparison.Ordinal)) {
// New item
DataItem child = new DataItem ();
child.Name = name;
int id;
if (ids != null && int.TryParse (value.Substring (1), out id))
ids [child] = id;
lineNum++;
while (lineNum <= lastLine) {
if (!ReadDataNode (child, lines, lastLine, value, ids, ref lineNum))
break;
}
item.ItemData.Add (child);
} else {
value = DecodeString (value);
DataValue val = new DataValue (name, value);
item.ItemData.Add (val);
lineNum++;
}
return true;
}
public DataNode Read (XmlElement elem)
{
DataItem item = new DataItem ();
item.UniqueNames = false;
item.Name = elem.LocalName;
foreach (XmlAttribute att in elem.Attributes) {
if (att.LocalName == "xmlns")
continue;
DataNode data = ReadAttribute (att.LocalName, att.Value);
if (data != null) {
DataValue val = data as DataValue;
if (val != null)
val.StoreAsAttribute = true;
item.ItemData.Add (data);
}
}
string text = "";
foreach (XmlNode node in elem.ChildNodes) {
if (node.NodeType == XmlNodeType.Element) {
DataNode data = ReadChild ((XmlElement)node, item);
if (data != null) item.ItemData.Add (data);
} else if (node.NodeType == XmlNodeType.Text) {
text += ((XmlText)node).Value;
}
}
if (!item.HasItemData && text != "")
return new DataValue (item.Name, text);
return item;
}
DataCollection GetNestedCollection (DataCollection col, string[] nameList, int pos, bool isDefault)
{
if (pos == nameList.Length - 1) return col;
DataItem item = col [nameList[pos]] as DataItem;
if (item == null) {
item = new DataItem ();
item.Name = nameList[pos];
col.Add (item);
item.IsDefaultValue = isDefault;
}
if (item.IsDefaultValue && !isDefault)
item.IsDefaultValue = false;
return GetNestedCollection (item.ItemData, nameList, pos + 1, isDefault);
}
protected virtual DataNode ReadChild (XmlReader reader, DataItem parent)
{
return GetChildReader (parent).Read (reader);
}
internal protected override DataNode OnSerialize (SerializationContext serCtx, object mapData, object obj)
{
string ctype = null;
if (obj.GetType () != ValueType) {
if (obj is IExtendedDataItem) {
// This is set by fallback types, to make sure the original type name is serialized back
ctype = (string) ((IExtendedDataItem)obj).ExtendedProperties ["__raw_ctype"];
}
if (ctype == null) {
DataType subtype = Context.GetConfigurationDataType (obj.GetType ());
DataNode n = subtype.Serialize (serCtx, mapData, obj);
DataItem it = n as DataItem;
if (it == null) {
it = new DataItem ();
n.Name = "Value";
it.ItemData.Add (n);
}
it.ItemData.Add (new DataValue ("ctype", subtype.Name));
it.Name = Name;
return it;
}
}
DataItem item = new DataItem ();
item.Name = Name;
ICustomDataItem citem = Context.AttributeProvider.GetCustomDataItem (obj);
if (citem != null) {
ClassTypeHandler handler = new ClassTypeHandler (serCtx, this);
item.ItemData = citem.Serialize (handler);
}
else
item.ItemData = Serialize (serCtx, obj);
if (ctype != null)
item.ItemData.Add (new DataValue ("ctype", ctype));
return item;
}
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);
}
}
DataCollection GetNestedCollection (DataCollection col, string[] nameList, int pos)
{
if (pos == nameList.Length - 1) return col;
DataItem item = col [nameList[pos]] as DataItem;
if (item == null) {
item = new DataItem ();
item.Name = nameList[pos];
col.Add (item);
}
return GetNestedCollection (item.ItemData, nameList, pos + 1);
}
DataItem ReadDataItem (int start, int count, List<string> lines)
{
DataItem it = new DataItem ();
int lineNum = start + 1;
int lastLine = start + count - 2;
while (lineNum <= lastLine) {
if (!ReadDataNode (it, lines, lastLine, "", ref lineNum))
lineNum++;
}
return it;
}
void Deserialize (SerializationContext serCtx, object obj, DataCollection itemData, DataItem ukwnDataRoot, string baseName)
{
Hashtable expandedCollections = null;
foreach (DataNode value in itemData) {
ItemProperty prop = (ItemProperty) properties [baseName + value.Name];
if (prop == null) {
if (value is DataItem) {
DataItem root = new DataItem ();
root.Name = value.Name;
root.UniqueNames = ((DataItem)value).UniqueNames;
if (ukwnDataRoot != null)
ukwnDataRoot.ItemData.Add (root);
Deserialize (serCtx, obj, ((DataItem)value).ItemData, root, baseName + value.Name + "/");
// If no unknown data has been added, there is no need to keep this
// in the unknown items list.
if (ukwnDataRoot != null && !root.HasItemData)
ukwnDataRoot.ItemData.Remove (root);
}
else if (obj is IExtendedDataItem && (value.Name != "ctype" || baseName.Length > 0)) {
// store unreadable raw data to a special property so it can be
// serialized back an the original format is kept
// The ctype attribute don't need to be stored for the root object, since
// it is generated by the serializer
ukwnDataRoot.ItemData.Add (value);
}
continue;
}
if (prop.WriteOnly || !prop.CanDeserialize (serCtx, obj))
continue;
try {
if (prop.ExpandedCollection) {
ICollectionHandler handler = prop.ExpandedCollectionHandler;
if (expandedCollections == null) expandedCollections = new Hashtable ();
object pos, col;
if (!expandedCollections.ContainsKey (prop)) {
col = handler.CreateCollection (out pos, -1);
} else {
pos = expandedCollections [prop];
col = prop.GetValue (obj);
}
handler.AddItem (ref col, ref pos, prop.Deserialize (serCtx, obj, value));
expandedCollections [prop] = pos;
prop.SetValue (obj, col);
}
else {
if (prop.HasSetter && prop.DataType.CanCreateInstance)
prop.SetValue (obj, prop.Deserialize (serCtx, obj, value));
else if (prop.DataType.CanReuseInstance) {
object pval = prop.GetValue (obj);
if (pval == null) {
if (prop.HasSetter)
throw new InvalidOperationException ("The property '" + prop.Name + "' is null and a new instance of '" + prop.PropertyType + "' can't be created.");
else
throw new InvalidOperationException ("The property '" + prop.Name + "' is null and it does not have a setter.");
}
prop.Deserialize (serCtx, obj, value, pval);
} else {
throw new InvalidOperationException ("The property does not have a setter.");
}
}
}
catch (Exception ex) {
throw new InvalidOperationException ("Could not set property '" + prop.Name + "' in type '" + Name + "'", ex);
}
}
}
public virtual void ReadSlnData (DataItem item)
{
customSlnData = item;
}
public DataNode Read(XmlReader reader)
{
DataItem item = new DataItem();
item.UniqueNames = false;
reader.MoveToContent();
string name = reader.LocalName;
item.Name = name;
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "xmlns")
{
continue;
}
DataNode data = ReadAttribute(reader.LocalName, reader.Value);
if (data != null)
{
DataValue val = data as DataValue;
if (val != null)
{
val.StoreAsAttribute = true;
}
item.ItemData.Add(data);
}
}
reader.MoveToElement();
if (reader.IsEmptyElement)
{
reader.Skip();
return(item);
}
reader.ReadStartElement();
string text = "";
while (reader.NodeType != XmlNodeType.EndElement)
{
if (reader.NodeType == XmlNodeType.Element)
{
DataNode data = ReadChild(reader, item);
if (data != null)
{
item.ItemData.Add(data);
}
}
else if (reader.NodeType == XmlNodeType.Text || reader.NodeType == XmlNodeType.Whitespace)
{
text += reader.Value;
reader.Skip();
}
else
{
reader.Skip();
}
}
reader.ReadEndElement();
if (!item.HasItemData && text != "")
{
return(new DataValue(name, text));
}
return(item);
}