private static void WriteChildElements(DslModeling::SerializationContext serializationContext, Activity element, global::System.Xml.XmlWriter writer)
{
// FlowBase
global::System.Collections.ObjectModel.ReadOnlyCollection<FlowBase> allFlowBaseInstances = FlowBase.GetLinksToTargetActs(element);
if (!serializationContext.Result.Failed && allFlowBaseInstances.Count > 0)
{
writer.WriteStartElement("targetActs");
foreach (FlowBase eachFlowBaseInstance in allFlowBaseInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachFlowBaseInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachFlowBaseInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachFlowBaseInstance, writer);
}
writer.WriteEndElement();
}
}
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, NestedClass element, global::System.Xml.XmlWriter writer)
{
// NestedClassHasProperties
global::System.Collections.ObjectModel.ReadOnlyCollection<NestedClassHasProperties> allNestedClassHasPropertiesInstances = NestedClassHasProperties.GetLinksToProperties(element);
if (!serializationContext.Result.Failed && allNestedClassHasPropertiesInstances.Count > 0)
{
writer.WriteStartElement("properties");
global::System.Type typeofNestedClassHasProperties = typeof(NestedClassHasProperties);
foreach (NestedClassHasProperties eachNestedClassHasPropertiesInstance in allNestedClassHasPropertiesInstances)
{
if (serializationContext.Result.Failed)
break;
if (eachNestedClassHasPropertiesInstance.GetType() != typeofNestedClassHasProperties)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachNestedClassHasPropertiesInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachNestedClassHasPropertiesInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachNestedClassHasPropertiesInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachNestedClassHasPropertiesInstance.Property;
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();
}
// NestedClassReferencesModelClasses
global::System.Collections.ObjectModel.ReadOnlyCollection<NestedClassReferencesModelClasses> allNestedClassReferencesModelClassesInstances = NestedClassReferencesModelClasses.GetLinksToModelClasses(element);
if (!serializationContext.Result.Failed && allNestedClassReferencesModelClassesInstances.Count > 0)
{
writer.WriteStartElement("modelClasses");
foreach (NestedClassReferencesModelClasses eachNestedClassReferencesModelClassesInstance in allNestedClassReferencesModelClassesInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachNestedClassReferencesModelClassesInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachNestedClassReferencesModelClassesInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachNestedClassReferencesModelClassesInstance, writer);
}
writer.WriteEndElement();
}
}
/// <summary>
/// Public Write() method that serializes one ManyToOneRelation instance into XML.
/// </summary>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="element">ManyToOneRelation instance to be serialized.</param>
/// <param name="writer">XmlWriter to write serialized data to.</param>
/// <param name="rootElementSettings">
/// The root element settings if the passed in element is serialized as a root element in the XML. The root element contains additional
/// information like schema target namespace, version, etc.
/// This should only be passed for root-level elements. Null should be passed for rest elements (and ideally call the Write() method
/// without this parameter).
/// </param>
public override void Write(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, DslModeling::RootElementSettings rootElementSettings)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert (serializationContext != null);
if (serializationContext == null)
throw new global::System.ArgumentNullException ("serializationContext");
global::System.Diagnostics.Debug.Assert (element != null);
if (element == null)
throw new global::System.ArgumentNullException ("element");
global::System.Diagnostics.Debug.Assert (writer != null);
if (writer == null)
throw new global::System.ArgumentNullException ("writer");
#endregion
// Write start of element, including schema target namespace if specified.
if (rootElementSettings != null && !string.IsNullOrEmpty(rootElementSettings.SchemaTargetNamespace))
{
writer.WriteStartElement(XmlTagName, rootElementSettings.SchemaTargetNamespace);
DslModeling::SerializationUtilities.WriteDomainModelNamespaces(serializationContext.Directory, writer, rootElementSettings.SchemaTargetNamespace);
}
else
{
writer.WriteStartElement(XmlTagName);
}
// Write version info (in the format 1.2.3.4), if necessary
if (rootElementSettings != null && rootElementSettings.Version != null)
writer.WriteAttributeString("dslVersion", rootElementSettings.Version.ToString(4));
// Write out element Id.
writer.WriteAttributeString("Id", element.Id.ToString("D", global::System.Globalization.CultureInfo.CurrentCulture));
WritePropertiesAsAttributes(serializationContext, element, writer);
// Write out any extension data if this is the root element
if (rootElementSettings != null && !serializationContext.Result.Failed)
{
ActiveWriterSerializationHelper.Instance.WriteExtensions(serializationContext, element, writer);
}
// Write the target role-player instance.
ManyToOneRelation instance = element as ManyToOneRelation;
global::System.Diagnostics.Debug.Assert(instance != null, "Expecting an instance of ManyToOneRelation!");
DslModeling::ModelElement targetElement = instance.Target;
DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer(targetElement.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(targetSerializer != null, "Cannot find serializer for " + targetElement.GetDomainClass().Name + "!");
targetSerializer.WriteMoniker(serializationContext, targetElement, writer, instance.Source, this);
if (!serializationContext.Result.Failed)
{
// Write 1) properties serialized as nested XML elements and 2) child model elements into XML.
WriteElements(serializationContext, element, writer);
}
writer.WriteEndElement();
}
/// <summary>
/// Serialize all child model elements.
/// </summary>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="element">EntityType instance to be serialized.</param>
/// <param name="writer">XmlWriter to write serialized data to.</param>
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.EntityType element, global::System.Xml.XmlWriter writer)
{
// EntityTypeHasProperties
global::System.Collections.ObjectModel.ReadOnlyCollection<global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.EntityTypeHasProperties> allEntityTypeHasPropertiesInstances = global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.EntityTypeHasProperties.GetLinksToProperties(element);
if (!serializationContext.Result.Failed && allEntityTypeHasPropertiesInstances.Count > 0)
{
writer.WriteStartElement("properties");
global::System.Type typeofEntityTypeHasProperties = typeof(global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.EntityTypeHasProperties);
foreach (global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.EntityTypeHasProperties eachEntityTypeHasPropertiesInstance in allEntityTypeHasPropertiesInstances)
{
if (serializationContext.Result.Failed)
break;
if (eachEntityTypeHasPropertiesInstance.GetType() != typeofEntityTypeHasProperties)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachEntityTypeHasPropertiesInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachEntityTypeHasPropertiesInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachEntityTypeHasPropertiesInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachEntityTypeHasPropertiesInstance.Property;
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();
}
// Association
global::System.Collections.ObjectModel.ReadOnlyCollection<global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.Association> allAssociationInstances = global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.Association.GetLinksToAssociationTargets(element);
if (!serializationContext.Result.Failed && allAssociationInstances.Count > 0)
{
writer.WriteStartElement("associationTargets");
foreach (global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.Association eachAssociationInstance in allAssociationInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachAssociationInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachAssociationInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachAssociationInstance, writer);
}
writer.WriteEndElement();
}
// EntityTypeHasNavigationProperties
global::System.Collections.ObjectModel.ReadOnlyCollection<global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.EntityTypeHasNavigationProperties> allEntityTypeHasNavigationPropertiesInstances = global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.EntityTypeHasNavigationProperties.GetLinksToNavigationProperties(element);
if (!serializationContext.Result.Failed && allEntityTypeHasNavigationPropertiesInstances.Count > 0)
{
writer.WriteStartElement("navigationProperties");
global::System.Type typeofEntityTypeHasNavigationProperties = typeof(global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.EntityTypeHasNavigationProperties);
foreach (global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.EntityTypeHasNavigationProperties eachEntityTypeHasNavigationPropertiesInstance in allEntityTypeHasNavigationPropertiesInstances)
{
if (serializationContext.Result.Failed)
break;
if (eachEntityTypeHasNavigationPropertiesInstance.GetType() != typeofEntityTypeHasNavigationProperties)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachEntityTypeHasNavigationPropertiesInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachEntityTypeHasNavigationPropertiesInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachEntityTypeHasNavigationPropertiesInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachEntityTypeHasNavigationPropertiesInstance.NavigationProperty;
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();
}
// Inheritance
global::System.Collections.ObjectModel.ReadOnlyCollection<global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.Inheritance> allInheritanceInstances = global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.Inheritance.GetLinksToDerivedTypes(element);
if (!serializationContext.Result.Failed && allInheritanceInstances.Count > 0)
{
DslModeling::DomainRelationshipXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.Inheritance.DomainClassId) as DslModeling::DomainRelationshipXmlSerializer;
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for Inheritance!");
writer.WriteStartElement("derivedTypes");
global::System.Type typeofInheritance = typeof(global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.Inheritance);
foreach (global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.Inheritance eachInheritanceInstance in allInheritanceInstances)
{
if (serializationContext.Result.Failed)
break;
if (eachInheritanceInstance.GetType() != typeofInheritance)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachInheritanceInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachInheritanceInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachInheritanceInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachInheritanceInstance.TargetEntityType;
DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer(targetElement.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(targetSerializer != null, "Cannot find serializer for " + targetElement.GetDomainClass().Name + "!");
targetSerializer.WriteMoniker(serializationContext, targetElement, writer, element, relSerializer);
}
}
writer.WriteEndElement();
}
}
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, ModelClass element, global::System.Xml.XmlWriter writer)
{
// ManyToOneRelation
global::System.Collections.ObjectModel.ReadOnlyCollection<ManyToOneRelation> allManyToOneRelationInstances = ManyToOneRelation.GetLinksToTargets(element);
if (!serializationContext.Result.Failed && allManyToOneRelationInstances.Count > 0)
{
writer.WriteStartElement("targets");
foreach (ManyToOneRelation eachManyToOneRelationInstance in allManyToOneRelationInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachManyToOneRelationInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachManyToOneRelationInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachManyToOneRelationInstance, writer);
}
writer.WriteEndElement();
}
// ClassHasProperty
global::System.Collections.ObjectModel.ReadOnlyCollection<ClassHasProperty> allClassHasPropertyInstances = ClassHasProperty.GetLinksToProperties(element);
if (!serializationContext.Result.Failed && allClassHasPropertyInstances.Count > 0)
{
writer.WriteStartElement("properties");
global::System.Type typeofClassHasProperty = typeof(ClassHasProperty);
foreach (ClassHasProperty eachClassHasPropertyInstance in allClassHasPropertyInstances)
{
if (serializationContext.Result.Failed)
break;
if (eachClassHasPropertyInstance.GetType() != typeofClassHasProperty)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachClassHasPropertyInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachClassHasPropertyInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachClassHasPropertyInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachClassHasPropertyInstance.Property;
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();
}
// ManyToManyRelation
global::System.Collections.ObjectModel.ReadOnlyCollection<ManyToManyRelation> allManyToManyRelationInstances = ManyToManyRelation.GetLinksToManyToManyTargets(element);
if (!serializationContext.Result.Failed && allManyToManyRelationInstances.Count > 0)
{
writer.WriteStartElement("manyToManyTargets");
foreach (ManyToManyRelation eachManyToManyRelationInstance in allManyToManyRelationInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachManyToManyRelationInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachManyToManyRelationInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachManyToManyRelationInstance, writer);
}
writer.WriteEndElement();
}
// OneToOneRelation
OneToOneRelation theOneToOneRelationInstance = OneToOneRelation.GetLinkToOneToOneTarget(element);
if (!serializationContext.Result.Failed && theOneToOneRelationInstance != null)
{
writer.WriteStartElement("oneToOneTarget");
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(theOneToOneRelationInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + theOneToOneRelationInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, theOneToOneRelationInstance, writer);
writer.WriteEndElement();
}
// InheritanceRelation
global::System.Collections.ObjectModel.ReadOnlyCollection<InheritanceRelation> allInheritanceRelationInstances = InheritanceRelation.GetLinksToTargetModelClasses(element);
if (!serializationContext.Result.Failed && allInheritanceRelationInstances.Count > 0)
{
DslModeling::DomainRelationshipXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(InheritanceRelation.DomainClassId) as DslModeling::DomainRelationshipXmlSerializer;
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for InheritanceRelation!");
writer.WriteStartElement("targetModelClasses");
global::System.Type typeofInheritanceRelation = typeof(InheritanceRelation);
foreach (InheritanceRelation eachInheritanceRelationInstance in allInheritanceRelationInstances)
{
if (serializationContext.Result.Failed)
break;
if (eachInheritanceRelationInstance.GetType() != typeofInheritanceRelation)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachInheritanceRelationInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachInheritanceRelationInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachInheritanceRelationInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachInheritanceRelationInstance.TargetModelClass;
DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer(targetElement.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(targetSerializer != null, "Cannot find serializer for " + targetElement.GetDomainClass().Name + "!");
targetSerializer.WriteMoniker(serializationContext, targetElement, writer, element, relSerializer);
}
}
writer.WriteEndElement();
}
}
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, MultipleAssociation element, global::System.Xml.XmlWriter writer)
{
// MultipleAssociationRole
global::System.Collections.ObjectModel.ReadOnlyCollection<MultipleAssociationRole> allMultipleAssociationRoleInstances = MultipleAssociationRole.GetLinksToTypes(element);
if (!serializationContext.Result.Failed && allMultipleAssociationRoleInstances.Count > 0)
{
writer.WriteStartElement("types");
foreach (MultipleAssociationRole eachMultipleAssociationRoleInstance in allMultipleAssociationRoleInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachMultipleAssociationRoleInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachMultipleAssociationRoleInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachMultipleAssociationRoleInstance, writer);
}
writer.WriteEndElement();
}
// AssociationClassRelationship
AssociationClassRelationship theAssociationClassRelationshipInstance = AssociationClassRelationship.GetLinkToAssociationClass(element);
if (!serializationContext.Result.Failed && theAssociationClassRelationshipInstance != null)
{
DslModeling::DomainRelationshipXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(AssociationClassRelationship.DomainClassId) as DslModeling::DomainRelationshipXmlSerializer;
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for AssociationClassRelationship!");
writer.WriteStartElement("associationClass");
global::System.Type typeofAssociationClassRelationship = typeof(AssociationClassRelationship);
if (theAssociationClassRelationshipInstance.GetType() != typeofAssociationClassRelationship)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(theAssociationClassRelationshipInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + theAssociationClassRelationshipInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, theAssociationClassRelationshipInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = theAssociationClassRelationshipInstance.AssociationClass;
DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer(targetElement.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(targetSerializer != null, "Cannot find serializer for " + targetElement.GetDomainClass().Name + "!");
targetSerializer.WriteMoniker(serializationContext, targetElement, writer, element, relSerializer);
}
writer.WriteEndElement();
}
}
protected virtual void WriteReferenceRelationshipRoleTransitionStateBaseTarget(DslModeling::SerializationContext serializationContext, global::Tum.StateMachineDSL.Transition instance, global::System.Xml.XmlWriter writer, DslEditorModeling::SerializationOptions options)
{
#region Save ReferenceRelationship Transition Roles
if (!serializationContext.Result.Failed)
{
// Write StateBaseTarget link id
writer.WriteStartElement("StateBaseTargetRef");
string valueId = StateMachineLanguageSerializationHelper.Instance.ConvertIdTo(serializationContext, instance.StateBaseTarget.Id);
writer.WriteAttributeString("link", valueId);
writer.WriteEndElement();
}
#endregion
}
protected virtual void WriteReferenceRelationshipMarriedTo(DslModeling::SerializationContext serializationContext, global::Tum.FamilyTreeDSL.FamilyTreePerson instance, global::System.Xml.XmlWriter writer, DslEditorModeling::SerializationOptions options)
{
#region Save ReferenceRelationship MarriedTo
global::Tum.FamilyTreeDSL.MarriedTo allMMarriedToInstance = global::Tum.FamilyTreeDSL.MarriedTo.GetLinkToWife(instance);
if( allMMarriedToInstance != null )
{
if (!serializationContext.Result.Failed)
{
// Write target link
writer.WriteStartElement("WifeRef");
string valueId = FamilyTreeDSLSerializationHelper.Instance.ConvertIdTo(serializationContext, (allMMarriedToInstance ).Wife.Id);
writer.WriteAttributeString("link", valueId);
writer.WriteEndElement();
}
}
#endregion
}
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, SuppliedAsset element, global::System.Xml.XmlWriter writer)
{
// SuppliedAssetCopiesToProducedAssets
global::System.Collections.ObjectModel.ReadOnlyCollection<SuppliedAssetCopiesToProducedAssets> allSuppliedAssetCopiesToProducedAssetsInstances = SuppliedAssetCopiesToProducedAssets.GetLinksToProducedAssets(element);
if (!serializationContext.Result.Failed && allSuppliedAssetCopiesToProducedAssetsInstances.Count > 0)
{
writer.WriteStartElement("producedAssets");
foreach (SuppliedAssetCopiesToProducedAssets eachSuppliedAssetCopiesToProducedAssetsInstance in allSuppliedAssetCopiesToProducedAssetsInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachSuppliedAssetCopiesToProducedAssetsInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachSuppliedAssetCopiesToProducedAssetsInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachSuppliedAssetCopiesToProducedAssetsInstance, writer);
}
writer.WriteEndElement();
}
// SuppliedAssetSuppliesProductionTools
global::System.Collections.ObjectModel.ReadOnlyCollection<SuppliedAssetSuppliesProductionTools> allSuppliedAssetSuppliesProductionToolsInstances = SuppliedAssetSuppliesProductionTools.GetLinksToProductionTools(element);
if (!serializationContext.Result.Failed && allSuppliedAssetSuppliesProductionToolsInstances.Count > 0)
{
writer.WriteStartElement("productionTools");
foreach (SuppliedAssetSuppliesProductionTools eachSuppliedAssetSuppliesProductionToolsInstance in allSuppliedAssetSuppliesProductionToolsInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachSuppliedAssetSuppliesProductionToolsInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachSuppliedAssetSuppliesProductionToolsInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachSuppliedAssetSuppliesProductionToolsInstance, writer);
}
writer.WriteEndElement();
}
}
/// <summary>
/// Public WriteMoniker() method that writes a monikerized SubProcessElement instance into XML.
/// </summary>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="element">SubProcessElement instance to be monikerized.</param>
/// <param name="writer">XmlWriter to write serialized data to.</param>
/// <param name="sourceRolePlayer">Source element that references the SubProcessElement instance being monikerized.</param>
/// <param name="relSerializer">Serializer that handles the relationship connecting the source element to the SubProcessElement instance being monikerized.</param>
public override void WriteMoniker(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, DslModeling::ModelElement sourceRolePlayer, DslModeling::DomainRelationshipXmlSerializer relSerializer)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert (serializationContext != null);
if (serializationContext == null)
throw new global::System.ArgumentNullException ("serializationContext");
global::System.Diagnostics.Debug.Assert (element != null);
if (element == null)
throw new global::System.ArgumentNullException ("element");
global::System.Diagnostics.Debug.Assert (writer != null);
if (writer == null)
throw new global::System.ArgumentNullException ("writer");
global::System.Diagnostics.Debug.Assert (sourceRolePlayer != null);
if (sourceRolePlayer == null)
throw new global::System.ArgumentNullException ("sourceRolePlayer");
global::System.Diagnostics.Debug.Assert (relSerializer != null);
if (relSerializer == null)
throw new global::System.ArgumentNullException ("relSerializer");
#endregion
string monikerString = relSerializer.SerializeReference(serializationContext, sourceRolePlayer, element);
global::System.Diagnostics.Debug.Assert(!string.IsNullOrEmpty(monikerString));
writer.WriteStartElement(this.MonikerTagName);
CloudCoreArchitectProcessOverviewSerializationHelper.Instance.WriteAttributeString(serializationContext, element, writer, this.MonikerAttributeName, monikerString);
writer.WriteEndElement();
}
protected virtual void WriteReferenceRelationshipParentOf(DslModeling::SerializationContext serializationContext, global::Tum.FamilyTreeDSL.FamilyTreePerson instance, global::System.Xml.XmlWriter writer, DslEditorModeling::SerializationOptions options)
{
#region Save ReferenceRelationship ParentOf
global::System.Collections.ObjectModel.ReadOnlyCollection<global::Tum.FamilyTreeDSL.ParentOf> allMParentOfInstances = global::Tum.FamilyTreeDSL.ParentOf.GetLinksToChildren(instance);
foreach(global::Tum.FamilyTreeDSL.ParentOf allMParentOfInstance in allMParentOfInstances)
{
if (!serializationContext.Result.Failed)
{
// Write target link
writer.WriteStartElement("ChildRef");
string valueId = FamilyTreeDSLSerializationHelper.Instance.ConvertIdTo(serializationContext, (allMParentOfInstance ).Child.Id);
writer.WriteAttributeString("link", valueId);
writer.WriteEndElement();
}
}
#endregion
}
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, SqlMapperMappingDiagram element, global::System.Xml.XmlWriter writer)
{
// SqlMapperMappingDiagramReferencesEntityShapes
global::System.Collections.ObjectModel.ReadOnlyCollection<SqlMapperMappingDiagramReferencesEntityShapes> allSqlMapperMappingDiagramReferencesEntityShapesInstances = SqlMapperMappingDiagramReferencesEntityShapes.GetLinksToEntityShapes(element);
if (!serializationContext.Result.Failed && allSqlMapperMappingDiagramReferencesEntityShapesInstances.Count > 0)
{
writer.WriteStartElement("entityShapes");
foreach (SqlMapperMappingDiagramReferencesEntityShapes eachSqlMapperMappingDiagramReferencesEntityShapesInstance in allSqlMapperMappingDiagramReferencesEntityShapesInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachSqlMapperMappingDiagramReferencesEntityShapesInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachSqlMapperMappingDiagramReferencesEntityShapesInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachSqlMapperMappingDiagramReferencesEntityShapesInstance, writer);
}
writer.WriteEndElement();
}
}
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, EntityShape element, global::System.Xml.XmlWriter writer)
{
// EntityShapeReferencesRelationshipshape
global::System.Collections.ObjectModel.ReadOnlyCollection<EntityShapeReferencesRelationshipshape> allEntityShapeReferencesRelationshipshapeInstances = EntityShapeReferencesRelationshipshape.GetLinksToRelationshipshape(element);
if (!serializationContext.Result.Failed && allEntityShapeReferencesRelationshipshapeInstances.Count > 0)
{
writer.WriteStartElement("relationshipshape");
foreach (EntityShapeReferencesRelationshipshape eachEntityShapeReferencesRelationshipshapeInstance in allEntityShapeReferencesRelationshipshapeInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachEntityShapeReferencesRelationshipshapeInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachEntityShapeReferencesRelationshipshapeInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachEntityShapeReferencesRelationshipshapeInstance, writer);
}
writer.WriteEndElement();
}
}
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, DominDriveDesignModel element, global::System.Xml.XmlWriter writer)
{
// DominDriveDesignModelHasAggregateRootEntity
global::System.Collections.ObjectModel.ReadOnlyCollection<DominDriveDesignModelHasAggregateRootEntity> allDominDriveDesignModelHasAggregateRootEntityInstances = DominDriveDesignModelHasAggregateRootEntity.GetLinksToAggregateRootEntity(element);
if (!serializationContext.Result.Failed && allDominDriveDesignModelHasAggregateRootEntityInstances.Count > 0)
{
writer.WriteStartElement("aggregateRootEntity");
foreach (DominDriveDesignModelHasAggregateRootEntity eachDominDriveDesignModelHasAggregateRootEntityInstance in allDominDriveDesignModelHasAggregateRootEntityInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachDominDriveDesignModelHasAggregateRootEntityInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachDominDriveDesignModelHasAggregateRootEntityInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachDominDriveDesignModelHasAggregateRootEntityInstance, writer);
}
writer.WriteEndElement();
}
// DominDriveDesignModelHasEntityModels
global::System.Collections.ObjectModel.ReadOnlyCollection<DominDriveDesignModelHasEntityModels> allDominDriveDesignModelHasEntityModelsInstances = DominDriveDesignModelHasEntityModels.GetLinksToEntityModels(element);
if (!serializationContext.Result.Failed && allDominDriveDesignModelHasEntityModelsInstances.Count > 0)
{
writer.WriteStartElement("entityModels");
foreach (DominDriveDesignModelHasEntityModels eachDominDriveDesignModelHasEntityModelsInstance in allDominDriveDesignModelHasEntityModelsInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachDominDriveDesignModelHasEntityModelsInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachDominDriveDesignModelHasEntityModelsInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachDominDriveDesignModelHasEntityModelsInstance, writer);
}
writer.WriteEndElement();
}
// DominDriveDesignModelHasDomainServiceModels
global::System.Collections.ObjectModel.ReadOnlyCollection<DominDriveDesignModelHasDomainServiceModels> allDominDriveDesignModelHasDomainServiceModelsInstances = DominDriveDesignModelHasDomainServiceModels.GetLinksToDomainServiceModels(element);
if (!serializationContext.Result.Failed && allDominDriveDesignModelHasDomainServiceModelsInstances.Count > 0)
{
writer.WriteStartElement("domainServiceModels");
foreach (DominDriveDesignModelHasDomainServiceModels eachDominDriveDesignModelHasDomainServiceModelsInstance in allDominDriveDesignModelHasDomainServiceModelsInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachDominDriveDesignModelHasDomainServiceModelsInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachDominDriveDesignModelHasDomainServiceModelsInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachDominDriveDesignModelHasDomainServiceModelsInstance, writer);
}
writer.WriteEndElement();
}
// DominDriveDesignModelHasFactoryModels
global::System.Collections.ObjectModel.ReadOnlyCollection<DominDriveDesignModelHasFactoryModels> allDominDriveDesignModelHasFactoryModelsInstances = DominDriveDesignModelHasFactoryModels.GetLinksToFactoryModels(element);
if (!serializationContext.Result.Failed && allDominDriveDesignModelHasFactoryModelsInstances.Count > 0)
{
writer.WriteStartElement("factoryModels");
foreach (DominDriveDesignModelHasFactoryModels eachDominDriveDesignModelHasFactoryModelsInstance in allDominDriveDesignModelHasFactoryModelsInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachDominDriveDesignModelHasFactoryModelsInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachDominDriveDesignModelHasFactoryModelsInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachDominDriveDesignModelHasFactoryModelsInstance, writer);
}
writer.WriteEndElement();
}
// DominDriveDesignModelHasValueObjectModels
global::System.Collections.ObjectModel.ReadOnlyCollection<DominDriveDesignModelHasValueObjectModels> allDominDriveDesignModelHasValueObjectModelsInstances = DominDriveDesignModelHasValueObjectModels.GetLinksToValueObjectModels(element);
if (!serializationContext.Result.Failed && allDominDriveDesignModelHasValueObjectModelsInstances.Count > 0)
{
writer.WriteStartElement("valueObjectModels");
foreach (DominDriveDesignModelHasValueObjectModels eachDominDriveDesignModelHasValueObjectModelsInstance in allDominDriveDesignModelHasValueObjectModelsInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachDominDriveDesignModelHasValueObjectModelsInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachDominDriveDesignModelHasValueObjectModelsInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachDominDriveDesignModelHasValueObjectModelsInstance, writer);
}
writer.WriteEndElement();
}
// DominDriveDesignModelHasDomainEventModels
global::System.Collections.ObjectModel.ReadOnlyCollection<DominDriveDesignModelHasDomainEventModels> allDominDriveDesignModelHasDomainEventModelsInstances = DominDriveDesignModelHasDomainEventModels.GetLinksToDomainEventModels(element);
if (!serializationContext.Result.Failed && allDominDriveDesignModelHasDomainEventModelsInstances.Count > 0)
{
writer.WriteStartElement("domainEventModels");
foreach (DominDriveDesignModelHasDomainEventModels eachDominDriveDesignModelHasDomainEventModelsInstance in allDominDriveDesignModelHasDomainEventModelsInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachDominDriveDesignModelHasDomainEventModelsInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachDominDriveDesignModelHasDomainEventModelsInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachDominDriveDesignModelHasDomainEventModelsInstance, writer);
}
writer.WriteEndElement();
}
}
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, Comment element, global::System.Xml.XmlWriter writer)
{
// CommentReferencesSubjects
global::System.Collections.ObjectModel.ReadOnlyCollection<CommentReferencesSubjects> allCommentReferencesSubjectsInstances = CommentReferencesSubjects.GetLinksToSubjects(element);
if (!serializationContext.Result.Failed && allCommentReferencesSubjectsInstances.Count > 0)
{
DslModeling::DomainRelationshipXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(CommentReferencesSubjects.DomainClassId) as DslModeling::DomainRelationshipXmlSerializer;
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for CommentReferencesSubjects!");
writer.WriteStartElement("subjects");
global::System.Type typeofCommentReferencesSubjects = typeof(CommentReferencesSubjects);
foreach (CommentReferencesSubjects eachCommentReferencesSubjectsInstance in allCommentReferencesSubjectsInstances)
{
if (serializationContext.Result.Failed)
break;
if (eachCommentReferencesSubjectsInstance.GetType() != typeofCommentReferencesSubjects)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachCommentReferencesSubjectsInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachCommentReferencesSubjectsInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachCommentReferencesSubjectsInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachCommentReferencesSubjectsInstance.Subject;
DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer(targetElement.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(targetSerializer != null, "Cannot find serializer for " + targetElement.GetDomainClass().Name + "!");
targetSerializer.WriteMoniker(serializationContext, targetElement, writer, element, relSerializer);
}
}
writer.WriteEndElement();
}
}
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, VariabilityRequirement element, global::System.Xml.XmlWriter writer)
{
// ParentVariabilityRequirementHasParentVariabilityRequirements
global::System.Collections.ObjectModel.ReadOnlyCollection<ParentVariabilityRequirementHasParentVariabilityRequirements> allParentVariabilityRequirementHasParentVariabilityRequirementsInstances = ParentVariabilityRequirementHasParentVariabilityRequirements.GetLinksToVariabilityRequirements(element);
if (!serializationContext.Result.Failed && allParentVariabilityRequirementHasParentVariabilityRequirementsInstances.Count > 0)
{
writer.WriteStartElement("variabilityRequirements");
foreach (ParentVariabilityRequirementHasParentVariabilityRequirements eachParentVariabilityRequirementHasParentVariabilityRequirementsInstance in allParentVariabilityRequirementHasParentVariabilityRequirementsInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachParentVariabilityRequirementHasParentVariabilityRequirementsInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachParentVariabilityRequirementHasParentVariabilityRequirementsInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachParentVariabilityRequirementHasParentVariabilityRequirementsInstance, writer);
}
writer.WriteEndElement();
}
}
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, ModelInterface element, global::System.Xml.XmlWriter writer)
{
// InterfaceHasOperation
global::System.Collections.ObjectModel.ReadOnlyCollection<InterfaceHasOperation> allInterfaceHasOperationInstances = InterfaceHasOperation.GetLinksToOperations(element);
if (!serializationContext.Result.Failed && allInterfaceHasOperationInstances.Count > 0)
{
writer.WriteStartElement("operations");
global::System.Type typeofInterfaceHasOperation = typeof(InterfaceHasOperation);
foreach (InterfaceHasOperation eachInterfaceHasOperationInstance in allInterfaceHasOperationInstances)
{
if (serializationContext.Result.Failed)
break;
if (eachInterfaceHasOperationInstance.GetType() != typeofInterfaceHasOperation)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachInterfaceHasOperationInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachInterfaceHasOperationInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachInterfaceHasOperationInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachInterfaceHasOperationInstance.Operation;
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();
}
// Implementation
global::System.Collections.ObjectModel.ReadOnlyCollection<Implementation> allImplementationInstances = Implementation.GetLinksToImplementors(element);
if (!serializationContext.Result.Failed && allImplementationInstances.Count > 0)
{
DslModeling::DomainRelationshipXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(Implementation.DomainClassId) as DslModeling::DomainRelationshipXmlSerializer;
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for Implementation!");
writer.WriteStartElement("implementors");
global::System.Type typeofImplementation = typeof(Implementation);
foreach (Implementation eachImplementationInstance in allImplementationInstances)
{
if (serializationContext.Result.Failed)
break;
if (eachImplementationInstance.GetType() != typeofImplementation)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachImplementationInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachImplementationInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachImplementationInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachImplementationInstance.Implementor;
DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer(targetElement.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(targetSerializer != null, "Cannot find serializer for " + targetElement.GetDomainClass().Name + "!");
targetSerializer.WriteMoniker(serializationContext, targetElement, writer, element, relSerializer);
}
}
writer.WriteEndElement();
}
}
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, CustomizationPolicySchema element, global::System.Xml.XmlWriter writer)
{
// PolicyHasSettings
global::System.Collections.ObjectModel.ReadOnlyCollection<PolicyHasSettings> allPolicyHasSettingsInstances = PolicyHasSettings.GetLinksToSettings(element);
if (!serializationContext.Result.Failed && allPolicyHasSettingsInstances.Count > 0)
{
writer.WriteStartElement("settings");
global::System.Type typeofPolicyHasSettings = typeof(PolicyHasSettings);
foreach (PolicyHasSettings eachPolicyHasSettingsInstance in allPolicyHasSettingsInstances)
{
if (serializationContext.Result.Failed)
break;
if (eachPolicyHasSettingsInstance.GetType() != typeofPolicyHasSettings)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachPolicyHasSettingsInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachPolicyHasSettingsInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachPolicyHasSettingsInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachPolicyHasSettingsInstance.CustomizableSettingSchema;
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();
}
}
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, View element, global::System.Xml.XmlWriter writer)
{
// ViewHasElements
global::System.Collections.ObjectModel.ReadOnlyCollection<ViewHasElements> allViewHasElementsInstances = ViewHasElements.GetLinksToElements(element);
if (!serializationContext.Result.Failed && allViewHasElementsInstances.Count > 0)
{
writer.WriteStartElement("elements");
global::System.Type typeofViewHasElements = typeof(ViewHasElements);
foreach (ViewHasElements eachViewHasElementsInstance in allViewHasElementsInstances)
{
if (serializationContext.Result.Failed)
break;
if (eachViewHasElementsInstance.GetType() != typeofViewHasElements)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachViewHasElementsInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachViewHasElementsInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachViewHasElementsInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachViewHasElementsInstance.AbstractElement;
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();
}
// ViewHasExtensionProducts
global::System.Collections.ObjectModel.ReadOnlyCollection<ViewHasExtensionProducts> allViewHasExtensionProductsInstances = ViewHasExtensionProducts.GetLinksToExtensionProducts(element);
if (!serializationContext.Result.Failed && allViewHasExtensionProductsInstances.Count > 0)
{
writer.WriteStartElement("extensionProducts");
global::System.Type typeofViewHasExtensionProducts = typeof(ViewHasExtensionProducts);
foreach (ViewHasExtensionProducts eachViewHasExtensionProductsInstance in allViewHasExtensionProductsInstances)
{
if (serializationContext.Result.Failed)
break;
if (eachViewHasExtensionProductsInstance.GetType() != typeofViewHasExtensionProducts)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachViewHasExtensionProductsInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachViewHasExtensionProductsInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachViewHasExtensionProductsInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachViewHasExtensionProductsInstance.Extension;
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();
}
}
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>
/// Serialize all child model elements.
/// </summary>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="element">EntityDesignerViewModel instance to be serialized.</param>
/// <param name="writer">XmlWriter to write serialized data to.</param>
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.EntityDesignerViewModel element, global::System.Xml.XmlWriter writer)
{
// EntityDesignerViewModelHasEntityTypes
global::System.Collections.ObjectModel.ReadOnlyCollection<EntityDesignerViewModelHasEntityTypes> allEntityDesignerViewModelHasEntityTypesInstances = EntityDesignerViewModelHasEntityTypes.GetLinksToEntityTypes(element);
if (!serializationContext.Result.Failed && allEntityDesignerViewModelHasEntityTypesInstances.Count > 0)
{
writer.WriteStartElement("entityTypes");
global::System.Type typeofEntityDesignerViewModelHasEntityTypes = typeof(EntityDesignerViewModelHasEntityTypes);
foreach (EntityDesignerViewModelHasEntityTypes eachEntityDesignerViewModelHasEntityTypesInstance in allEntityDesignerViewModelHasEntityTypesInstances)
{
if (serializationContext.Result.Failed)
break;
if (eachEntityDesignerViewModelHasEntityTypesInstance.GetType() != typeofEntityDesignerViewModelHasEntityTypes)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachEntityDesignerViewModelHasEntityTypesInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachEntityDesignerViewModelHasEntityTypesInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachEntityDesignerViewModelHasEntityTypesInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachEntityDesignerViewModelHasEntityTypesInstance.EntityType;
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();
}
}
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, DesignPattern element, global::System.Xml.XmlWriter writer)
{
// DesignPatternHasAbstractClasses
global::System.Collections.ObjectModel.ReadOnlyCollection<DesignPatternHasAbstractClasses> allDesignPatternHasAbstractClassesInstances = DesignPatternHasAbstractClasses.GetLinksToAbstractClasses(element);
if (!serializationContext.Result.Failed && allDesignPatternHasAbstractClassesInstances.Count > 0)
{
writer.WriteStartElement("abstractClasses");
foreach (DesignPatternHasAbstractClasses eachDesignPatternHasAbstractClassesInstance in allDesignPatternHasAbstractClassesInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachDesignPatternHasAbstractClassesInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachDesignPatternHasAbstractClassesInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachDesignPatternHasAbstractClassesInstance, writer);
}
writer.WriteEndElement();
}
// DesignPatternHasConcreteClasses
global::System.Collections.ObjectModel.ReadOnlyCollection<DesignPatternHasConcreteClasses> allDesignPatternHasConcreteClassesInstances = DesignPatternHasConcreteClasses.GetLinksToConcreteClasses(element);
if (!serializationContext.Result.Failed && allDesignPatternHasConcreteClassesInstances.Count > 0)
{
writer.WriteStartElement("concreteClasses");
foreach (DesignPatternHasConcreteClasses eachDesignPatternHasConcreteClassesInstance in allDesignPatternHasConcreteClassesInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachDesignPatternHasConcreteClassesInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachDesignPatternHasConcreteClassesInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachDesignPatternHasConcreteClassesInstance, writer);
}
writer.WriteEndElement();
}
}
/// <summary>
/// Public Write() method that serializes one Test instance into XML.
/// </summary>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="element">Test instance to be serialized.</param>
/// <param name="writer">XmlWriter to write serialized data to.</param>
/// <param name="rootElementSettings">
/// The root element settings if the passed in element is serialized as a root element in the XML. The root element contains additional
/// information like schema target namespace, version, etc.
/// This should only be passed for root-level elements. Null should be passed for rest elements (and ideally call the Write() method
/// without this parameter).
/// </param>
/// <param name="options">Serialization options.</param>
public override void Write(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, DslModeling::RootElementSettings rootElementSettings, DslEditorModeling::SerializationOptions options)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert (serializationContext != null);
if (serializationContext == null)
throw new global::System.ArgumentNullException ("serializationContext");
global::System.Diagnostics.Debug.Assert (element != null);
if (element == null)
throw new global::System.ArgumentNullException ("element");
global::System.Diagnostics.Debug.Assert (writer != null);
if (writer == null)
throw new global::System.ArgumentNullException ("writer");
#endregion
// Write start of element, including schema target namespace if specified.
writer.WriteStartElement(this.XmlTagName);
if (!serializationContext.Result.Failed)
{
WritePropertiesAsAttributes(serializationContext, element, writer, options);
}
if (!serializationContext.Result.Failed)
{
// Write 1) properties serialized as nested XML elements and 2) child model elements into XML.
WriteElements(serializationContext, element, writer, options);
}
writer.WriteEndElement();
}
/// <summary>
/// Public Write() method that serializes one MultipleAssociationRole instance into XML.
/// </summary>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="element">MultipleAssociationRole instance to be serialized.</param>
/// <param name="writer">XmlWriter to write serialized data to.</param>
/// <param name="rootElementSettings">
/// The root element settings if the passed in element is serialized as a root element in the XML. The root element contains additional
/// information like schema target namespace, version, etc.
/// This should only be passed for root-level elements. Null should be passed for rest elements (and ideally call the Write() method
/// without this parameter).
/// </param>
public override void Write(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, DslModeling::RootElementSettings rootElementSettings)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert (serializationContext != null);
if (serializationContext == null)
throw new global::System.ArgumentNullException ("serializationContext");
global::System.Diagnostics.Debug.Assert (element != null);
if (element == null)
throw new global::System.ArgumentNullException ("element");
global::System.Diagnostics.Debug.Assert (writer != null);
if (writer == null)
throw new global::System.ArgumentNullException ("writer");
#endregion
// Write start of element, including schema target namespace if specified.
if (rootElementSettings != null && !string.IsNullOrEmpty(rootElementSettings.SchemaTargetNamespace))
writer.WriteStartElement(this.XmlTagName, rootElementSettings.SchemaTargetNamespace);
else
writer.WriteStartElement(this.XmlTagName);
// Write version info (in the format 1.2.3.4), if necessary
if (rootElementSettings != null && rootElementSettings.Version != null)
writer.WriteAttributeString("dslVersion", rootElementSettings.Version.ToString(4));
WritePropertiesAsAttributes(serializationContext, element, writer);
// Write the target role-player instance.
MultipleAssociationRole instance = element as MultipleAssociationRole;
global::System.Diagnostics.Debug.Assert(instance != null, "Expecting an instance of MultipleAssociationRole!");
DslModeling::ModelElement targetElement = instance.Type;
DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer(targetElement.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(targetSerializer != null, "Cannot find serializer for " + targetElement.GetDomainClass().Name + "!");
targetSerializer.WriteMoniker(serializationContext, targetElement, writer, instance.MultipleAssociation, this);
if (!serializationContext.Result.Failed)
{
// Write 1) properties serialized as nested XML elements and 2) child model elements into XML.
WriteElements(serializationContext, element, writer);
}
writer.WriteEndElement();
}
/// <summary>
/// Public Write() method that serializes one NestedClass instance into XML.
/// </summary>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="element">NestedClass instance to be serialized.</param>
/// <param name="writer">XmlWriter to write serialized data to.</param>
/// <param name="rootElementSettings">
/// The root element settings if the passed in element is serialized as a root element in the XML. The root element contains additional
/// information like schema target namespace, version, etc.
/// This should only be passed for root-level elements. Null should be passed for rest elements (and ideally call the Write() method
/// without this parameter).
/// </param>
public override void Write(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, DslModeling::RootElementSettings rootElementSettings)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert (serializationContext != null);
if (serializationContext == null)
throw new global::System.ArgumentNullException ("serializationContext");
global::System.Diagnostics.Debug.Assert (element != null);
if (element == null)
throw new global::System.ArgumentNullException ("element");
global::System.Diagnostics.Debug.Assert (writer != null);
if (writer == null)
throw new global::System.ArgumentNullException ("writer");
#endregion
// Write start of element, including schema target namespace if specified.
if (rootElementSettings != null && !string.IsNullOrEmpty(rootElementSettings.SchemaTargetNamespace))
{
writer.WriteStartElement(XmlTagName, rootElementSettings.SchemaTargetNamespace);
DslModeling::SerializationUtilities.WriteDomainModelNamespaces(serializationContext.Directory, writer, rootElementSettings.SchemaTargetNamespace);
}
else
{
writer.WriteStartElement(XmlTagName);
}
// Write version info (in the format 1.2.3.4), if necessary
if (rootElementSettings != null && rootElementSettings.Version != null)
writer.WriteAttributeString("dslVersion", rootElementSettings.Version.ToString(4));
WritePropertiesAsAttributes(serializationContext, element, writer);
// Write out any extension data if this is the root element
if (rootElementSettings != null && !serializationContext.Result.Failed)
{
ActiveWriterSerializationHelper.Instance.WriteExtensions(serializationContext, element, writer);
}
if (!serializationContext.Result.Failed)
{
// Write 1) properties serialized as nested XML elements and 2) child model elements into XML.
WriteElements(serializationContext, element, writer);
}
writer.WriteEndElement();
}
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, ModelClass element, global::System.Xml.XmlWriter writer)
{
// UnidirectionalAssociation
global::System.Collections.ObjectModel.ReadOnlyCollection<UnidirectionalAssociation> allUnidirectionalAssociationInstances = UnidirectionalAssociation.GetLinksToUnidirectionalTargets(element);
if (!serializationContext.Result.Failed && allUnidirectionalAssociationInstances.Count > 0)
{
writer.WriteStartElement("unidirectionalTargets");
foreach (UnidirectionalAssociation eachUnidirectionalAssociationInstance in allUnidirectionalAssociationInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachUnidirectionalAssociationInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachUnidirectionalAssociationInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachUnidirectionalAssociationInstance, writer);
}
writer.WriteEndElement();
}
// ClassHasAttributes
global::System.Collections.ObjectModel.ReadOnlyCollection<ClassHasAttributes> allClassHasAttributesInstances = ClassHasAttributes.GetLinksToAttributes(element);
if (!serializationContext.Result.Failed && allClassHasAttributesInstances.Count > 0)
{
writer.WriteStartElement("attributes");
global::System.Type typeofClassHasAttributes = typeof(ClassHasAttributes);
foreach (ClassHasAttributes eachClassHasAttributesInstance in allClassHasAttributesInstances)
{
if (serializationContext.Result.Failed)
break;
if (eachClassHasAttributesInstance.GetType() != typeofClassHasAttributes)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachClassHasAttributesInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachClassHasAttributesInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachClassHasAttributesInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachClassHasAttributesInstance.Attribute;
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();
}
// ClassHasOperations
global::System.Collections.ObjectModel.ReadOnlyCollection<ClassHasOperations> allClassHasOperationsInstances = ClassHasOperations.GetLinksToOperations(element);
if (!serializationContext.Result.Failed && allClassHasOperationsInstances.Count > 0)
{
writer.WriteStartElement("operations");
global::System.Type typeofClassHasOperations = typeof(ClassHasOperations);
foreach (ClassHasOperations eachClassHasOperationsInstance in allClassHasOperationsInstances)
{
if (serializationContext.Result.Failed)
break;
if (eachClassHasOperationsInstance.GetType() != typeofClassHasOperations)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachClassHasOperationsInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachClassHasOperationsInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachClassHasOperationsInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachClassHasOperationsInstance.Operation;
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();
}
// Generalization
global::System.Collections.ObjectModel.ReadOnlyCollection<Generalization> allGeneralizationInstances = Generalization.GetLinksToSubclasses(element);
if (!serializationContext.Result.Failed && allGeneralizationInstances.Count > 0)
{
writer.WriteStartElement("subclasses");
foreach (Generalization eachGeneralizationInstance in allGeneralizationInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachGeneralizationInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachGeneralizationInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachGeneralizationInstance, writer);
}
writer.WriteEndElement();
}
// BidirectionalAssociation
global::System.Collections.ObjectModel.ReadOnlyCollection<BidirectionalAssociation> allBidirectionalAssociationInstances = BidirectionalAssociation.GetLinksToBidirectionalTargets(element);
if (!serializationContext.Result.Failed && allBidirectionalAssociationInstances.Count > 0)
{
writer.WriteStartElement("bidirectionalTargets");
foreach (BidirectionalAssociation eachBidirectionalAssociationInstance in allBidirectionalAssociationInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachBidirectionalAssociationInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachBidirectionalAssociationInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachBidirectionalAssociationInstance, writer);
}
writer.WriteEndElement();
}
// Aggregation
global::System.Collections.ObjectModel.ReadOnlyCollection<Aggregation> allAggregationInstances = Aggregation.GetLinksToAggregationTargets(element);
if (!serializationContext.Result.Failed && allAggregationInstances.Count > 0)
{
writer.WriteStartElement("aggregationTargets");
foreach (Aggregation eachAggregationInstance in allAggregationInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachAggregationInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachAggregationInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachAggregationInstance, writer);
}
writer.WriteEndElement();
}
// Composition
global::System.Collections.ObjectModel.ReadOnlyCollection<Composition> allCompositionInstances = Composition.GetLinksToCompositionTargets(element);
if (!serializationContext.Result.Failed && allCompositionInstances.Count > 0)
{
writer.WriteStartElement("compositionTargets");
foreach (Composition eachCompositionInstance in allCompositionInstances)
{
if (serializationContext.Result.Failed)
break;
DslModeling::DomainClassXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(eachCompositionInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for " + eachCompositionInstance.GetDomainClass().Name + "!");
relSerializer.Write(serializationContext, eachCompositionInstance, writer);
}
writer.WriteEndElement();
}
}
/// <summary>
/// Public WriteMoniker() method that writes a monikerized ManyToOneRelation instance into XML.
/// </summary>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="element">ManyToOneRelation instance to be monikerized.</param>
/// <param name="writer">XmlWriter to write serialized data to.</param>
/// <param name="sourceRolePlayer">Source element that references the ManyToOneRelation instance being monikerized.</param>
/// <param name="relSerializer">Serializer that handles the relationship connecting the source element to the ManyToOneRelation instance being monikerized.</param>
public override void WriteMoniker(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, DslModeling::ModelElement sourceRolePlayer, DslModeling::DomainRelationshipXmlSerializer relSerializer)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert (serializationContext != null);
if (serializationContext == null)
throw new global::System.ArgumentNullException ("serializationContext");
global::System.Diagnostics.Debug.Assert (element != null);
if (element == null)
throw new global::System.ArgumentNullException ("element");
global::System.Diagnostics.Debug.Assert (writer != null);
if (writer == null)
throw new global::System.ArgumentNullException ("writer");
global::System.Diagnostics.Debug.Assert (sourceRolePlayer != null);
if (sourceRolePlayer == null)
throw new global::System.ArgumentNullException ("sourceRolePlayer");
global::System.Diagnostics.Debug.Assert (relSerializer != null);
if (relSerializer == null)
throw new global::System.ArgumentNullException ("relSerializer");
#endregion
string monikerString = CalculateQualifiedName(serializationContext.Directory, element);
global::System.Diagnostics.Debug.Assert(!string.IsNullOrEmpty(monikerString));
writer.WriteStartElement(MonikerTagName);
ActiveWriterSerializationHelper.Instance.WriteAttributeString(serializationContext, element, writer, MonikerAttributeName, monikerString);
writer.WriteEndElement();
}
/// <summary>
/// Public Write() method that serializes one Comment instance into XML.
/// </summary>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="element">Comment instance to be serialized.</param>
/// <param name="writer">XmlWriter to write serialized data to.</param>
/// <param name="rootElementSettings">
/// The root element settings if the passed in element is serialized as a root element in the XML. The root element contains additional
/// information like schema target namespace, version, etc.
/// This should only be passed for root-level elements. Null should be passed for rest elements (and ideally call the Write() method
/// without this parameter).
/// </param>
public override void Write(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, DslModeling::RootElementSettings rootElementSettings)
{
#region Check Parameters
global::System.Diagnostics.Debug.Assert (serializationContext != null);
if (serializationContext == null)
throw new global::System.ArgumentNullException ("serializationContext");
global::System.Diagnostics.Debug.Assert (element != null);
if (element == null)
throw new global::System.ArgumentNullException ("element");
global::System.Diagnostics.Debug.Assert (writer != null);
if (writer == null)
throw new global::System.ArgumentNullException ("writer");
#endregion
// Write start of element, including schema target namespace if specified.
if (rootElementSettings != null && !string.IsNullOrEmpty(rootElementSettings.SchemaTargetNamespace))
writer.WriteStartElement(this.XmlTagName, rootElementSettings.SchemaTargetNamespace);
else
writer.WriteStartElement(this.XmlTagName);
// Write version info (in the format 1.2.3.4), if necessary
if (rootElementSettings != null && rootElementSettings.Version != null)
writer.WriteAttributeString("dslVersion", rootElementSettings.Version.ToString(4));
// Write out element Id.
writer.WriteAttributeString("Id", element.Id.ToString("D", global::System.Globalization.CultureInfo.CurrentCulture));
WritePropertiesAsAttributes(serializationContext, element, writer);
if (!serializationContext.Result.Failed)
{
// Write 1) properties serialized as nested XML elements and 2) child model elements into XML.
WriteElements(serializationContext, element, writer);
}
writer.WriteEndElement();
}
internal virtual void WriteElementCDATAString(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, string elementName, string elementValue)
{
writer.WriteStartElement(elementName);
writer.WriteCData(elementValue);
writer.WriteEndElement();
}
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, MessageBase element, global::System.Xml.XmlWriter writer)
{
// RequestReferencedByOperation
global::System.Collections.ObjectModel.ReadOnlyCollection<RequestReferencedByOperation> allRequestReferencedByOperationInstances = RequestReferencedByOperation.GetLinksToRequestFor(element);
if (!serializationContext.Result.Failed && allRequestReferencedByOperationInstances.Count > 0)
{
DslModeling::DomainRelationshipXmlSerializer relSerializer = serializationContext.Directory.GetSerializer(RequestReferencedByOperation.DomainClassId) as DslModeling::DomainRelationshipXmlSerializer;
global::System.Diagnostics.Debug.Assert(relSerializer != null, "Cannot find serializer for RequestReferencedByOperation!");
writer.WriteStartElement("requestFor");
global::System.Type typeofRequestReferencedByOperation = typeof(RequestReferencedByOperation);
foreach (RequestReferencedByOperation eachRequestReferencedByOperationInstance in allRequestReferencedByOperationInstances)
{
if (serializationContext.Result.Failed)
break;
if (eachRequestReferencedByOperationInstance.GetType() != typeofRequestReferencedByOperation)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachRequestReferencedByOperationInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachRequestReferencedByOperationInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachRequestReferencedByOperationInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachRequestReferencedByOperationInstance.Operation;
DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer(targetElement.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(targetSerializer != null, "Cannot find serializer for " + targetElement.GetDomainClass().Name + "!");
targetSerializer.WriteMoniker(serializationContext, targetElement, writer, element, relSerializer);
}
}
writer.WriteEndElement();
}
// MessageHasMessageParts
global::System.Collections.ObjectModel.ReadOnlyCollection<MessageHasMessageParts> allMessageHasMessagePartsInstances = MessageHasMessageParts.GetLinksToMessageParts(element);
if (!serializationContext.Result.Failed && allMessageHasMessagePartsInstances.Count > 0)
{
writer.WriteStartElement("messageParts");
global::System.Type typeofMessageHasMessageParts = typeof(MessageHasMessageParts);
foreach (MessageHasMessageParts eachMessageHasMessagePartsInstance in allMessageHasMessagePartsInstances)
{
if (serializationContext.Result.Failed)
break;
if (eachMessageHasMessagePartsInstance.GetType() != typeofMessageHasMessageParts)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachMessageHasMessagePartsInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachMessageHasMessagePartsInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachMessageHasMessagePartsInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachMessageHasMessagePartsInstance.MessagePart;
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();
}
}
