/// <summary>
/// This method is called during deserialization to convert a given value to a specific typed value (Int32?).
/// </summary>
/// <param name="serializationContext">The current serialization context instance.</param>
/// <param name="modelELement">ModdelElement, to which the property belongs to.</param>
/// <param name="propertyName">The Property name, which value is to be converted.</param>
/// <param name="value">Value to convert.</param>
/// <param name="targetType">Type, the object is to be converted to.</param>
/// <param name="isRequired">True if this property is marked as required in the domain model. Can be null.</param>
/// <returns>Converted value.</returns>
public override global::System.Int32?ConvertTypedObjectInt32From(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement modelELement, string propertyName, object value, System.Type targetType, bool?isRequired)
{
if (value is string)
{
if (String.IsNullOrEmpty(value as string))
{
return(null);
}
if (String.IsNullOrWhiteSpace(value as string))
{
return(null);
}
try
{
System.Int32?d = Convert.ToInt32(value, System.Globalization.CultureInfo.InvariantCulture);
return(d);
}
catch (Exception ex)
{
serializationContext.Result.AddMessage(new DslModeling::SerializationMessage(
DslModeling::SerializationMessageKind.Error, "Couldnt convert " + value + " to Int: " + ex.ToString(), "", 0, 0, null));
}
}
return(null);
}
/// <summary>
/// This method creates an instance of DesignerDiagram based on the tag currently pointed by the reader. The reader is guaranteed (by the caller)
/// to be pointed at a serialized instance of DesignerDiagram.
/// </summary>
/// <remarks>
/// The caller will guarantee that the reader is positioned at open XML tag of the ModelRoot instance being read. This method should
/// not move the reader; the reader should remain at the same position when this method returns.
/// </remarks>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="reader">XmlReader to read serialized data from.</param>
/// <param name="partition">Partition in which new DesignerDiagram instance should be created.</param>
/// <returns>Created DesignerDiagram instance.</returns>
protected override DslModeling::ModelElement CreateInstance(DslModeling::SerializationContext serializationContext, global::System.Xml.XmlReader reader, DslModeling::Partition partition)
{
string idStr = reader.GetAttribute("Id");
try
{
global::System.Guid id;
if (string.IsNullOrEmpty(idStr))
{ // Create a default Id.
id = global::System.Guid.NewGuid();
StateMachineLanguageSerializationBehaviorSerializationMessages.MissingId(serializationContext, reader, id);
}
else
{
id = new global::System.Guid(idStr);
}
return(new DesignerDiagram(partition, new DslModeling::PropertyAssignment(DslModeling::ElementFactory.IdPropertyAssignment, id)));
}
catch (global::System.ArgumentNullException /* anEx */)
{
StateMachineLanguageSerializationBehaviorSerializationMessages.InvalidPropertyValue(serializationContext, reader, "Id", typeof(global::System.Guid), idStr);
}
catch (global::System.FormatException /* fEx */)
{
StateMachineLanguageSerializationBehaviorSerializationMessages.InvalidPropertyValue(serializationContext, reader, "Id", typeof(global::System.Guid), idStr);
}
catch (global::System.OverflowException /* ofEx */)
{
StateMachineLanguageSerializationBehaviorSerializationMessages.InvalidPropertyValue(serializationContext, reader, "Id", typeof(global::System.Guid), idStr);
}
return(null);
}
private MemoryStream InternalSaveModel2(DslModeling::SerializationResult serializationResult, PatternModelSchema modelRoot, string fileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert(serializationResult != null);
global::System.Diagnostics.Debug.Assert(modelRoot != null);
global::System.Diagnostics.Debug.Assert(!serializationResult.Failed);
#endregion
serializationResult.Encoding = encoding;
DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(modelRoot.Store);
global::System.IO.MemoryStream newFileContent = new global::System.IO.MemoryStream();
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileName, serializationResult);
this.InitializeSerializationContext(modelRoot.Partition, serializationContext, false);
// MonikerResolver shouldn't be required in Save operation, so not calling SetupMonikerResolver() here.
serializationContext.WriteOptionalPropertiesWithDefaultValue = writeOptionalPropertiesWithDefaultValue;
global::System.Xml.XmlWriterSettings settings = PatternModelSerializationHelper.Instance.CreateXmlWriterSettings(serializationContext, false, encoding);
using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(newFileContent, settings))
{
this.WriteRootElement(serializationContext, modelRoot, writer);
}
return(newFileContent);
}
public override void SaveModel(DslModeling::SerializationResult serializationResult, MetaModel modelRoot, string fileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue)
{
base.SaveModel(serializationResult, modelRoot, fileName, encoding, writeOptionalPropertiesWithDefaultValue);
System.IO.FileInfo info = new System.IO.FileInfo(fileName);
string fileNameDiagram = info.DirectoryName + "\\" + info.Name.Remove(info.Name.Length - info.Extension.Length, info.Extension.Length) + DiagramExtension;
// save view information
using (global::System.IO.MemoryStream newFileContent = new global::System.IO.MemoryStream())
{
DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(modelRoot.Store);
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileName, serializationResult);
this.InitializeSerializationContext(modelRoot.Partition, serializationContext, false);
// MonikerResolver shouldn't be required in Save operation, so not calling SetupMonikerResolver() here.
serializationContext.WriteOptionalPropertiesWithDefaultValue = writeOptionalPropertiesWithDefaultValue;
global::System.Xml.XmlWriterSettings settings = LanguageDSLSerializationHelper.Instance.CreateXmlWriterSettings(serializationContext, false, encoding);
using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(newFileContent, settings))
{
ViewSerializer serializer = directory.GetSerializer(View.DomainClassId) as ViewSerializer;
serializer.Write(serializationContext, modelRoot.View, writer);
}
if (!serializationResult.Failed && newFileContent != null)
{ // Only write the content if there's no error encountered during serialization.
using (global::System.IO.FileStream fileStream = new global::System.IO.FileStream(fileNameDiagram, global::System.IO.FileMode.Create, global::System.IO.FileAccess.Write, global::System.IO.FileShare.None))
{
using (global::System.IO.BinaryWriter writer = new global::System.IO.BinaryWriter(fileStream, encoding))
{
writer.Write(newFileContent.ToArray());
}
}
}
}
}
private global::System.IO.MemoryStream InternalSaveDiagram(DslModeling::SerializationResult serializationResult, DslDiagrams::Diagram diagram, string diagramFileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert(serializationResult != null);
global::System.Diagnostics.Debug.Assert(diagram != null);
global::System.Diagnostics.Debug.Assert(!serializationResult.Failed);
#endregion
global::System.IO.MemoryStream newFileContent = new global::System.IO.MemoryStream();
var directory = this.GetDirectory(diagram.Store);
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, diagramFileName, serializationResult);
this.InitializeSerializationContext(diagram.Partition, serializationContext, false);
// MonikerResolver shouldn't be required in Save operation, so not calling SetupMonikerResolver() here.
serializationContext.WriteOptionalPropertiesWithDefaultValue = writeOptionalPropertiesWithDefaultValue;
global::System.Xml.XmlWriterSettings settings = EFModelSerializationHelper.Instance.CreateXmlWriterSettings(serializationContext, true, encoding);
var diagramSerializer = GetSerializer(diagram);
using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(newFileContent, settings))
{
//this.WriteRootElement(serializationContext, diagram, writer);
// Carry out the normal serialization.
this.WriteRootElement(serializationContext, diagramSerializer, diagram, writer);
}
return(newFileContent);
}
private global::System.IO.MemoryStream InternalSaveDiagram2(DslModeling::SerializationResult serializationResult, PatternModelSchemaDiagram diagram, string diagramFileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert(serializationResult != null);
global::System.Diagnostics.Debug.Assert(diagram != null);
global::System.Diagnostics.Debug.Assert(!serializationResult.Failed);
#endregion
DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(diagram.Store);
global::System.IO.MemoryStream newFileContent = new global::System.IO.MemoryStream();
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, diagramFileName, serializationResult);
this.InitializeSerializationContext(diagram.Partition, serializationContext, false);
// MonikerResolver shouldn't be required in Save operation, so not calling SetupMonikerResolver() here.
serializationContext.WriteOptionalPropertiesWithDefaultValue = writeOptionalPropertiesWithDefaultValue;
global::System.Xml.XmlWriterSettings settings = PatternModelSerializationHelper.Instance.CreateXmlWriterSettings(serializationContext, true, encoding);
using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(newFileContent, settings))
{
this.WriteRootElement(serializationContext, diagram, writer);
}
return newFileContent;
}
private void CustomRead(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlReader reader)
{
DefaultRead(serializationContext, element, reader);
ConfigurationSectionModel model = (ConfigurationSectionModel)element;
// Make sure there's always a Validators instance in the model
if (model.PropertyValidators == null)
{
model.PropertyValidators = new PropertyValidators(model.Store);
}
}
/// <summary>
/// Saves the diagram.
/// </summary>
/// <typeparam name="TModel">The type of the model.</typeparam>
/// <param name="serializationResult">The serialization result.</param>
/// <param name="modelRoot">The model root.</param>
/// <param name="modelFileName">Name of the model file.</param>
/// <param name="diagram">The diagram.</param>
/// <param name="diagramFileName">Name of the diagram file.</param>
/// <param name="encoding">The encoding.</param>
/// <param name="writeOptionalPropertiesWithDefaultValue">if set to <c>true</c> [write optional properties with default value].</param>
public void SaveDiagram <TModel>(DslModeling::SerializationResult serializationResult, TModel modelRoot, string modelFileName, ComponentModelDiagram diagram, string diagramFileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue)
where TModel : ModelElement
{
if (serializationResult.Failed)
{
return;
}
// MonikerResolver shouldn't be required in Save operation, so not calling SetupMonikerResolver() here.
using (global::System.IO.MemoryStream diagramFileContent = new global::System.IO.MemoryStream())
{
DslModeling::DomainClassXmlSerializer diagramSerializer = this.Directory.GetSerializer(diagram.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(diagramSerializer != null, "Cannot find serializer for " + diagram.GetDomainClass().Name + "!");
if (diagramSerializer != null)
{
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(this.Directory, diagramFileName, serializationResult);
serializationContext.WriteOptionalPropertiesWithDefaultValue = writeOptionalPropertiesWithDefaultValue;
global::System.Xml.XmlWriterSettings settings = new global::System.Xml.XmlWriterSettings();
settings.Indent = true;
settings.Encoding = encoding;
using (global::System.IO.StreamWriter streamWriter = new global::System.IO.StreamWriter(diagramFileContent, encoding))
{
using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(streamWriter, settings))
{
diagramSerializer.WriteRootElement(serializationContext, diagram, writer);
}
}
}
if (!serializationResult.Failed)
{ // Only write the contents if there's no error encountered during serialization.
if (diagramFileContent != null)
{
IVsQueryEditQuerySave2 scc = ServiceLocator.Instance.GetService <IVsQueryEditQuerySave2>(typeof(SVsQueryEditQuerySave));
if (scc != null)
{
uint result;
if (scc.QuerySaveFile(diagramFileName, 0, null, out result) != (int)tagVSQuerySaveResult.QSR_SaveOK)
{
return;
}
}
using (global::System.IO.FileStream fileStream = new global::System.IO.FileStream(diagramFileName, global::System.IO.FileMode.Create, global::System.IO.FileAccess.Write, global::System.IO.FileShare.None))
{
using (global::System.IO.BinaryWriter writer = new global::System.IO.BinaryWriter(fileStream, encoding))
{
writer.Write(diagramFileContent.ToArray());
}
}
}
}
}
}
/// <summary>
/// This method is called during serialization to convert a given typed value (Double?) to a specific value (string).
/// </summary>
/// <param name="serializationContext">The current serialization context instance.</param>
/// <param name="modelELement">ModdelElement, to which the property belongs to.</param>
/// <param name="propertyName">The Property name, which value is to be converted.</param>
/// <param name="value">Typed value to convert.</param>
/// <param name="sourceType">Type of the value.</param>
/// <param name="isRequired">True if this property is marked as required in the domain model. Can be null.</param>
/// <returns>Converted value.</returns>
public override object ConvertTypedObjectDoubleTo(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement modelELement, string propertyName, object value, System.Type sourceType, bool?isRequired)
{
if (value != null)
{
if (value is Double)
{
return(((Double)value).ToString(System.Globalization.CultureInfo.InvariantCulture));
}
}
return("");
}
/// <summary>
/// This method is called during deserialization to convert a given id as string to the id of type Guid as used by the domain model.
/// </summary>
/// <param name="serializationContext">The current serialization context instance.</param>
/// <param name="id">Id as string.</param>
/// <returns>Converted value, Id as Guid.</returns>
public static Guid ConvertIdFrom(DslModeling::SerializationContext serializationContext, string id)
{
try
{
return(KeyGenerator.Instance.ConvertVModellIDToGuid(id));
}
catch (Exception ex)
{
serializationContext.Result.AddMessage(new DslModeling::SerializationMessage(
DslModeling::SerializationMessageKind.Error, "Couldnt convert " + id + " to Guid: " + ex.ToString(), "", 0, 0, null));
return(Guid.Empty);
}
}
/// <summary>
/// Read an element from the root of XML.
/// </summary>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="rootElement">In-memory element instance that will get the deserialized data.</param>
/// <param name="reader">XmlReader to read serialized data from.</param>
/// <param name="schemaResolver">An ISchemaResolver that allows the serializer to do schema validation on the root element (and everything inside it).</param>
protected override void ReadRootElement(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement rootElement, global::System.Xml.XmlReader reader, DslModeling::ISchemaResolver schemaResolver)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert(serializationContext != null);
if (serializationContext == null)
{
throw new global::System.ArgumentNullException("serializationContext");
}
global::System.Diagnostics.Debug.Assert(rootElement != null);
if (rootElement == null)
{
throw new global::System.ArgumentNullException("rootElement");
}
global::System.Diagnostics.Debug.Assert(reader != null);
if (reader == null)
{
throw new global::System.ArgumentNullException("reader");
}
#endregion
DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(rootElement.Store);
DslModeling::DomainClassXmlSerializer rootSerializer = null;
if (rootElement is DslDiagrams::Diagram)
{
rootSerializer = directory.GetSerializer(PatternModelSchemaDiagram.DomainClassId);
}
else
{
rootSerializer = directory.GetSerializer(rootElement.GetDomainClass().Id);
}
global::System.Diagnostics.Debug.Assert(rootSerializer != null, @"Cannot find serializer for " + rootElement.GetDomainClass().Name + @"!");
// Version check.
this.CheckVersion(serializationContext, reader);
if (!serializationContext.Result.Failed)
{
// Use a validating reader if possible
using (reader = TryCreateValidatingReader(schemaResolver, reader, serializationContext))
{
rootSerializer.Read(serializationContext, rootElement, reader);
}
}
}
/// <summary>
/// Write an element as the root of XML.
/// </summary>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="rootElement">Root element instance that will be serialized.</param>
/// <param name="writer">XmlWriter to write serialized data to.</param>
public override void WriteRootElement(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement rootElement, global::System.Xml.XmlWriter writer)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert(serializationContext != null);
if (serializationContext == null)
{
throw new global::System.ArgumentNullException("serializationContext");
}
global::System.Diagnostics.Debug.Assert(rootElement != null);
if (rootElement == null)
{
throw new global::System.ArgumentNullException("rootElement");
}
global::System.Diagnostics.Debug.Assert(writer != null);
if (writer == null)
{
throw new global::System.ArgumentNullException("writer");
}
#endregion
DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(rootElement.Store);
DslModeling::DomainClassXmlSerializer rootSerializer = null;
if (rootElement is DslDiagrams::Diagram)
{
rootSerializer = directory.GetSerializer(PatternModelSchemaDiagram.DomainClassId);
}
else
{
rootSerializer = directory.GetSerializer(rootElement.GetDomainClass().Id);
}
global::System.Diagnostics.Debug.Assert(rootSerializer != null, "Cannot find serializer for " + rootElement.GetDomainClass().Name + "!");
// Set up root element settings
DslModeling::RootElementSettings rootElementSettings = new DslModeling::RootElementSettings();
if (!(rootElement is DslDiagrams::Diagram))
{
// Only model has schema, diagram has no schema.
rootElementSettings.SchemaTargetNamespace = "http://schemas.microsoft.com/visualstudio/patterning/runtime/patternmodel";
}
rootElementSettings.Version = new global::System.Version("1.3.0.0");
// Carry out the normal serialization.
rootSerializer.Write(serializationContext, rootElement, writer, rootElementSettings);
}
/// <summary>
/// This methods serializes 1) properties serialized as nested XML elements and 2) child model elements into XML.
/// </summary>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="element">MetaModel instance to be serialized.</param>
/// <param name="writer">XmlWriter to write serialized data to.</param>
protected override void WriteElements(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
// Always call the base class so any extensions are serialized
//base.WriteElements(serializationContext, element, writer);
// Write any additional element data under this XML element
WriteAdditionalElementData(serializationContext, element, writer);
MetaModel instance = element as MetaModel;
global::System.Diagnostics.Debug.Assert(instance != null, "Expecting an instance of MetaModel!");
// Write child model elements (which are always serialized as nested XML elements).
if (!serializationContext.Result.Failed)
{
WriteChildElementsExtended(serializationContext, instance, writer);
}
}
/// <summary>
/// Read any extension data written inside this XML element
/// </summary>
/// <param name="serializationContext">The current serialization context instance.</param>
/// <param name="element">In-memory ModelElement instance that is currently being read.</param>
/// <param name="reader">Reader for the file being read. The reader is positioned after the attributes of the specified element.</param>
/// <remarks>The method reads any extension element data, regardless of whether it relates the current
/// element or not. There may be no additional data for the specified element.</remarks>
internal protected virtual void ReadExtensions(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlReader reader)
{
if (serializationContext == null)
{
throw new global::System.ArgumentNullException("serializationContext");
}
if (element == null)
{
throw new global::System.ArgumentNullException("element");
}
if (reader == null)
{
throw new global::System.ArgumentNullException("reader");
}
if (string.CompareOrdinal(reader.LocalName, DslModeling::SerializationUtilities.ExtensionsXmlElementName) == 0)
{
DslModeling::SerializationUtilities.ReadExtensions(serializationContext, reader, element.Partition);
}
}
/// <summary>
/// This method is called during serialization to convert a given typed value (Html) to a specific value (string).
/// </summary>
/// <param name="serializationContext">The current serialization context instance.</param>
/// <param name="modelELement">ModdelElement, to which the property belongs to.</param>
/// <param name="propertyName">The Property name, which value is to be converted.</param>
/// <param name="value">Typed value to convert.</param>
/// <param name="sourceType">Type of the value.</param>
/// <param name="isRequired">True if this property is marked as required in the domain model. Can be null.</param>
/// <returns>Converted value.</returns>
public static object ConvertTypedObjectHtmlTo(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement modelELement, string propertyName, object value, System.Type sourceType, bool?isRequired)
{
Tum.PDE.ToolFramework.Modeling.Visualization.VMXExtensions.Html.Html strValue = value as Tum.PDE.ToolFramework.Modeling.Visualization.VMXExtensions.Html.Html;
if (strValue != null)
{
return(strValue.HtmlData);
}
else
{
if (isRequired != null)
{
// Important: This is needed, otherwise export will fail! (as long as we still use this extern export)
if (isRequired.Value == true)
{
return("");
}
}
return(null);
}
}
/// <summary>
/// Write extension element data inside the current XML element
/// </summary>
/// <param name="serializationContext">The current serialization context instance.</param>
/// <param name="element">The element whose attributes have just been written.</param>
/// <param name="writer">XmlWriter to write serialized data to.</param>
/// <remarks>The default implemenation is to write out all non-embedded extension elements,
/// regardless of whether they relate to the current element or not.
/// The additional data should be written as a series of one or more
/// XML elements.</remarks>
internal protected virtual void WriteExtensions(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
if (serializationContext == null)
{
throw new global::System.ArgumentNullException("serializationContext");
}
if (element == null)
{
throw new global::System.ArgumentNullException("element");
}
if (writer == null)
{
throw new global::System.ArgumentNullException("writer");
}
// Build a list of extension elements to serialize
global::System.Collections.ObjectModel.ReadOnlyCollection <DslModeling::ModelElement> allExtensionElements = element.Partition.ElementDirectory.FindElements(DslModeling::ExtensionElement.DomainClassId, true);
global::System.Collections.Generic.IEnumerable <DslModeling::ExtensionElement> nonEmbeddedExtensionsElements = allExtensionElements.Where(e => DslModeling::DomainClassInfo.FindEmbeddingElementLink(e) == null).OfType <DslModeling::ExtensionElement>();
DslModeling::SerializationUtilities.WriteExtensions(serializationContext, writer, nonEmbeddedExtensionsElements);
}
protected virtual void WriteRootElement(DslModeling::SerializationContext serializationContext, DslModeling::DomainClassXmlSerializer domainClassXmlSerializer, DslModeling::ModelElement rootElement, global::System.Xml.XmlWriter writer)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert(serializationContext != null);
if (serializationContext == null)
{
throw new global::System.ArgumentNullException("serializationContext");
}
global::System.Diagnostics.Debug.Assert(domainClassXmlSerializer != null);
if (domainClassXmlSerializer == null)
{
throw new global::System.ArgumentNullException("domainClassXmlSerializer");
}
global::System.Diagnostics.Debug.Assert(rootElement != null);
if (rootElement == null)
{
throw new global::System.ArgumentNullException("rootElement");
}
global::System.Diagnostics.Debug.Assert(writer != null);
if (writer == null)
{
throw new global::System.ArgumentNullException("writer");
}
#endregion
// Set up root element settings
DslModeling::RootElementSettings rootElementSettings = new DslModeling::RootElementSettings();
if (!(rootElement is DslDiagrams::Diagram))
{
// Only model has schema, diagram has no schema.
rootElementSettings.SchemaTargetNamespace = "http://schemas.microsoft.com/dsltools/Language4";
}
rootElementSettings.Version = new global::System.Version("1.0.0.0");
// Carry out the normal serialization.
domainClassXmlSerializer.Write(serializationContext, rootElement, writer, rootElementSettings);
}
protected virtual void ReadRootElement(DslModeling::SerializationContext serializationContext, DslModeling::DomainClassXmlSerializer domainClassXmlSerializer, DslModeling::ModelElement rootElement, global::System.Xml.XmlReader reader, DslModeling::ISchemaResolver schemaResolver)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert(serializationContext != null);
if (serializationContext == null)
{
throw new global::System.ArgumentNullException("serializationContext");
}
global::System.Diagnostics.Debug.Assert(domainClassXmlSerializer != null);
if (domainClassXmlSerializer == null)
{
throw new global::System.ArgumentNullException("domainClassXmlSerializer");
}
global::System.Diagnostics.Debug.Assert(rootElement != null);
if (rootElement == null)
{
throw new global::System.ArgumentNullException("rootElement");
}
global::System.Diagnostics.Debug.Assert(reader != null);
if (reader == null)
{
throw new global::System.ArgumentNullException("reader");
}
#endregion
// Version check.
this.CheckVersion(serializationContext, reader);
if (!serializationContext.Result.Failed)
{
// Use a validating reader if possible
using (reader = TryCreateValidatingReader(schemaResolver, reader, serializationContext))
{
domainClassXmlSerializer.Read(serializationContext, rootElement, reader);
}
}
}
private void CustomWrite(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, DslModeling::RootElementSettings rootElementSettings)
{
DefaultWrite(serializationContext, element, writer, rootElementSettings);
}
private DslModeling::Moniker CustomCreateMonikerInstance(DslModeling::SerializationContext serializationContext, global::System.Xml.XmlReader reader, DslModeling::ModelElement sourceRolePlayer, global::System.Guid relDomainClassId, DslModeling::Partition partition)
{
return(DefaultCreateMonikerInstance(serializationContext, reader, sourceRolePlayer, relDomainClassId, partition));
}
private void WriteChildElementsExtended(DslModeling::SerializationContext serializationContext, MetaModel element, global::System.Xml.XmlWriter writer)
{
// MetaModelHasDomainTypes
global::System.Collections.ObjectModel.ReadOnlyCollection <MetaModelHasDomainTypes> allMetaModelHasDomainTypesInstances = MetaModelHasDomainTypes.GetLinksToDomainTypes(element);
if (!serializationContext.Result.Failed && allMetaModelHasDomainTypesInstances.Count > 0)
{
writer.WriteStartElement("domainTypes");
global::System.Type typeofMetaModelHasDomainTypes = typeof(MetaModelHasDomainTypes);
foreach (MetaModelHasDomainTypes eachMetaModelHasDomainTypesInstance in allMetaModelHasDomainTypesInstances)
{
if (serializationContext.Result.Failed)
{
break;
}
if (eachMetaModelHasDomainTypesInstance.GetType() != typeofMetaModelHasDomainTypes)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachMetaModelHasDomainTypesInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachMetaModelHasDomainTypesInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachMetaModelHasDomainTypesInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachMetaModelHasDomainTypesInstance.DomainType;
DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer(targetElement.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(targetSerializer != null, "Cannot find serializer for " + targetElement.GetDomainClass().Name + "!");
targetSerializer.Write(serializationContext, targetElement, writer);
}
}
writer.WriteEndElement();
}
// MetaModelHasValidation
MetaModelHasValidation theMetaModelHasValidationInstance = MetaModelHasValidation.GetLinkToValidation(element);
if (!serializationContext.Result.Failed && theMetaModelHasValidationInstance != null)
{
writer.WriteStartElement("validation");
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(theMetaModelHasValidationInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + theMetaModelHasValidationInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, theMetaModelHasValidationInstance, writer);
writer.WriteEndElement();
}
// MetaModelHasAdditionalInformation
MetaModelHasAdditionalInformation theMetaModelHasAdditionalInformationInstance = MetaModelHasAdditionalInformation.GetLinkToAdditionalInformation(element);
if (!serializationContext.Result.Failed && theMetaModelHasAdditionalInformationInstance != null)
{
writer.WriteStartElement("additionalInformation");
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(theMetaModelHasAdditionalInformationInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + theMetaModelHasAdditionalInformationInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, theMetaModelHasAdditionalInformationInstance, writer);
writer.WriteEndElement();
}
// MetaModelHasMetaModelLibraries
global::System.Collections.ObjectModel.ReadOnlyCollection <MetaModelHasMetaModelLibraries> allMetaModelHasMetaModelLibrariesInstances = MetaModelHasMetaModelLibraries.GetLinksToMetaModelLibraries(element);
if (!serializationContext.Result.Failed && allMetaModelHasMetaModelLibrariesInstances.Count > 0)
{
writer.WriteStartElement("metaModelLibraries");
foreach (MetaModelHasMetaModelLibraries eachMetaModelHasMetaModelLibrariesInstance in allMetaModelHasMetaModelLibrariesInstances)
{
if (serializationContext.Result.Failed)
{
break;
}
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachMetaModelHasMetaModelLibrariesInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachMetaModelHasMetaModelLibrariesInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachMetaModelHasMetaModelLibrariesInstance, writer);
}
writer.WriteEndElement();
}
/*
* // MetaModelHasView
* MetaModelHasView theMetaModelHasViewInstance = MetaModelHasView.GetLinkToView(element);
* if (!serializationContext.Result.Failed && theMetaModelHasViewInstance != null)
* {
* DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(theMetaModelHasViewInstance.GetDomainClass().Id);
* global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + theMetaModelHasViewInstance.GetDomainClass().Name + "!");
* relSerializer.Write(serializationContext, theMetaModelHasViewInstance, writer);
* }*/
// MetaModelHasModelContexts
global::System.Collections.ObjectModel.ReadOnlyCollection <MetaModelHasModelContexts> allMetaModelHasModelContextsInstances = MetaModelHasModelContexts.GetLinksToModelContexts(element);
if (!serializationContext.Result.Failed && allMetaModelHasModelContextsInstances.Count > 0)
{
writer.WriteStartElement("modelContexts");
foreach (MetaModelHasModelContexts eachMetaModelHasModelContextsInstance in allMetaModelHasModelContextsInstances)
{
if (serializationContext.Result.Failed)
{
break;
}
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachMetaModelHasModelContextsInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachMetaModelHasModelContextsInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachMetaModelHasModelContextsInstance, writer);
}
writer.WriteEndElement();
}
// MetaModelHasPropertyGridEditors
global::System.Collections.ObjectModel.ReadOnlyCollection <MetaModelHasPropertyGridEditors> allMetaModelHasPropertyGridEditorsInstances = MetaModelHasPropertyGridEditors.GetLinksToPropertyGridEditors(element);
if (!serializationContext.Result.Failed && allMetaModelHasPropertyGridEditorsInstances.Count > 0)
{
writer.WriteStartElement("propertyGridEditors");
global::System.Type typeofMetaModelHasPropertyGridEditors = typeof(MetaModelHasPropertyGridEditors);
foreach (MetaModelHasPropertyGridEditors eachMetaModelHasPropertyGridEditorsInstance in allMetaModelHasPropertyGridEditorsInstances)
{
if (serializationContext.Result.Failed)
{
break;
}
if (eachMetaModelHasPropertyGridEditorsInstance.GetType() != typeofMetaModelHasPropertyGridEditors)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachMetaModelHasPropertyGridEditorsInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachMetaModelHasPropertyGridEditorsInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachMetaModelHasPropertyGridEditorsInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachMetaModelHasPropertyGridEditorsInstance.PropertyGridEditor;
DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer(targetElement.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(targetSerializer != null, "Cannot find serializer for " + targetElement.GetDomainClass().Name + "!");
targetSerializer.Write(serializationContext, targetElement, writer);
}
}
writer.WriteEndElement();
}
}
public virtual void SaveModelAndDiagram(DslModeling::SerializationResult serializationResult, Model modelRoot, string modelFileName, ActiveRecordMapping diagram, string diagramFileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue)
{
#region Check Parameters
if (serializationResult == null)
throw new global::System.ArgumentNullException("serializationResult");
if (string.IsNullOrEmpty(modelFileName))
throw new global::System.ArgumentNullException("modelFileName");
if (diagram == null)
throw new global::System.ArgumentNullException("diagram");
if (string.IsNullOrEmpty(diagramFileName))
throw new global::System.ArgumentNullException("diagramFileName");
#endregion
if (serializationResult.Failed)
return;
// Save the model file first
using (global::System.IO.MemoryStream modelFileContent = this.InternalSaveModel(serializationResult, modelRoot, modelFileName, encoding, writeOptionalPropertiesWithDefaultValue))
{
if (serializationResult.Failed)
return;
using (global::System.IO.MemoryStream diagramFileContent = new global::System.IO.MemoryStream())
{
DslModeling::DomainClassXmlSerializer diagramSerializer = this.Directory.GetSerializer(diagram.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(diagramSerializer != null, "Cannot find serializer for " + diagram.GetDomainClass().Name + "!");
if (diagramSerializer != null)
{
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(this.Directory, diagramFileName, serializationResult);
// MonikerResolver shouldn't be required in Save operation, so not calling SetupMonikerResolver() here.
serializationContext.WriteOptionalPropertiesWithDefaultValue = writeOptionalPropertiesWithDefaultValue;
global::System.Xml.XmlWriterSettings settings = new global::System.Xml.XmlWriterSettings();
settings.Indent = true;
settings.Encoding = encoding;
using (global::System.IO.StreamWriter streamWriter = new global::System.IO.StreamWriter(diagramFileContent, encoding))
{
using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(streamWriter, settings))
{
diagramSerializer.WriteRootElement(serializationContext, diagram, writer);
}
}
}
if (!serializationResult.Failed)
{ // Only write the contents if there's no error encountered during serialization.
if (modelFileContent != null)
{
using (global::System.IO.FileStream fileStream = new global::System.IO.FileStream(modelFileName, global::System.IO.FileMode.Create, global::System.IO.FileAccess.Write, global::System.IO.FileShare.None))
{
using (global::System.IO.BinaryWriter writer = new global::System.IO.BinaryWriter(fileStream, encoding))
{
writer.Write(modelFileContent.ToArray());
}
}
}
if (diagramFileContent != null)
{
using (global::System.IO.FileStream fileStream = new global::System.IO.FileStream(diagramFileName, global::System.IO.FileMode.Create, global::System.IO.FileAccess.Write, global::System.IO.FileShare.None))
{
using (global::System.IO.BinaryWriter writer = new global::System.IO.BinaryWriter(fileStream, encoding))
{
writer.Write(diagramFileContent.ToArray());
}
}
}
}
}
}
}
/// <summary>
/// Saves the given model root as a in-memory stream.
/// This is a helper used by SaveModel() and SaveModelAndDiagram(). When saving the model and the diagram together, we want to make sure that
/// both can be saved without error before writing the content to disk, so we serialize the model into a in-memory stream first.
/// </summary>
/// <param name="serializationResult">Stores serialization result from the save operation.</param>
/// <param name="modelRoot">EntityDesignerViewModel instance to be saved.</param>
/// <param name="fileName">Name of the file in which the EntityDesignerViewModel instance will be saved.</param>
/// <param name="encoding">Encoding to use when saving the EntityDesignerViewModel instance.</param>
/// <param name="writeOptionalPropertiesWithDefaultValue">Whether optional properties with default value will be saved.</param>
/// <returns>In-memory stream containing the serialized EntityDesignerViewModel instance.</returns>
internal virtual global::System.IO.MemoryStream InternalSaveModel(DslModeling::SerializationResult serializationResult, global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.EntityDesignerViewModel modelRoot, string fileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert(serializationResult != null);
global::System.Diagnostics.Debug.Assert(modelRoot != null);
global::System.Diagnostics.Debug.Assert(!serializationResult.Failed);
#endregion
serializationResult.Encoding = encoding;
DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(modelRoot.Store);
global::System.IO.MemoryStream newFileContent = new global::System.IO.MemoryStream();
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileName, serializationResult);
this.InitializeSerializationContext(modelRoot.Partition, serializationContext, false);
// MonikerResolver shouldn't be required in Save operation, so not calling SetupMonikerResolver() here.
serializationContext.WriteOptionalPropertiesWithDefaultValue = writeOptionalPropertiesWithDefaultValue;
global::System.Xml.XmlWriterSettings settings = MicrosoftDataEntityDesignSerializationHelper.Instance.CreateXmlWriterSettings(serializationContext, false, encoding);
using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(newFileContent, settings))
{
this.WriteRootElement(serializationContext, modelRoot, writer);
}
return newFileContent;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="serializationContext">SerializationContext to be used to store schema validation warning/error.</param>
internal BinbinDomainLanguageSerializationBehaviorSchemaValidationCallback(DslModeling::SerializationContext serializationContext)
{
global::System.Diagnostics.Debug.Assert(serializationContext != null);
this.serializationContext = serializationContext;
}
private void CustomWriteMoniker(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, DslModeling::ModelElement sourceRolePlayer, DslModeling::DomainRelationshipXmlSerializer relSerializer)
{
DefaultWriteMoniker(serializationContext, element, writer, sourceRolePlayer, relSerializer);
}
/// <summary>
/// This method is called during deserialization to convert a given id as string to the id of type Guid as used by the domain model.
/// </summary>
/// <param name="serializationContext">The current serialization context instance.</param>
/// <param name="id">Id as string.</param>
/// <returns>Converted value, Id as Guid.</returns>
public override Guid ConvertIdFrom(DslModeling::SerializationContext serializationContext, string id)
{
return(VMXExt::SerializationHelper.ConvertIdFrom(serializationContext, id));
}
private void CustomWriteElements(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
DefaultWriteElements(serializationContext, element, writer);
}
/// <summary>
/// This method is called during serialization to convert a given id to its specific string representation.
/// </summary>
/// <param name="serializationContext">The current serialization context instance.</param>
/// <param name="id">Id.</param>
/// <returns>Converted value.</returns>
public override string ConvertIdTo(DslModeling::SerializationContext serializationContext, Guid id)
{
return(VMXExt::SerializationHelper.ConvertIdTo(serializationContext, id));
}
// private void OnPostLoadModelAndDiagram(DslModeling::SerializationResult serializationResult, DslModeling::Partition modelPartition, string modelFileName, DslModeling::Partition diagramPartition, string diagramFileName, ModelRoot modelRoot, EFModelDiagram diagram)
// private DslDiagrams::Diagram LoadDiagram(DslModeling::SerializationResult serializationResult, DslModeling::ModelElement modelRoot, DslModeling::Partition diagramPartition, global::System.IO.Stream diagramStream, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController, DslModeling::ISerializerLocator serializerLocator)
private DslDiagrams::Diagram LoadDiagram(DslModeling::SerializationResult serializationResult, DslModeling::Partition modelPartition, string modelFileName, string diagramFileName, DslModeling::ModelElement modelRoot, DslModeling::Partition diagramPartition, global::System.IO.Stream diagramStream, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController, DslModeling::ISerializerLocator serializerLocator)
{
#region Check Parameters
if (serializationResult == null)
{
throw new global::System.ArgumentNullException("serializationResult");
}
if (modelRoot == null)
{
throw new global::System.ArgumentNullException("modelRoot");
}
if (diagramPartition == null)
{
throw new global::System.ArgumentNullException("diagramPartition");
}
#endregion
DslDiagrams::Diagram diagram = null;
var diagramName = string.Empty;
// Ensure there is an outer transaction spanning both model and diagram load, so moniker resolution works properly.
if (!diagramPartition.Store.TransactionActive)
{
throw new global::System.InvalidOperationException(EFModelDomainModel.SingletonResourceManager.GetString("MissingTransaction"));
}
if (diagramStream == null || diagramStream == global::System.IO.Stream.Null || !diagramStream.CanRead || diagramStream.Length < 6)
{
// missing diagram file indicates we should create a new diagram.
diagram = this.CreateDiagramHelper(diagramPartition, modelRoot);
}
else
{
var directory = this.GetDirectory(diagramPartition.Store);
var localName = string.Empty;
var localSettings = EFModelSerializationHelper.Instance.CreateXmlReaderSettings(null, false);
try
{
using (var reader = global::System.Xml.XmlReader.Create(diagramStream, localSettings))
{
reader.MoveToContent();
localName = reader.LocalName;
global::System.Diagnostics.Debug.Assert(!string.IsNullOrEmpty(reader.GetAttribute("name")), "One of diagram streams is not well-formed");
diagramName = reader.GetAttribute("name");
}
diagramStream.Seek(0, global::System.IO.SeekOrigin.Begin);
}
catch (global::System.Xml.XmlException xEx)
{
DslModeling::SerializationUtilities.AddMessage(
new DslModeling::SerializationContext(directory),
DslModeling::SerializationMessageKind.Error,
xEx
);
}
var diagramSerializer = directory.GetSerializer(EFModelDiagram.DomainClassId) ?? this.GetSerializer(diagramPartition.Store, localName);
global::System.Diagnostics.Debug.Assert(diagramSerializer != null, "Cannot find serializer for " + diagramName);
if (diagramSerializer != null)
{
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, diagramName, serializationResult);
this.InitializeSerializationContext(diagramPartition, serializationContext, true);
DslModeling::TransactionContext transactionContext = new DslModeling::TransactionContext();
transactionContext.Add(DslModeling::SerializationContext.TransactionContextKey, serializationContext);
using (DslModeling::Transaction postT = diagramPartition.Store.TransactionManager.BeginTransaction("PostLoad Model and Diagram", true, transactionContext))
{
using (DslModeling::Transaction t = diagramPartition.Store.TransactionManager.BeginTransaction("LoadDiagram", true, transactionContext))
{
// Ensure there is some content in the file. Blank (or almost blank, to account for encoding header bytes, etc.)
// files will cause a new diagram to be created and returned
if (diagramStream.Length > 5)
{
global::System.Xml.XmlReaderSettings settings = EFModelSerializationHelper.Instance.CreateXmlReaderSettings(serializationContext, false);
try
{
using (global::System.Xml.XmlReader reader = global::System.Xml.XmlReader.Create(diagramStream, settings))
{
reader.MoveToContent();
diagram = diagramSerializer.TryCreateInstance(serializationContext, reader, diagramPartition) as DslDiagrams::Diagram;
if (diagram != null)
{
this.ReadRootElement(serializationContext, diagramSerializer, diagram, reader, schemaResolver);
}
}
}
catch (global::System.Xml.XmlException xEx)
{
DslModeling::SerializationUtilities.AddMessage(
serializationContext,
DslModeling::SerializationMessageKind.Error,
xEx
);
}
if (serializationResult.Failed)
{
// Serialization error encountered, rollback the transaction.
diagram = null;
t.Rollback();
}
}
if (diagram == null && !serializationResult.Failed)
{
// Create diagram if it doesn't exist
diagram = this.CreateDiagramHelper(diagramPartition, modelRoot);
}
if (t.IsActive)
{
t.Commit();
}
} // End inner Tx
// Fire PostLoad customization code whether Load succeeded or not
// Provide a method in a partial class with the following signature:
///// <summary>
///// Customize Model and Diagram Loading.
///// </summary>
///// <param name="serializationResult">Stores serialization result from the load operation.</param>
///// <param name="modelPartition">Partition in which the new DslLibrary instance will be created.</param>
///// <param name="modelFileName">Name of the file from which the DslLibrary instance will be deserialized.</param>
///// <param name="diagramPartition">Partition in which the new DslDesignerDiagram instance will be created.</param>
///// <param name="diagramFileName">Name of the file from which the DslDesignerDiagram instance will be deserialized.</param>
///// <param name="modelRoot">The root of the file that was loaded.</param>
///// <param name="diagram">The diagram matching the modelRoot.</param>
// private void OnPostLoadModelAndDiagram(DslModeling::SerializationResult serializationResult, DslModeling::Partition modelPartition, string modelFileName, DslModeling::Partition diagramPartition, string diagramFileName, ModelRoot modelRoot, EFModelDiagram diagram)
this.OnPostLoadModelAndDiagram(serializationResult, modelPartition, modelFileName, diagramPartition, diagramFileName, (ModelRoot)modelRoot, (EFModelDiagram)diagram);
if (serializationResult.Failed)
{ // Serialization error encountered, rollback the middle transaction.
modelRoot = null;
postT.Rollback();
}
if (postT.IsActive)
{
postT.Commit();
}
} // End MiddleTx
// Do load-time validation if a ValidationController is provided.
if (!serializationResult.Failed && validationController != null)
{
using (new SerializationValidationObserver(serializationResult, validationController))
{
validationController.Validate(diagramPartition, DslValidation::ValidationCategories.Load);
}
}
}
}
if (diagram != null)
{
if (!serializationResult.Failed)
{ // Succeeded.
diagram.ModelElement = diagram.ModelElement ?? modelRoot;
diagram.PostDeserialization(true);
this.CheckForOrphanedShapes(diagram, serializationResult);
}
else
{ // Failed.
diagram.PostDeserialization(false);
}
}
return(diagram);
}
/// <summary>
/// Loads a ExampleModel instance.
/// </summary>
/// <param name="serializationResult">Stores serialization result from the load operation.</param>
/// <param name="partition">Partition in which the new ExampleModel instance will be created.</param>
/// <param name="fileName">Name of the file from which the ExampleModel instance will be deserialized.</param>
/// <param name="schemaResolver">
/// An ISchemaResolver that allows the serializer to do schema validation on the root element (and everything inside it).
/// If null is passed, schema validation will not be performed.
/// </param>
/// <param name="validationController">
/// A ValidationController that will be used to do load-time validation (validations with validation category "Load"). If null
/// is passed, load-time validation will not be performed.
/// </param>
/// <returns>The loaded ExampleModel instance.</returns>
public virtual ExampleModel LoadModel(DslModeling::SerializationResult serializationResult, DslModeling::Partition partition, string fileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController)
{
#region Check Parameters
if (serializationResult == null)
throw new global::System.ArgumentNullException("serializationResult");
if (partition == null)
throw new global::System.ArgumentNullException("partition");
if (string.IsNullOrEmpty(fileName))
throw new global::System.ArgumentNullException("fileName");
#endregion
// Ensure there is a transaction for this model to Load in.
if (!partition.Store.TransactionActive)
{
throw new global::System.InvalidOperationException(AsyncDslDomainModel.SingletonResourceManager.GetString("MissingTransaction"));
}
ExampleModel modelRoot = null;
DslModeling::DomainClassXmlSerializer modelRootSerializer = this.Directory.GetSerializer(ExampleModel.DomainClassId);
global::System.Diagnostics.Debug.Assert(modelRootSerializer != null, "Cannot find serializer for ExampleModel!");
if (modelRootSerializer != null)
{
using (global::System.IO.FileStream fileStream = global::System.IO.File.OpenRead(fileName))
{
using (DslModeling::Transaction t = partition.Store.TransactionManager.BeginTransaction("Load Model from " + fileName, true))
{
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(this.Directory, fileStream.Name, serializationResult);
// Set up MonikerResolver for AsyncDsl.
this.SetupMonikerResolver(serializationContext, partition.Store);
// Ensure there is some content in the file. Blank (or almost blank, to account for encoding header bytes, etc.)
// files will cause a new root element to be created and returned.
if (fileStream.Length > 5)
{
global::System.Xml.XmlReaderSettings settings = new global::System.Xml.XmlReaderSettings();
try
{
using (global::System.Xml.XmlReader reader = global::System.Xml.XmlReader.Create(fileStream, settings))
{
reader.MoveToContent();
modelRoot = modelRootSerializer.TryCreateInstance(serializationContext, reader, partition) as ExampleModel;
if (modelRoot != null && !serializationResult.Failed)
{
// Note: the actual instance we get back from TryCreateInstance() can be of a derived type of ExampleModel,
// so we need to find the correct serializer instance to deserialize the element properly.
DslModeling::DomainClassXmlSerializer instanceSerializer = this.Directory.GetSerializer(modelRoot.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(instanceSerializer != null, "Cannot find serializer for " + modelRoot.GetDomainClass().Name + "!");
instanceSerializer.ReadRootElement(serializationContext, modelRoot, reader, schemaResolver);
}
}
}
catch (global::System.Xml.XmlException xEx)
{
DslModeling::SerializationUtilities.AddMessage(
serializationContext,
DslModeling::SerializationMessageKind.Error,
xEx
);
}
}
if(modelRoot == null && !serializationResult.Failed)
{
// create model root if it doesn't exist.
modelRoot = this.CreateModelHelper(partition);
}
if (t.IsActive)
t.Commit();
} // End Inner Tx
// Do load-time validation if a ValidationController is provided.
if (!serializationResult.Failed && validationController != null)
{
using (new SerializationValidationObserver(serializationResult, validationController))
{
validationController.Validate(partition, DslValidation::ValidationCategories.Load);
}
}
}
}
return modelRoot;
}
public virtual ExampleModel LoadModelAndDiagram(DslModeling::SerializationResult serializationResult, DslModeling::Partition modelPartition, string modelFileName, DslModeling::Partition diagramPartition, string diagramFileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController)
{
#region Check Parameters
if (serializationResult == null)
throw new global::System.ArgumentNullException("serializationResult");
if (modelPartition == null)
throw new global::System.ArgumentNullException("modelPartition");
if (diagramPartition == null)
throw new global::System.ArgumentNullException("diagramPartition");
if (string.IsNullOrEmpty(diagramFileName))
throw new global::System.ArgumentNullException("diagramFileName");
#endregion
ExampleModel modelRoot;
// Ensure there is an outer transaction spanning both model and diagram load, so moniker resolution works properly.
if (!diagramPartition.Store.TransactionActive)
{
throw new global::System.InvalidOperationException(AsyncDslDomainModel.SingletonResourceManager.GetString("MissingTransaction"));
}
modelRoot = this.LoadModel(serializationResult, modelPartition, modelFileName, schemaResolver, validationController);
if (serializationResult.Failed)
{
// don't try to deserialize diagram data if model load failed.
return modelRoot;
}
AsyncDslDiagram diagram = null;
DslModeling::DomainClassXmlSerializer diagramSerializer = this.Directory.GetSerializer(AsyncDslDiagram.DomainClassId);
global::System.Diagnostics.Debug.Assert(diagramSerializer != null, "Cannot find serializer for AsyncDslDiagram");
if (diagramSerializer != null)
{
if(!global::System.IO.File.Exists(diagramFileName))
{
// missing diagram file indicates we should create a new diagram.
diagram = this.CreateDiagramHelper(diagramPartition, modelRoot);
}
else
{
using (global::System.IO.FileStream fileStream = global::System.IO.File.OpenRead(diagramFileName))
{
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(this.Directory, fileStream.Name, serializationResult);
// Set up MonikerResolver for AsyncDsl.
this.SetupMonikerResolver(serializationContext, diagramPartition.Store);
using (DslModeling::Transaction t = diagramPartition.Store.TransactionManager.BeginTransaction("LoadDiagram", true))
{
// Ensure there is some content in the file. Blank (or almost blank, to account for encoding header bytes, etc.)
// files will cause a new diagram to be created and returned
if (fileStream.Length > 5)
{
global::System.Xml.XmlReaderSettings settings = new global::System.Xml.XmlReaderSettings();
try
{
using (global::System.Xml.XmlReader reader = global::System.Xml.XmlReader.Create(fileStream, settings))
{
reader.MoveToContent();
diagram = diagramSerializer.TryCreateInstance(serializationContext, reader, diagramPartition) as AsyncDslDiagram;
if (diagram != null)
{
// Note: the actual instance we get back from TryCreateInstance() can be of a derived type of AsyncDslDiagram,
// so we need to find the correct serializer instance to deserialize the element properly.
DslModeling::DomainClassXmlSerializer instanceSerializer = this.Directory.GetSerializer(diagram.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(instanceSerializer != null, "Cannot find serializer for " + diagram.GetDomainClass().Name + "!");
instanceSerializer.ReadRootElement(serializationContext, diagram, reader, schemaResolver);
}
}
}
catch (global::System.Xml.XmlException xEx)
{
DslModeling::SerializationUtilities.AddMessage(
serializationContext,
DslModeling::SerializationMessageKind.Error,
xEx
);
}
if (serializationResult.Failed)
{
// Serialization error encountered, rollback the transaction.
diagram = null;
t.Rollback();
}
}
if(diagram == null && !serializationResult.Failed)
{
// Create diagram if it doesn't exist
diagram = this.CreateDiagramHelper(diagramPartition, modelRoot);
}
if (t.IsActive)
t.Commit();
} // End inner Tx
// Do load-time validation if a ValidationController is provided.
if (!serializationResult.Failed && validationController != null)
{
using (new SerializationValidationObserver(serializationResult, validationController))
{
validationController.Validate(diagramPartition, DslValidation::ValidationCategories.Load);
}
}
}
}
if (diagram != null)
{
if (!serializationResult.Failed)
{ // Succeeded.
diagram.ModelElement = modelRoot;
diagram.PostDeserialization(true);
this.CheckForOrphanedShapes(diagram, serializationResult);
}
else
{ // Failed.
diagram.PostDeserialization(false);
}
}
}
return modelRoot;
}
public virtual HostDesignerModel LoadModel(DslModeling::SerializationResult serializationResult, DslModeling::Partition partition, string fileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController, DslModeling::ISerializerLocator serializerLocator)
{
#region Check Parameters
if (serializationResult == null)
throw new global::System.ArgumentNullException("serializationResult");
if (partition == null)
throw new global::System.ArgumentNullException("partition");
if (string.IsNullOrEmpty(fileName))
throw new global::System.ArgumentNullException("fileName");
#endregion
// Ensure there is a transaction for this model to Load in.
if (!partition.Store.TransactionActive)
{
throw new global::System.InvalidOperationException(HostDesignerDomainModel.SingletonResourceManager.GetString("MissingTransaction"));
}
HostDesignerModel modelRoot = null;
DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(partition.Store);
DslModeling::DomainClassXmlSerializer modelRootSerializer = directory.GetSerializer(HostDesignerModel.DomainClassId);
global::System.Diagnostics.Debug.Assert(modelRootSerializer != null, "Cannot find serializer for HostDesignerModel!");
if (modelRootSerializer != null)
{
using (global::System.IO.FileStream fileStream = global::System.IO.File.OpenRead(fileName))
{
using (DslModeling::Transaction postT = partition.Store.TransactionManager.BeginTransaction("PostLoad Model", true))
{
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileStream.Name, serializationResult);
this.InitializeSerializationContext(partition, serializationContext, true);
DslModeling::TransactionContext transactionContext = new DslModeling::TransactionContext();
transactionContext.Add(DslModeling::SerializationContext.TransactionContextKey, serializationContext);
using (DslModeling::Transaction t = partition.Store.TransactionManager.BeginTransaction("Load Model from " + fileName, true, transactionContext))
{
// Ensure there is some content in the file. Blank (or almost blank, to account for encoding header bytes, etc.)
// files will cause a new root element to be created and returned.
if (fileStream.Length > 5)
{
try
{
global::System.Xml.XmlReaderSettings settings = HostDesignerSerializationHelper.Instance.CreateXmlReaderSettings(serializationContext, false);
using (global::System.Xml.XmlReader reader = global::System.Xml.XmlReader.Create(fileStream, settings))
{
// Attempt to read the encoding.
reader.Read(); // Move to the first node - will be the XmlDeclaration if there is one.
global::System.Text.Encoding encoding;
if (this.TryGetEncoding(reader, out encoding))
{
serializationResult.Encoding = encoding;
}
// Load any additional domain models that are required
DslModeling::SerializationUtilities.ResolveDomainModels(reader, serializerLocator, partition.Store);
reader.MoveToContent();
modelRoot = modelRootSerializer.TryCreateInstance(serializationContext, reader, partition) as HostDesignerModel;
if (modelRoot != null && !serializationResult.Failed)
{
this.ReadRootElement(serializationContext, modelRoot, reader, schemaResolver);
}
}
}
catch (global::System.Xml.XmlException xEx)
{
DslModeling::SerializationUtilities.AddMessage(
serializationContext,
DslModeling::SerializationMessageKind.Error,
xEx
);
}
}
if(modelRoot == null && !serializationResult.Failed)
{
// create model root if it doesn't exist.
modelRoot = this.CreateModelHelper(partition);
}
if (t.IsActive)
t.Commit();
} // End Inner Tx
// Fire PostLoad customization code whether load has succeeded or not
// Provide a method in a partial class with the following signature:
///// <summary>
///// Customize Model Loading.
///// </summary>
///// <param name="serializationResult">Stores serialization result from the load operation.</param>
///// <param name="partition">Partition in which the new HostDesignerModel instance will be created.</param>
///// <param name="fileName">Name of the file from which the HostDesignerModel instance will be deserialized.</param>
///// <param name="modelRoot">The root of the file that was loaded.</param>
// private void OnPostLoadModel(DslModeling::SerializationResult serializationResult, DslModeling::Partition partition, string fileName, HostDesignerModel modelRoot )
this.OnPostLoadModel(serializationResult, partition, fileName, modelRoot);
if (serializationResult.Failed)
{ // Serialization error encountered, rollback the middle transaction.
modelRoot = null;
postT.Rollback();
}
if (postT.IsActive)
postT.Commit();
} // End PostLoad Tx
// Do load-time validation if a ValidationController is provided.
if (!serializationResult.Failed && validationController != null)
{
using (new SerializationValidationObserver(serializationResult, validationController))
{
validationController.Validate(partition, DslValidation::ValidationCategories.Load);
}
}
}
}
return modelRoot;
}
/// <summary>
/// This method is called during deserialization to convert a given value to a specific typed value (Html).
/// </summary>
/// <param name="serializationContext">The current serialization context instance.</param>
/// <param name="modelELement">ModdelElement, to which the property belongs to.</param>
/// <param name="propertyName">The Property name, which value is to be converted.</param>
/// <param name="value">Value to convert.</param>
/// <param name="targetType">Type, the object is to be converted to.</param>
/// <param name="isRequired">True if this property is marked as required in the domain model. Can be null.</param>
/// <returns>Converted value.</returns>
public override VMXExt::Html.Html ConvertTypedObjectHtmlFrom(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement modelELement, string propertyName, object value, System.Type targetType, bool?isRequired)
{
return(VMXExt::SerializationHelper.ConvertTypedObjectHtmlFrom(serializationContext, modelELement, propertyName, value, targetType, isRequired));
}
public MetaModel LoadModel(DslModeling::SerializationResult serializationResult, DslModeling::Partition partition, string fileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController, DslModeling::ISerializerLocator serializerLocator, bool bStartT, bool bIsTopMost)
{
#region Model
#region Check Parameters
if (serializationResult == null)
throw new global::System.ArgumentNullException("serializationResult");
if (partition == null)
throw new global::System.ArgumentNullException("partition");
if (string.IsNullOrEmpty(fileName))
throw new global::System.ArgumentNullException("fileName");
#endregion
// Ensure there is a transaction for this model to Load in.
if (!partition.Store.TransactionActive)
{
throw new global::System.InvalidOperationException(LanguageDSLDomainModel.SingletonResourceManager.GetString("MissingTransaction"));
}
MetaModel modelRoot = null;
DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(partition.Store);
DslModeling::DomainClassXmlSerializer modelRootSerializer = directory.GetSerializer(MetaModel.DomainClassId);
global::System.Diagnostics.Debug.Assert(modelRootSerializer != null, "Cannot find serializer for MetaModel!");
if (modelRootSerializer != null)
{
using (global::System.IO.FileStream fileStream = global::System.IO.File.OpenRead(fileName))
{
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileStream.Name, serializationResult);
this.InitializeSerializationContext(partition, serializationContext, true);
DslModeling::TransactionContext transactionContext = new DslModeling::TransactionContext();
transactionContext.Add(DslModeling::SerializationContext.TransactionContextKey, serializationContext);
DslModeling::Transaction t = null;
if (bStartT)
{
t = partition.Store.TransactionManager.BeginTransaction("Load Model from " + fileName, true, transactionContext);
}
// Ensure there is some content in the file. Blank (or almost blank, to account for encoding header bytes, etc.)
// files will cause a new root element to be created and returned.
if (fileStream.Length > 5)
{
try
{
global::System.Xml.XmlReaderSettings settings = LanguageDSLSerializationHelper.Instance.CreateXmlReaderSettings(serializationContext, false);
using (global::System.Xml.XmlReader reader = global::System.Xml.XmlReader.Create(fileStream, settings))
{
// Attempt to read the encoding.
reader.Read(); // Move to the first node - will be the XmlDeclaration if there is one.
global::System.Text.Encoding encoding;
if (this.TryGetEncoding(reader, out encoding))
{
serializationResult.Encoding = encoding;
}
// Load any additional domain models that are required
DslModeling::SerializationUtilities.ResolveDomainModels(reader, serializerLocator, partition.Store);
reader.MoveToContent();
modelRoot = modelRootSerializer.TryCreateInstance(serializationContext, reader, partition) as MetaModel;
if (modelRoot != null && !serializationResult.Failed)
{
modelRoot.BaseDirectory = MetaModelLibraryBase.GetBaseDirectory(fileName);
modelRoot.FilePath = fileName;
this.ReadRootElement(serializationContext, modelRoot, reader, schemaResolver);
}
}
}
catch (global::System.Xml.XmlException xEx)
{
DslModeling::SerializationUtilities.AddMessage(
serializationContext,
DslModeling::SerializationMessageKind.Error,
xEx
);
}
}
if (modelRoot == null && !serializationResult.Failed)
{
// create model root if it doesn't exist.
modelRoot = this.CreateModelHelper(partition);
modelRoot.BaseDirectory = MetaModelLibraryBase.GetBaseDirectory(fileName);
modelRoot.FilePath = fileName;
}
if (bStartT)
if (t.IsActive)
t.Commit();
// Do load-time validation if a ValidationController is provided.
if (!serializationResult.Failed && validationController != null)
{
using (new SerializationValidationObserver(serializationResult, validationController))
{
validationController.Validate(partition, DslValidation::ValidationCategories.Load);
}
}
}
}
#endregion
MetaModel model = modelRoot;
if (bIsTopMost)
model.IsTopMost = true;
#region Diagrams
System.IO.FileInfo info = new System.IO.FileInfo(fileName);
string fileNameDiagram = info.DirectoryName + "\\" + info.Name.Remove(info.Name.Length - info.Extension.Length, info.Extension.Length) + DiagramExtension;
View view = null;
if (System.IO.File.Exists(fileNameDiagram))
{
//DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(partition.Store);
DslModeling::DomainClassXmlSerializer viewSerializer = directory.GetSerializer(View.DomainClassId);
global::System.Diagnostics.Debug.Assert(viewSerializer != null, "Cannot find serializer for View!");
if (viewSerializer != null)
{
using (global::System.IO.FileStream fileStream = global::System.IO.File.OpenRead(fileNameDiagram))
{
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileStream.Name, serializationResult);
this.InitializeSerializationContext(partition, serializationContext, true);
DslModeling::TransactionContext transactionContext = new DslModeling::TransactionContext();
transactionContext.Add(DslModeling::SerializationContext.TransactionContextKey, serializationContext);
DslModeling::Transaction t = null;
if (bStartT)
t = partition.Store.TransactionManager.BeginTransaction("Load Model from " + fileNameDiagram, true, transactionContext);
// Ensure there is some content in the file. Blank (or almost blank, to account for encoding header bytes, etc.)
// files will cause a new root element to be created and returned.
if (fileStream.Length > 5)
{
try
{
global::System.Xml.XmlReaderSettings settings = LanguageDSLSerializationHelper.Instance.CreateXmlReaderSettings(serializationContext, false);
using (global::System.Xml.XmlReader reader = global::System.Xml.XmlReader.Create(fileStream, settings))
{
// Attempt to read the encoding.
reader.Read(); // Move to the first node - will be the XmlDeclaration if there is one.
global::System.Text.Encoding encoding;
if (this.TryGetEncoding(reader, out encoding))
{
serializationResult.Encoding = encoding;
}
reader.MoveToContent();
view = viewSerializer.TryCreateInstance(serializationContext, reader, partition) as View;
if (view != null && !serializationResult.Failed)
{
// Use a validating reader if possible
viewSerializer.Read(serializationContext, view, reader);
model.View = view;
}
}
}
catch (global::System.Xml.XmlException xEx)
{
DslModeling::SerializationUtilities.AddMessage(
serializationContext,
DslModeling::SerializationMessageKind.Error,
xEx
);
}
}
if (bStartT)
if (t.IsActive)
t.Commit();
}
}
}
#endregion
//if( bIsTopMost )
SerializationPostProcessor.PostProcessModelLoad(model);
return model;
}
private global::System.IO.MemoryStream InternalSaveDiagram(DslModeling::SerializationResult serializationResult, AsyncDslDiagram diagram, string diagramFileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert(serializationResult != null);
global::System.Diagnostics.Debug.Assert(diagram != null);
global::System.Diagnostics.Debug.Assert(!serializationResult.Failed);
#endregion
global::System.IO.MemoryStream newFileContent = new global::System.IO.MemoryStream();
DslModeling::DomainClassXmlSerializer diagramSerializer = this.Directory.GetSerializer(diagram.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(diagramSerializer != null, "Cannot find serializer for " + diagram.GetDomainClass().Name + "!");
if (diagramSerializer != null)
{
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(this.Directory, diagramFileName, serializationResult);
// MonikerResolver shouldn't be required in Save operation, so not calling SetupMonikerResolver() here.
serializationContext.WriteOptionalPropertiesWithDefaultValue = writeOptionalPropertiesWithDefaultValue;
global::System.Xml.XmlWriterSettings settings = new global::System.Xml.XmlWriterSettings();
settings.Indent = true;
settings.Encoding = encoding;
using (global::System.IO.StreamWriter streamWriter = new global::System.IO.StreamWriter(newFileContent, encoding))
{
using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(streamWriter, settings))
{
diagramSerializer.WriteRootElement(serializationContext, diagram, writer);
}
}
}
return newFileContent;
}
/// <summary>
/// This method is called during serialization to convert a given typed value (Html) to a specific value (string).
/// </summary>
/// <param name="serializationContext">The current serialization context instance.</param>
/// <param name="modelELement">ModdelElement, to which the property belongs to.</param>
/// <param name="propertyName">The Property name, which value is to be converted.</param>
/// <param name="value">Typed value to convert.</param>
/// <param name="sourceType">Type of the value.</param>
/// <param name="isRequired">True if this property is marked as required in the domain model. Can be null.</param>
/// <returns>Converted value.</returns>
public override object ConvertTypedObjectHtmlTo(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement modelELement, string propertyName, object value, System.Type sourceType, bool?isRequired)
{
return(VMXExt::SerializationHelper.ConvertTypedObjectHtmlTo(serializationContext, modelELement, propertyName, value, sourceType, isRequired));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="serializationContext">SerializationContext to be used to store schema validation warning/error.</param>
internal HostDesignerSerializationBehaviorSchemaValidationCallback(DslModeling::SerializationContext serializationContext)
{
global::System.Diagnostics.Debug.Assert(serializationContext != null);
this.serializationContext = serializationContext;
}
public virtual global::Tum.VModellXT.VModell LoadModelVModell(DslModeling::SerializationResult serializationResult, DslModeling::Partition partition, string fileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController, DslModeling::ISerializerLocator serializerLocator)
{
#region Check Parameters
if (serializationResult == null)
throw new global::System.ArgumentNullException("serializationResult");
if (partition == null)
throw new global::System.ArgumentNullException("partition");
if (string.IsNullOrEmpty(fileName))
throw new global::System.ArgumentNullException("fileName");
#endregion
DslEditorModeling::DomainModelStore dStore = (DslEditorModeling::DomainModelStore)partition.Store;
if( dStore == null)
throw new global::System.ArgumentNullException("dStore");
//dStore.WaitForWritingLockRelease();
// Ensure there is a transaction for this model to Load in.
if (!partition.Store.TransactionActive)
{
throw new global::System.InvalidOperationException(VModellXTDomainModel.SingletonResourceManager.GetString("MissingTransaction"));
}
global::Tum.VModellXT.VModell modelRoot = null;
DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(partition.Store);
DslModeling::DomainClassXmlSerializer modelRootSerializer = directory.GetSerializer(global::Tum.VModellXT.VModell.DomainClassId);
global::System.Diagnostics.Debug.Assert(modelRootSerializer != null, "Cannot find serializer for VModell!");
if (modelRootSerializer != null)
{
global::System.IO.FileStream fileStream = null;
try
{
fileStream = global::System.IO.File.OpenRead(fileName);
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileStream.Name, serializationResult);
this.InitializeSerializationContext(partition, serializationContext, true);
DslModeling::TransactionContext transactionContext = new DslModeling::TransactionContext();
transactionContext.Add(DslModeling::SerializationContext.TransactionContextKey, serializationContext);
//using (DslModeling::Transaction t = partition.Store.TransactionManager.BeginTransaction("Load Model from " + fileName, true, transactionContext))
//{
// Ensure there is some content in the file. Blank (or almost blank, to account for encoding header bytes, etc.)
// files will cause a new root element to be created and returned.
if (fileStream.Length > 5)
{
global::System.Xml.XmlReaderSettings settings = VModellXTSerializationHelper.Instance.CreateXmlReaderSettings(serializationContext, false);
using (global::System.Xml.XmlReader reader = global::System.Xml.XmlReader.Create(fileStream, settings))
{
try
{
// Attempt to read the encoding.
reader.Read(); // Move to the first node - will be the XmlDeclaration if there is one.
global::System.Text.Encoding encoding;
if (this.TryGetEncoding(reader, out encoding))
{
serializationResult.Encoding = encoding;
}
// Load any additional domain models that are required
//DslModeling::SerializationUtilities.ResolveDomainModels(reader, serializerLocator, partition.Store);
reader.MoveToContent();
modelRoot = modelRootSerializer.TryCreateInstance(serializationContext, reader, partition) as global::Tum.VModellXT.VModell;
if (modelRoot != null && !serializationResult.Failed)
{
modelRoot.DomainFilePath = fileName;
this.ReadRootElementVModell(serializationContext, modelRoot, reader, schemaResolver);
}
fileStream.Dispose();
}
catch (global::System.Xml.XmlException xEx)
{
DslModeling::SerializationUtilities.AddMessage(
serializationContext,
DslModeling::SerializationMessageKind.Error,
xEx
);
}
finally
{
fileStream = null;
}
}
}
if(modelRoot == null && !serializationResult.Failed)
{
// create model root if it doesn't exist.
modelRoot = this.CreateModelHelperVModell(partition);
modelRoot.DomainFilePath = fileName;
}
//if (t.IsActive)
// t.Commit();
//}
// Do load-time validation if a ValidationController is provided.
if (!serializationResult.Failed && validationController != null)
{
using (new SerializationValidationObserver(serializationResult, validationController))
{
validationController.Validate(partition, DslValidation::ValidationCategories.Load);
}
}
}
finally
{
if( fileStream != null )
fileStream.Dispose();
}
}
return modelRoot;
}
public virtual HostDesignerModel LoadModelAndDiagram(DslModeling::SerializationResult serializationResult, DslModeling::Partition modelPartition, string modelFileName, DslModeling::Partition diagramPartition, string diagramFileName, DslModeling::ISchemaResolver schemaResolver, DslValidation::ValidationController validationController, DslModeling::ISerializerLocator serializerLocator)
{
#region Check Parameters
if (serializationResult == null)
throw new global::System.ArgumentNullException("serializationResult");
if (modelPartition == null)
throw new global::System.ArgumentNullException("modelPartition");
if (diagramPartition == null)
throw new global::System.ArgumentNullException("diagramPartition");
if (string.IsNullOrEmpty(diagramFileName))
throw new global::System.ArgumentNullException("diagramFileName");
#endregion
HostDesignerModel modelRoot;
// Ensure there is an outer transaction spanning both model and diagram load, so moniker resolution works properly.
if (!diagramPartition.Store.TransactionActive)
{
throw new global::System.InvalidOperationException(HostDesignerDomainModel.SingletonResourceManager.GetString("MissingTransaction"));
}
modelRoot = this.LoadModel(serializationResult, modelPartition, modelFileName, schemaResolver, validationController, serializerLocator);
if (serializationResult.Failed)
{
// don't try to deserialize diagram data if model load failed.
return modelRoot;
}
HostDesignerDiagram diagram = null;
DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(diagramPartition.Store);
DslModeling::DomainClassXmlSerializer diagramSerializer = directory.GetSerializer(HostDesignerDiagram.DomainClassId);
global::System.Diagnostics.Debug.Assert(diagramSerializer != null, "Cannot find serializer for HostDesignerDiagram");
if (diagramSerializer != null)
{
if(!global::System.IO.File.Exists(diagramFileName))
{
// missing diagram file indicates we should create a new diagram.
diagram = this.CreateDiagramHelper(diagramPartition, modelRoot);
}
else
{
using (global::System.IO.FileStream fileStream = global::System.IO.File.OpenRead(diagramFileName))
{
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileStream.Name, serializationResult);
this.InitializeSerializationContext(diagramPartition, serializationContext, true);
DslModeling::TransactionContext transactionContext = new DslModeling::TransactionContext();
transactionContext.Add(DslModeling::SerializationContext.TransactionContextKey, serializationContext);
using (DslModeling::Transaction postT = diagramPartition.Store.TransactionManager.BeginTransaction("PostLoad Model and Diagram", true, transactionContext))
{
using (DslModeling::Transaction t = diagramPartition.Store.TransactionManager.BeginTransaction("LoadDiagram", true, transactionContext))
{
// Ensure there is some content in the file. Blank (or almost blank, to account for encoding header bytes, etc.)
// files will cause a new diagram to be created and returned
if (fileStream.Length > 5)
{
global::System.Xml.XmlReaderSettings settings = HostDesignerSerializationHelper.Instance.CreateXmlReaderSettings(serializationContext, false);
try
{
using (global::System.Xml.XmlReader reader = global::System.Xml.XmlReader.Create(fileStream, settings))
{
reader.MoveToContent();
diagram = diagramSerializer.TryCreateInstance(serializationContext, reader, diagramPartition) as HostDesignerDiagram;
if (diagram != null)
{
this.ReadRootElement(serializationContext, diagram, reader, schemaResolver);
}
}
}
catch (global::System.Xml.XmlException xEx)
{
DslModeling::SerializationUtilities.AddMessage(
serializationContext,
DslModeling::SerializationMessageKind.Error,
xEx
);
}
if (serializationResult.Failed)
{
// Serialization error encountered, rollback the transaction.
diagram = null;
t.Rollback();
}
}
if(diagram == null && !serializationResult.Failed)
{
// Create diagram if it doesn't exist
diagram = this.CreateDiagramHelper(diagramPartition, modelRoot);
}
if (t.IsActive)
t.Commit();
} // End inner Tx
// Fire PostLoad customization code whether Load succeeded or not
// Provide a method in a partial class with the following signature:
///// <summary>
///// Customize Model and Diagram Loading.
///// </summary>
///// <param name="serializationResult">Stores serialization result from the load operation.</param>
///// <param name="modelPartition">Partition in which the new DslLibrary instance will be created.</param>
///// <param name="modelFileName">Name of the file from which the DslLibrary instance will be deserialized.</param>
///// <param name="diagramPartition">Partition in which the new DslDesignerDiagram instance will be created.</param>
///// <param name="diagramFileName">Name of the file from which the DslDesignerDiagram instance will be deserialized.</param>
///// <param name="modelRoot">The root of the file that was loaded.</param>
///// <param name="diagram">The diagram matching the modelRoot.</param>
// private void OnPostLoadModelAndDiagram(DslModeling::SerializationResult serializationResult, DslModeling::Partition modelPartition, string modelFileName, DslModeling::Partition diagramPartition, string diagramFileName, HostDesignerModel modelRoot, HostDesignerDiagram diagram)
this.OnPostLoadModelAndDiagram(serializationResult, modelPartition, modelFileName, diagramPartition, diagramFileName, modelRoot, diagram);
if (serializationResult.Failed)
{ // Serialization error encountered, rollback the middle transaction.
modelRoot = null;
postT.Rollback();
}
if (postT.IsActive)
postT.Commit();
} // End MiddleTx
// Do load-time validation if a ValidationController is provided.
if (!serializationResult.Failed && validationController != null)
{
using (new SerializationValidationObserver(serializationResult, validationController))
{
validationController.Validate(diagramPartition, DslValidation::ValidationCategories.Load);
}
}
}
}
if (diagram != null)
{
if (!serializationResult.Failed)
{ // Succeeded.
diagram.ModelElement = modelRoot;
diagram.PostDeserialization(true);
this.CheckForOrphanedShapes(diagram, serializationResult);
}
else
{ // Failed.
diagram.PostDeserialization(false);
}
}
}
return modelRoot;
}
public virtual void TemporarlySaveModelVModell(DslModeling::SerializationResult serializationResult, global::Tum.VModellXT.VModell modelRoot, string fileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue)
{
#region Check Parameters
if (serializationResult == null)
throw new global::System.ArgumentNullException("serializationResult");
if (modelRoot == null)
throw new global::System.ArgumentNullException("modelRoot");
if (string.IsNullOrEmpty(fileName))
throw new global::System.ArgumentNullException("fileName");
#endregion
if (serializationResult.Failed)
return;
//DslEditorModeling::DomainModelStore dStore = (DslEditorModeling::DomainModelStore)modelRoot.Store;
//if( dStore == null)
// throw new global::System.ArgumentNullException("dStore");
//dStore.WaitForWritingLockRelease();
global::System.IO.MemoryStream newFileContent = null;
try
{
newFileContent = new global::System.IO.MemoryStream();
DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(modelRoot.Store);
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileName, serializationResult);
this.InitializeSerializationContext(modelRoot.Partition, serializationContext, false);
serializationContext.WriteOptionalPropertiesWithDefaultValue = writeOptionalPropertiesWithDefaultValue;
global::System.Xml.XmlWriterSettings settings = VModellXTSerializationHelper.Instance.CreateXmlWriterSettings(serializationContext, false, encoding);
global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(newFileContent, settings);
DslEditorModeling::SerializationOptions options = new DslEditorModeling.SerializationOptions();
options.SerializationMode = DslEditorModeling.SerializationMode.Temporarly;
this.WriteRootElementVModell(serializationContext, modelRoot, writer, options);
writer.Flush();
if (!serializationResult.Failed && newFileContent != null)
{ // Only write the content if there's no error encountered during serialization.
global::System.IO.FileStream fileStream = null;
try
{
fileStream = new global::System.IO.FileStream(fileName, global::System.IO.FileMode.Create, global::System.IO.FileAccess.Write, global::System.IO.FileShare.None);
using (global::System.IO.BinaryWriter writerBin = new global::System.IO.BinaryWriter(fileStream, encoding))
{
try
{
writerBin.Write(newFileContent.ToArray());
fileStream.Dispose();
}
finally
{
fileStream = null;
}
}
}
finally
{
if( fileStream != null )
fileStream.Dispose();
}
}
}
finally
{
if( newFileContent != null )
newFileContent.Dispose();
}
}
private void CustomReadPropertiesFromAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlReader reader)
{
DefaultReadPropertiesFromAttributes(serializationContext, element, reader);
}
internal virtual void SaveModel(DslModeling::SerializationResult serializationResult, ProductState modelRoot, string fileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue)
{
#region Check Parameters
if (serializationResult == null)
throw new global::System.ArgumentNullException("serializationResult");
if (modelRoot == null)
throw new global::System.ArgumentNullException("modelRoot");
if (string.IsNullOrEmpty(fileName))
throw new global::System.ArgumentNullException("fileName");
#endregion
if (serializationResult.Failed)
return;
using (global::System.IO.MemoryStream newFileContent = new global::System.IO.MemoryStream())
{
DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(modelRoot.Store);
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileName, serializationResult);
this.InitializeSerializationContext(modelRoot.Partition, serializationContext, false);
// MonikerResolver shouldn't be required in Save operation, so not calling SetupMonikerResolver() here.
serializationContext.WriteOptionalPropertiesWithDefaultValue = writeOptionalPropertiesWithDefaultValue;
global::System.Xml.XmlWriterSettings settings = ProductStateStoreSerializationHelper.Instance.CreateXmlWriterSettings(serializationContext, false, encoding);
using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(newFileContent, settings))
{
this.WriteRootElement(serializationContext, modelRoot, writer);
}
if (!serializationResult.Failed && newFileContent != null)
{ // Only write the content if there's no error encountered during serialization.
using (global::System.IO.FileStream fileStream = new global::System.IO.FileStream(fileName, global::System.IO.FileMode.Create, global::System.IO.FileAccess.Write, global::System.IO.FileShare.None))
{
using (global::System.IO.BinaryWriter writer = new global::System.IO.BinaryWriter(fileStream, encoding))
{
writer.Write(newFileContent.ToArray());
}
}
}
}
}
private global::System.IO.MemoryStream InternalSaveModelVModell(DslModeling::SerializationResult serializationResult, global::Tum.VModellXT.VModell modelRoot, string fileName, global::System.Text.Encoding encoding, bool writeOptionalPropertiesWithDefaultValue, DslEditorModeling.SerializationMode serializationMode)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert(serializationResult != null);
global::System.Diagnostics.Debug.Assert(modelRoot != null);
global::System.Diagnostics.Debug.Assert(!serializationResult.Failed);
#endregion
//DslEditorModeling::DomainModelStore dStore = (DslEditorModeling::DomainModelStore)modelRoot.Store;
//if( dStore == null)
// throw new global::System.ArgumentNullException("dStore");
//dStore.WaitForWritingLockRelease();
serializationResult.Encoding = encoding;
DslModeling::DomainXmlSerializerDirectory directory = this.GetDirectory(modelRoot.Store);
global::System.IO.MemoryStream newFileContent = new global::System.IO.MemoryStream();
DslModeling::SerializationContext serializationContext = new DslModeling::SerializationContext(directory, fileName, serializationResult);
this.InitializeSerializationContext(modelRoot.Partition, serializationContext, false);
// MonikerResolver shouldn't be required in Save operation, so not calling SetupMonikerResolver() here.
serializationContext.WriteOptionalPropertiesWithDefaultValue = writeOptionalPropertiesWithDefaultValue;
global::System.Xml.XmlWriterSettings settings = VModellXTSerializationHelper.Instance.CreateXmlWriterSettings(serializationContext, false, encoding);
using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(newFileContent, settings))
{
DslEditorModeling.SerializationOptions options = new DslEditorModeling.SerializationOptions();
//options.SerializationMode = DslEditorModeling.SerializationMode.InternalToString;
options.SerializationMode = serializationMode;
this.WriteRootElementVModell(serializationContext, modelRoot, writer, options);
}
return newFileContent;
}
private void CustomReadElements(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlReader reader)
{
DefaultReadElements(serializationContext, element, reader);
}
private DslModeling::ModelElement CustomCreateInstance(DslModeling::SerializationContext serializationContext, global::System.Xml.XmlReader reader, DslModeling::Partition partition)
{
return(DefaultCreateInstance(serializationContext, reader, partition));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="serializationContext">SerializationContext to be used to store schema validation warning/error.</param>
internal CloudCoreArchitectProcessOverviewSerializationBehaviorSchemaValidationCallback(DslModeling::SerializationContext serializationContext)
{
global::System.Diagnostics.Debug.Assert(serializationContext != null);
this.serializationContext = serializationContext;
}