public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
var valueID = valuesCache.Add(instance);
var typeName = typeNamesCache.GetTypeName(instance.GetType());
using (var arrayNode = ownerDocument.CreateTypedElement("arrayOfDoubles",
typeName, parentNode))
{
arrayNode.AddAttribute("ID", valueID.ToString());
using (var itemsNode = ownerDocument.CreateElement("items", arrayNode))
{
var values = (Array) instance;
itemsNode.AddAttribute("count", values.Length);
var innerText = new StringBuilder();
var itemsPerLineCount = 0;
foreach (var listItem in values)
{
innerText.AppendFormat("{0},", listItem);
if (++itemsPerLineCount == 10)
{
itemsPerLineCount = 0;
innerText.AppendFormat("\r\n");
}
}
itemsNode.InnerText = innerText.ToString();
}
}
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
using (var valueNode = ownerDocument.CreateElement(nodeName, parentNode))
{
valueNode.AddAttribute("value", instance.ToString());
}
}
public void SaveTextProperty(int versionId, PropertyType propertyType, string value)
{
INodeWriter writer = this.CreateNodeWriter();
writer.SaveTextProperty(versionId, propertyType, true, value);
writer.Close();
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
var valueID = valuesCache.Add(instance);
var typeName = typeNamesCache.GetTypeName(instance.GetType());
using (var arrayNode = ownerDocument.CreateTypedElement("arrayOfDoubles",
typeName, parentNode))
{
arrayNode.AddAttribute("ID", valueID.ToString());
using (var itemsNode = ownerDocument.CreateElement("items", arrayNode))
{
var values = (Array)instance;
itemsNode.AddAttribute("count", values.Length);
var innerText = new StringBuilder();
var itemsPerLineCount = 0;
foreach (var listItem in values)
{
innerText.AppendFormat("{0},", listItem);
if (++itemsPerLineCount == 10)
{
itemsPerLineCount = 0;
innerText.AppendFormat("\r\n");
}
}
itemsNode.InnerText = innerText.ToString();
}
}
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
using (var referenceNode = ownerDocument.CreateObjectRefernceElement(parentNode))
{
referenceNode.AddAttribute("ID", valuesCache.GetID(instance));
}
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
using (var valueNode = ownerDocument.CreateElement("primitive", parentNode))
{
valueNode.AddAttribute("type", instance.GetType().FullName);
valueNode.InnerText = instance.ToString();
}
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
using (var valueNode = ownerDocument.CreateElement("primitive", parentNode))
{
valueNode.AddAttribute("type", instance.GetType().FullName);
valueNode.InnerText = instance.ToString();
}
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
var objectID = valuesCache.Add(instance);
var typeName = typeNamesCache.GetTypeName(referencedAsType);
using (ownerDocument.CreateAppObjectElement(typeName, objectID, parentNode))
{
}
}
private void Initialize()
{
RootNode = new NXmlNodeWriter(0, rootNodeName);
if (streamWriter != null)
{
RootNode.BeginWrite(streamWriter);
}
RootNode.AddAttribute("version", version.ToString());
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
var objectID = valuesCache.Add(instance);
var typeName = typeNamesCache.GetTypeName(referencedAsType);
using (ownerDocument.CreateAppObjectElement(typeName, objectID, parentNode))
{
}
}
/// <summary>
/// Use the given writer on the given syntax node and assert that the resulting output syntax
/// node will match a list of item of the given type parameter.
/// </summary>
/// <typeparam name="T">The resulting output syntax node type.</typeparam>
/// <param name="nodeWriter">The writer to use to generate the output.</param>
/// <param name="implPatternNode">The implementation pattern used as input to the writer.</param>
/// <returns>The resulting output syntax nodes.</returns>
public static IReadOnlyList <T> WriteAndAssertMultiMemberOfType <T>(INodeWriter nodeWriter, SyntaxNode implPatternNode)
where T : SyntaxNode
{
var output = new StringBuilder();
nodeWriter.Write(implPatternNode, s => output.Append(s));
return(AssertMultiMemberOfType <T>(output));
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
var typeName = (MetaDataTypeName) instance;
using (var node = ownerDocument.CreateElement("typename", parentNode))
{
node.AddAttribute("typeid", typeName.Id);
node.AddAttribute("name", typeName.Name);
}
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
var typeName = (MetaDataTypeName)instance;
using (var node = ownerDocument.CreateElement("typename", parentNode))
{
node.AddAttribute("typeid", typeName.Id);
node.AddAttribute("name", typeName.Name);
}
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
foreach (var writer in writers)
{
if (writer.CanWrite(instance, referencedAsType))
{
writer.Write(instance, parentNode, referencedAsType);
break;
}
}
}
public void Write(object instance, INodeWriter parentNode, Type type)
{
var valueID = valuesCache.Add(instance);
var typeName = typeNamesCache.GetTypeName(type);
using (var listNode = ownerDocument.CreateListElement(typeName,
valueID, parentNode))
{
WriteItems(listNode, (IList)instance);
}
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
var typeName = typeNamesCache.GetTypeName(instance.GetType());
using (var valueNode = ownerDocument.CreateTypedElement("enum",
typeName,
parentNode))
{
valueNode.InnerText = Enum.GetName(instance.GetType(), instance);
}
}
public void Write(object instance, INodeWriter parentNode, Type type)
{
var valueID = valuesCache.Add(instance);
var typeName = typeNamesCache.GetTypeName(type);
using (var listNode = ownerDocument.CreateListElement(typeName,
valueID, parentNode))
{
WriteItems(listNode, (IList) instance);
}
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
var typeName = typeNamesCache.GetTypeName(instance.GetType());
using (var valueNode = ownerDocument.CreateTypedElement("enum",
typeName,
parentNode))
{
valueNode.InnerText = Enum.GetName(instance.GetType(), instance);
}
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
foreach (var writer in writers)
{
if (writer.CanWrite(instance, referencedAsType))
{
writer.Write(instance, parentNode, referencedAsType);
break;
}
}
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
var typeName = typeNamesCache.GetTypeName(instance.GetType());
using (
var node = ownerDocument.CreateValueElement(typeName, parentNode))
{
using (var membersNode = ownerDocument.CreateMembersElement(node))
{
memberWriter.Write(instance, membersNode, instance.GetType());
}
}
}
private void WriteItems(INodeWriter listNode, IList items)
{
using (var itemsNode = ownerDocument.CreateItemsElement(listNode))
{
itemsNode.AddAttribute("count", items.Count);
foreach (var item in items)
{
objectWriter.Write(item, itemsNode, item.GetType());
}
}
}
public void Write(object instance, INodeWriter parentNode, Type type)
{
var valueId = valuesCache.Add(instance);
var typeName = typeNamesCache.GetTypeName(instance.GetType());
using (var dictNode = ownerDocument.CreateTypedElement("dict", typeName,
parentNode))
{
dictNode.AddAttribute("ID", valueId.ToString());
WriteItems(dictNode, (IDictionary)instance);
}
}
public void Write(object instance, INodeWriter parentNode, Type type)
{
var valueId = valuesCache.Add(instance);
var typeName = typeNamesCache.GetTypeName(instance.GetType());
using (var dictNode = ownerDocument.CreateTypedElement("dict", typeName,
parentNode))
{
dictNode.AddAttribute("ID", valueId.ToString());
WriteItems(dictNode, (IDictionary) instance);
}
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
var typeName = typeNamesCache.GetTypeName(instance.GetType());
using (
var node = ownerDocument.CreateValueElement(typeName, parentNode))
{
using (var membersNode = ownerDocument.CreateMembersElement(node))
{
memberWriter.Write(instance, membersNode, instance.GetType());
}
}
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
var objectID = valuesCache.Add(instance);
var typeName = typeNamesCache.GetTypeName(instance.GetType());
using (var classNode = ownerDocument.CreateClassElement(typeName, objectID, parentNode))
{
using (var membersNode = ownerDocument.CreateMembersElement(classNode))
{
memberWriter.Write(instance, membersNode, instance.GetType());
}
baseTypeMembersWriter.WriteMembers(instance, classNode, instance.GetType());
}
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
var objectID = valuesCache.Add(instance);
var typeName = typeNamesCache.GetTypeName(instance.GetType());
using (var classNode = ownerDocument.CreateClassElement(typeName, objectID, parentNode))
{
using (var membersNode = ownerDocument.CreateMembersElement(classNode))
{
memberWriter.Write(instance, membersNode, instance.GetType());
}
baseTypeMembersWriter.WriteMembers(instance, classNode, instance.GetType());
}
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
var valueID = valuesCache.Add(instance);
var typeName = typeNamesCache.GetTypeName(instance.GetType());
using (var arrayNode = ownerDocument.CreateArrayElement(
typeName, valueID, parentNode))
{
using (var itemsNode = ownerDocument.CreateItemsElement(arrayNode))
{
foreach (var listItem in (IEnumerable) instance)
{
var itemType = listItem == null ? instance.GetType().GetElementType() : listItem.GetType();
objectWriter.Write(listItem, itemsNode, itemType);
}
}
}
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
var valueID = valuesCache.Add(instance);
var typeName = typeNamesCache.GetTypeName(instance.GetType());
using (var arrayNode = ownerDocument.CreateArrayElement(
typeName, valueID, parentNode))
{
using (var itemsNode = ownerDocument.CreateItemsElement(arrayNode))
{
foreach (var listItem in (IEnumerable)instance)
{
var itemType = listItem == null?instance.GetType().GetElementType() : listItem.GetType();
objectWriter.Write(listItem, itemsNode, itemType);
}
}
}
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
var value = (double)instance;
string valueString;
if (value == double.MaxValue)
{
valueString = "max";
}
else if (value == double.MinValue)
{
valueString = "min";
}
else if (double.IsPositiveInfinity(value))
{
valueString = "posinfinity";
}
else if (double.IsNegativeInfinity(value))
{
valueString = "neginfinity";
}
else if (double.IsNaN(value))
{
valueString = "nan";
}
else
{
valueString = instance.ToString();
}
using (var valueNode = ownerDocument.CreateElement("double", parentNode))
{
valueNode.InnerText = valueString;
}
}
private static void SaveNodeProperties(NodeData nodeData, SavingAlgorithm savingAlgorithm, INodeWriter writer, bool isNewNode)
{
int versionId = nodeData.VersionId;
foreach (var propertyType in nodeData.PropertyTypes)
{
var slotValue = nodeData.GetDynamicRawData(propertyType) ?? propertyType.DefaultValue;
bool isModified = nodeData.IsModified(propertyType);
if (!isModified && !isNewNode)
{
continue;
}
switch (propertyType.DataType)
{
case DataType.String:
writer.SaveStringProperty(versionId, propertyType, (string)slotValue);
break;
case DataType.DateTime:
writer.SaveDateTimeProperty(versionId, propertyType, (DateTime)slotValue);
break;
case DataType.Int:
writer.SaveIntProperty(versionId, propertyType, (int)slotValue);
break;
case DataType.Currency:
writer.SaveCurrencyProperty(versionId, propertyType, (decimal)slotValue);
break;
case DataType.Text:
writer.SaveTextProperty(versionId, propertyType, true, (string)slotValue); //TODO: ?? isLoaded property handling
BenchmarkCounter.IncrementBy(BenchmarkCounter.CounterName.SaveNodeTextProperties, nodeData.SavingTimer.ElapsedTicks);
nodeData.SavingTimer.Restart();
break;
case DataType.Reference:
var ids = (IEnumerable <int>)slotValue;
if (!isNewNode || (ids != null && ids.Count() > 0))
{
var ids1 = ids.Distinct().ToList();
if (ids1.Count != ids.Count())
{
nodeData.SetDynamicRawData(propertyType, ids1);
}
writer.SaveReferenceProperty(versionId, propertyType, ids1);
}
BenchmarkCounter.IncrementBy(BenchmarkCounter.CounterName.SaveNodeReferenceProperties, nodeData.SavingTimer.ElapsedTicks);
nodeData.SavingTimer.Restart();
break;
case DataType.Binary:
var binValue = (BinaryDataValue)slotValue;
if (binValue != null)
{
if (!binValue.IsEmpty)
{
var vId = nodeData.SharedData == null ? nodeData.VersionId : nodeData.SharedData.VersionId;
if (binValue.Stream == null && binValue.Size != -1)
{
binValue.Stream = DataBackingStore.GetBinaryStream(vId, propertyType.Id);
}
}
}
if (binValue == null || binValue.IsEmpty)
{
writer.DeleteBinaryProperty(versionId, propertyType);
}
else if (binValue.Id == 0 || savingAlgorithm != SavingAlgorithm.UpdateSameVersion)
{
var id = writer.InsertBinaryProperty(versionId, propertyType.Id, binValue, isNewNode);
binValue.Id = id;
}
else
{
writer.UpdateBinaryProperty(binValue.Id, binValue);
}
BenchmarkCounter.IncrementBy(BenchmarkCounter.CounterName.SaveNodeBinaries, nodeData.SavingTimer.ElapsedTicks);
nodeData.SavingTimer.Restart();
break;
default:
throw new NotSupportedException(propertyType.DataType.ToString());
}
}
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
objectWriter.Write(instance, parentNode, referencedAsType);
}
public NXmlTypedElementWriter(INodeWriter node, string typeName, TextWriter streamWriter, int depth)
{
this.node = node;
this.depth = depth;
node.AddAttribute("type", typeName);
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
}
public void Setup()
{
_nodeWriter = NinjectFactory.GetInstance <INodeWriter>();
}
private void WriteItems(INodeWriter listNode, IList items)
{
using (var itemsNode = ownerDocument.CreateItemsElement(listNode))
{
itemsNode.AddAttribute("count", items.Count);
foreach (var item in items)
{
objectWriter.Write(item, itemsNode, item.GetType());
}
}
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
using (ownerDocument.CreateNullValueElement(parentNode))
{
}
}
public static void ShouldBeWrappingNodeVisitor(INodeWriter writer, INodeVisitor visitor)
{
writer.As<SparkNodeWriter>().ShouldEqual(new SparkNodeWriter(visitor));
}
public NXmlTypedElementWriter(INodeWriter node, string typeName, TextWriter streamWriter, int depth)
{
this.node = node;
this.depth = depth;
node.AddAttribute("type", typeName);
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
using (ownerDocument.CreateNullValueElement(parentNode))
{
}
}
public TreeSerializer(INodeWriter serializer) : base()
{
_serializer = serializer;
}
public INodeWriter CreateItemsElement(INodeWriter parentNode)
{
return(CreateElement("items", parentNode));
}
private static void SaveNodeBaseData(NodeData nodeData, SavingAlgorithm savingAlgorithm, INodeWriter writer, NodeSaveSettings settings, out int lastMajorVersionId, out int lastMinorVersionId)
{
switch (savingAlgorithm)
{
case SavingAlgorithm.CreateNewNode:
//nodeData.Id = writer.InsertNodeRow(nodeData);
//nodeData.VersionId = writer.InsertVersionRow(nodeData);
writer.InsertNodeAndVersionRows(nodeData, out lastMajorVersionId, out lastMinorVersionId);
break;
case SavingAlgorithm.UpdateSameVersion:
writer.UpdateNodeRow(nodeData);
writer.UpdateVersionRow(nodeData, out lastMajorVersionId, out lastMinorVersionId);
break;
case SavingAlgorithm.CopyToNewVersionAndUpdate:
writer.UpdateNodeRow(nodeData);
writer.CopyAndUpdateVersion(nodeData, settings.CurrentVersionId, out lastMajorVersionId, out lastMinorVersionId);
break;
case SavingAlgorithm.CopyToSpecifiedVersionAndUpdate:
writer.UpdateNodeRow(nodeData);
writer.CopyAndUpdateVersion(nodeData, settings.CurrentVersionId, settings.ExpectedVersionId, out lastMajorVersionId, out lastMinorVersionId);
break;
default:
throw new NotImplementedException("Unknown SavingAlgorithm: " + savingAlgorithm);
}
}
public INodeWriter CreateItemsElement(INodeWriter parentNode)
{
return CreateElement("items", parentNode);
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
}
private void Initialize()
{
RootNode = new NXmlNodeWriter(0, rootNodeName);
if (streamWriter != null)
{
RootNode.BeginWrite(streamWriter);
}
RootNode.AddAttribute("version", version.ToString());
}
public WriteNodeParams(INodeWriter writer, IList<NodeDescriptor> body)
{
}
public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
{
objectWriter.Write(instance, parentNode, referencedAsType);
}
