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 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()); } } } } }
InferDeduceSchema ( string data ) { global::System.Xml.Schema.XmlSchema schema = null; //Begin parsing source XML document global::System.Xml.XmlDocument doc = new global::System.Xml.XmlDocument(); try { //Assume string XML doc.LoadXml(data); } catch { //String XML load failed. Try loading as a file path try { doc.Load(data); } catch { throw new global::System.Xml.Schema.XmlSchemaException("XML document is not well-formed."); } } global::System.Xml.XmlElement root = doc.DocumentElement; global::System.Xml.XmlReader reader = null; reader = global::System.Xml.XmlReader.Create(new System.IO.StringReader(data)); global::System.Xml.Schema.XmlSchemaSet schema_set = null; schema_set = new global::System.Xml.Schema.XmlSchemaSet(); global::System.Xml.Schema.XmlSchemaInference schema_inferred = null; schema_inferred = new global::System.Xml.Schema.XmlSchemaInference(); schema_set = schema_inferred.InferSchema(reader); foreach (global::System.Xml.Schema.XmlSchema s in schema_set.Schemas()) { using (global::System.IO.StringWriter sw = new global::System.IO.StringWriter()) { using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(sw)) { s.Write(writer); } } } return //( (schema // types: types //) ); }
internal void WritePage(global::System.Xml.XmlWriter writer, global::System.Data.IDataReader reader) { object[] args = new object[] { writer, reader }; m_privateObject.Invoke("WritePage", new System.Type[] { typeof(global::System.Xml.XmlWriter), typeof(global::System.Data.IDataReader) }, args); }
internal void WritePageVersions(global::System.Xml.XmlWriter writer, int pageId) { object[] args = new object[] { writer, pageId }; m_privateObject.Invoke("WritePageVersions", new System.Type[] { typeof(global::System.Xml.XmlWriter), typeof(int) }, args); }
/// <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()); } } } } } }
internal void WriteMenuItem(global::System.Xml.XmlWriter writer, global::Mediachase.Cms.Dto.MenuDto menuDto, global::Mediachase.Cms.Dto.MenuDto.MenuItemRow itemRow) { object[] args = new object[] { writer, menuDto, itemRow }; m_privateObject.Invoke("WriteMenuItem", new System.Type[] { typeof(global::System.Xml.XmlWriter), typeof(global::Mediachase.Cms.Dto.MenuDto), typeof(global::Mediachase.Cms.Dto.MenuDto.MenuItemRow) }, args); }
public string ConvertLayoutInfoToString(LayoutInfo info) { string result = String.Empty; Microsoft.VisualStudio.Modeling.SerializationResult serializationResult = new Microsoft.VisualStudio.Modeling.SerializationResult(); DomainXmlSerializerDirectory directory = this.GetDirectory(info.Store); System.Text.Encoding encoding = System.Text.Encoding.GetEncoding("ISO-8859-1"); Microsoft.VisualStudio.Modeling.SerializationContext serializationContext = new SerializationContext(directory, "", serializationResult); this.InitializeSerializationContext(info.Partition, serializationContext, false); global::System.IO.MemoryStream newFileContent = new global::System.IO.MemoryStream(); global::System.Xml.XmlWriterSettings settings = DiagramsDSLSerializationHelper.Instance.CreateXmlWriterSettings(serializationContext, false, encoding); using (global::System.Xml.XmlWriter writer = global::System.Xml.XmlWriter.Create(newFileContent, settings)) { DomainClassXmlSerializer rootSerializer = directory.GetSerializer(LayoutInfo.DomainClassId); RootElementSettings rootElementSettings = new RootElementSettings(); rootElementSettings.SchemaTargetNamespace = "http://schemas.microsoft.com/dsltools/DiagramsDSL"; rootElementSettings.Version = new global::System.Version("1.0.0.0"); // Carry out the normal serialization. rootSerializer.Write(serializationContext, info, writer, rootElementSettings); } char[] chars = encoding.GetChars(newFileContent.GetBuffer()); // search the open angle bracket and trim off the Byte Of Mark. result = new string(chars); int indexPos = result.IndexOf('<'); if (indexPos > 0) { // strip off the leading Byte Of Mark. result = result.Substring(indexPos); } // trim off trailing 0s. result = result.TrimEnd('\0'); return(result); }
private void CustomWrite(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, DslModeling::RootElementSettings rootElementSettings) { DefaultWrite(serializationContext, element, writer, rootElementSettings); }
private static void WritePropertiesAsElements(SerializationContext serializationContext, MetaModelLibrary element, global::System.Xml.XmlWriter writer) { // FilePath if (!serializationContext.Result.Failed) { global::System.String propValue = element.FilePath; if (!serializationContext.Result.Failed) { if (!string.IsNullOrEmpty(propValue)) { LanguageDSLSerializationHelper.Instance.WriteElementString(serializationContext, element, writer, "filePath", propValue); } } } // Name if (!serializationContext.Result.Failed) { global::System.String propValue = element.Name; if (!serializationContext.Result.Failed) { if (!string.IsNullOrEmpty(propValue)) { LanguageDSLSerializationHelper.Instance.WriteElementString(serializationContext, element, writer, "name", propValue); } } } }
/// <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">MetaModelLibrary instance to be serialized.</param> /// <param name="writer">XmlWriter to write serialized data to.</param> protected override void WriteElements(SerializationContext serializationContext, ModelElement element, global::System.Xml.XmlWriter writer) { MetaModelLibrary instance = element as MetaModelLibrary; global::System.Diagnostics.Debug.Assert(instance != null, "Expecting an instance of MetaModelLibrary!"); // Write properties serialized as nested XML elements. if (!serializationContext.Result.Failed) { WritePropertiesAsElements(serializationContext, instance, writer); } }
/// <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> /// 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); }
private void CustomWrite(SerializationContext serializationContext, ModelElement element, global::System.Xml.XmlWriter writer, RootElementSettings rootElementSettings) { DomainType domainType = (DomainType)element; if (!domainType.IsBuildIn) { DefaultWrite(serializationContext, element, writer, rootElementSettings); } }
private void CustomWriteMoniker(SerializationContext serializationContext, ModelElement element, global::System.Xml.XmlWriter writer, ModelElement sourceRolePlayer, DomainRelationshipXmlSerializer relSerializer) { DefaultWriteMoniker(serializationContext, element, writer, sourceRolePlayer, relSerializer); }
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); }
/// <summary> /// Writes the specified attribute to the file. /// </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> /// <param name="attributeName">Name of the attribute to be written</param> /// <param name="attributeValue">Value of the attribute to be written</param> /// <remarks>This is an extension point to allow customisation e.g. to encode the data /// being written to the file.</remarks> internal virtual void WriteAttributeString(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, string attributeName, string attributeValue) { writer.WriteAttributeString(attributeName, attributeValue); }
private void CustomWritePropertiesAsAttributes(SerializationContext serializationContext, ModelElement element, global::System.Xml.XmlWriter writer) { DefaultWritePropertiesAsAttributes(serializationContext, element, writer); }
private void CustomWriteElements(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer) { DefaultWriteElements(serializationContext, element, writer); }
/// <summary> /// Writes the specified element to the file. /// </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> /// <param name="elementName">Name of the element to be written.</param> /// <param name="elementValue">Value of the element to be written.</param> /// <remarks>This is an extension point to allow customisation e.g. to encode the data /// being written to the file.</remarks> internal virtual void WriteElementString(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, string elementName, string elementValue) { writer.WriteElementString(elementName, elementValue); }
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(); } }
/// <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); } }