protected virtual void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
Model instanceOfModel = element as Model;
global::System.Diagnostics.Debug.Assert(instanceOfModel != null, "Expecting an instance of Model");
// UseNullables
if (!serializationContext.Result.Failed)
{
NullableUsage propValue = instanceOfModel.UseNullables;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<NullableUsage>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "No") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("useNullables", serializedPropValue);
}
}
}
// CaseOfPrivateFields
if (!serializationContext.Result.Failed)
{
FieldCase propValue = instanceOfModel.CaseOfPrivateFields;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<FieldCase>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "CamelcaseUnderscore") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("caseOfPrivateFields", serializedPropValue);
}
}
}
// GenerateMonoRailProject
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModel.GenerateMonoRailProject;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("generateMonoRailProject", serializedPropValue);
}
}
}
// MonoRailProjectName
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModel.MonoRailProjectName;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("monoRailProjectName", propValue);
}
}
// MonoRailProjectPath
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModel.MonoRailProjectPath;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("monoRailProjectPath", propValue);
}
}
// MonoRailDefaultLayout
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModel.MonoRailDefaultLayout;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, "default") != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("monoRailDefaultLayout", propValue);
}
}
}
// MonoRailDefaultRescue
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModel.MonoRailDefaultRescue;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, "generalerror") != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("monoRailDefaultRescue", propValue);
}
}
}
// MonoRailViewFileExtension
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModel.MonoRailViewFileExtension;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, ".vm") != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("monoRailViewFileExtension", propValue);
}
}
}
// UseGenerics
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModel.UseGenerics;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "true") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("useGenerics", serializedPropValue);
}
}
}
// UseBaseClass
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModel.UseBaseClass;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "true") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("useBaseClass", serializedPropValue);
}
}
}
// BaseClassName
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModel.BaseClassName;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("baseClassName", propValue);
}
}
// GeneratesDoubleDerived
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModel.GeneratesDoubleDerived;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("generatesDoubleDerived", serializedPropValue);
}
}
}
// DoubleDerivedNameSuffix
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModel.DoubleDerivedNameSuffix;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, "Base") != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("doubleDerivedNameSuffix", propValue);
}
}
}
// UseGeneratedCodeAttribute
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModel.UseGeneratedCodeAttribute;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("useGeneratedCodeAttribute", serializedPropValue);
}
}
}
// Target
if (!serializationContext.Result.Failed)
{
CodeGenerationTarget propValue = instanceOfModel.Target;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<CodeGenerationTarget>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "ActiveRecord") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("target", serializedPropValue);
}
}
}
// AssemblyPath
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModel.AssemblyPath;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("assemblyPath", propValue);
}
}
// ActiveRecordAssemblyName
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModel.ActiveRecordAssemblyName;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, "Castle.ActiveRecord") != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("activeRecordAssemblyName", propValue);
}
}
}
// NHibernateAssemblyName
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModel.NHibernateAssemblyName;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, "NHibernate") != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("nHibernateAssemblyName", propValue);
}
}
}
// RelateWithActiwFile
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModel.RelateWithActiwFile;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "true") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("relateWithActiwFile", serializedPropValue);
}
}
}
// UseVirtualProperties
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModel.UseVirtualProperties;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "true") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("useVirtualProperties", serializedPropValue);
}
}
}
// Namespace
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModel.Namespace;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("namespace", propValue);
}
}
// ImplementINotifyPropertyChanged
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModel.ImplementINotifyPropertyChanged;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("implementINotifyPropertyChanged", serializedPropValue);
}
}
}
// GenerateMetaData
if (!serializationContext.Result.Failed)
{
MetaDataGeneration propValue = instanceOfModel.GenerateMetaData;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<MetaDataGeneration>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "False") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("generateMetaData", serializedPropValue);
}
}
}
// UseNHQG
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModel.UseNHQG;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("useNHQG", serializedPropValue);
}
}
}
// NHQGExecutable
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModel.NHQGExecutable;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, "C:\\Program Files\\Rhino\\NHibernate Query Generator\\NHQG.exe") != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("nHQGExecutable", propValue);
}
}
}
// UseGenericRelations
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModel.UseGenericRelations;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "true") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("useGenericRelations", serializedPropValue);
}
}
}
// PropertyNameFilterExpression
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModel.PropertyNameFilterExpression;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("propertyNameFilterExpression", propValue);
}
}
// InitializeIListFields
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModel.InitializeIListFields;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("initializeIListFields", serializedPropValue);
}
}
}
}
/// <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();
}
/// <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>
public virtual void WriteAttributeString(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, string attributeName, string attributeValue)
{
writer.WriteAttributeString(attributeName, attributeValue);
}
/// <summary>
/// Public WriteMoniker() method that writes a monikerized UnidirectionalAssociation instance into XML.
/// </summary>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="element">UnidirectionalAssociation instance to be monikerized.</param>
/// <param name="writer">XmlWriter to write serialized data to.</param>
/// <param name="sourceRolePlayer">Source element that references the UnidirectionalAssociation instance being monikerized.</param>
/// <param name="relSerializer">Serializer that handles the relationship connecting the source element to the UnidirectionalAssociation 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 = this.CalculateQualifiedName(serializationContext.Directory, element);
global::System.Diagnostics.Debug.Assert(!string.IsNullOrEmpty(monikerString));
writer.WriteStartElement(this.MonikerTagName);
writer.WriteAttributeString(this.MonikerAttributeName, monikerString);
writer.WriteEndElement();
}
protected override void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, DslEditorModeling::SerializationOptions options)
{
global::Tum.StateMachineDSL.StateBase instance = element as global::Tum.StateMachineDSL.StateBase;
global::System.Diagnostics.Debug.Assert(instance != null, "Expecting an instance of StateBase");
// Domain Element Id
string valueId = StateMachineLanguageSerializationHelper.Instance.ConvertIdTo(serializationContext, element.Id);
writer.WriteAttributeString(StateMachineLanguageSerializationBehavior.Instance.IdSerializationNameDefaultContext, valueId);
}
protected override void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
base.WritePropertiesAsAttributes(serializationContext, element, writer);
Operation instanceOfOperation = element as Operation;
global::System.Diagnostics.Debug.Assert(instanceOfOperation != null, "Expecting an instance of Operation");
// Signature
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfOperation.Signature;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, string.Empty) != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("signature", propValue);
}
}
}
// Concurrency
if (!serializationContext.Result.Failed)
{
OperationConcurrency propValue = instanceOfOperation.Concurrency;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<OperationConcurrency>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Sequential") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("concurrency", serializedPropValue);
}
}
}
// Precondition
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfOperation.Precondition;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, string.Empty) != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("precondition", propValue);
}
}
}
// Postcondition
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfOperation.Postcondition;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, string.Empty) != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("postcondition", propValue);
}
}
}
}
protected override void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
base.WritePropertiesAsAttributes(serializationContext, element, writer);
ClassModelElement instanceOfClassModelElement = element as ClassModelElement;
global::System.Diagnostics.Debug.Assert(instanceOfClassModelElement != null, "Expecting an instance of ClassModelElement");
// Description
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfClassModelElement.Description;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, string.Empty) != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("description", propValue);
}
}
}
}
protected virtual void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
ManyToOneRelation instanceOfManyToOneRelation = element as ManyToOneRelation;
global::System.Diagnostics.Debug.Assert(instanceOfManyToOneRelation != null, "Expecting an instance of ManyToOneRelation");
// TargetCache
if (!serializationContext.Result.Failed)
{
CacheEnum propValue = instanceOfManyToOneRelation.TargetCache;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<CacheEnum>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Undefined") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("targetCache", serializedPropValue);
}
}
}
// TargetCascade
if (!serializationContext.Result.Failed)
{
ManyRelationCascadeEnum propValue = instanceOfManyToOneRelation.TargetCascade;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<ManyRelationCascadeEnum>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "None") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("targetCascade", serializedPropValue);
}
}
}
// TargetColumnKey
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfManyToOneRelation.TargetColumnKey;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("targetColumnKey", propValue);
}
}
// TargetCustomAccess
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfManyToOneRelation.TargetCustomAccess;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("targetCustomAccess", propValue);
}
}
// TargetInverse
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfManyToOneRelation.TargetInverse;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("targetInverse", serializedPropValue);
}
}
}
// TargetLazy
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfManyToOneRelation.TargetLazy;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("targetLazy", serializedPropValue);
}
}
}
// TargetMapType
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfManyToOneRelation.TargetMapType;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("targetMapType", propValue);
}
}
// TargetOrderBy
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfManyToOneRelation.TargetOrderBy;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("targetOrderBy", propValue);
}
}
// TargetRelationType
if (!serializationContext.Result.Failed)
{
RelationType propValue = instanceOfManyToOneRelation.TargetRelationType;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<RelationType>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Guess") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("targetRelationType", serializedPropValue);
}
}
}
// TargetSchema
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfManyToOneRelation.TargetSchema;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("targetSchema", propValue);
}
}
// TargetSort
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfManyToOneRelation.TargetSort;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("targetSort", propValue);
}
}
// TargetTable
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfManyToOneRelation.TargetTable;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("targetTable", propValue);
}
}
// TargetWhere
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfManyToOneRelation.TargetWhere;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("targetWhere", propValue);
}
}
// TargetDescription
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfManyToOneRelation.TargetDescription;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("targetDescription", propValue);
}
}
// TargetPropertyName
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfManyToOneRelation.TargetPropertyName;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("targetPropertyName", propValue);
}
}
// TargetPropertyType
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfManyToOneRelation.TargetPropertyType;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, "IList") != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("targetPropertyType", propValue);
}
}
}
// SourceCascade
if (!serializationContext.Result.Failed)
{
CascadeEnum propValue = instanceOfManyToOneRelation.SourceCascade;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<CascadeEnum>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "None") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("sourceCascade", serializedPropValue);
}
}
}
// SourceColumn
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfManyToOneRelation.SourceColumn;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("sourceColumn", propValue);
}
}
// SourceCustomAccess
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfManyToOneRelation.SourceCustomAccess;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("sourceCustomAccess", propValue);
}
}
// SourceInsert
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfManyToOneRelation.SourceInsert;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "true") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("sourceInsert", serializedPropValue);
}
}
}
// SourceNotNull
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfManyToOneRelation.SourceNotNull;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("sourceNotNull", serializedPropValue);
}
}
}
// SourceOuterJoin
if (!serializationContext.Result.Failed)
{
OuterJoinEnum propValue = instanceOfManyToOneRelation.SourceOuterJoin;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<OuterJoinEnum>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Auto") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("sourceOuterJoin", serializedPropValue);
}
}
}
// SourceType
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfManyToOneRelation.SourceType;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("sourceType", propValue);
}
}
// SourceUnique
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfManyToOneRelation.SourceUnique;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("sourceUnique", serializedPropValue);
}
}
}
// SourceUpdate
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfManyToOneRelation.SourceUpdate;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "true") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("sourceUpdate", serializedPropValue);
}
}
}
// SourceDescription
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfManyToOneRelation.SourceDescription;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("sourceDescription", propValue);
}
}
// TargetAccess
if (!serializationContext.Result.Failed)
{
PropertyAccess propValue = instanceOfManyToOneRelation.TargetAccess;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<PropertyAccess>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Property") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("targetAccess", serializedPropValue);
}
}
}
// SourcePropertyName
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfManyToOneRelation.SourcePropertyName;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("sourcePropertyName", propValue);
}
}
// SourceNotFoundBehaviour
if (!serializationContext.Result.Failed)
{
NotFoundBehaviour propValue = instanceOfManyToOneRelation.SourceNotFoundBehaviour;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<NotFoundBehaviour>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Default") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("sourceNotFoundBehaviour", serializedPropValue);
}
}
}
// TargetNotFoundBehaviour
if (!serializationContext.Result.Failed)
{
NotFoundBehaviour propValue = instanceOfManyToOneRelation.TargetNotFoundBehaviour;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<NotFoundBehaviour>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Default") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("targetNotFoundBehaviour", serializedPropValue);
}
}
}
// TargetElement
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfManyToOneRelation.TargetElement;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("targetElement", propValue);
}
}
// TargetIndexType
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfManyToOneRelation.TargetIndexType;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("targetIndexType", propValue);
}
}
// TargetIndex
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfManyToOneRelation.TargetIndex;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("targetIndex", propValue);
}
}
// TargetFetch
if (!serializationContext.Result.Failed)
{
FetchEnum propValue = instanceOfManyToOneRelation.TargetFetch;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<FetchEnum>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Unspecified") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("targetFetch", serializedPropValue);
}
}
}
}
protected virtual void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
Process instanceOfProcess = element as Process;
global::System.Diagnostics.Debug.Assert(instanceOfProcess != null, "Expecting an instance of Process");
// Name
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfProcess.Name;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("name", propValue);
}
}
}
protected override void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
base.WritePropertiesAsAttributes(serializationContext, element, writer);
ModelElementWithAccess instanceOfModelElementWithAccess = element as ModelElementWithAccess;
global::System.Diagnostics.Debug.Assert(instanceOfModelElementWithAccess != null, "Expecting an instance of ModelElementWithAccess");
// CustomAccess
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelElementWithAccess.CustomAccess;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("customAccess", propValue);
}
}
// Access
if (!serializationContext.Result.Failed)
{
PropertyAccess propValue = instanceOfModelElementWithAccess.Access;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<PropertyAccess>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Property") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("access", serializedPropValue);
}
}
}
}
protected override void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
base.WritePropertiesAsAttributes(serializationContext, element, writer);
NestedClass instanceOfNestedClass = element as NestedClass;
global::System.Diagnostics.Debug.Assert(instanceOfNestedClass != null, "Expecting an instance of NestedClass");
// ImplementINotifyPropertyChanged
if (!serializationContext.Result.Failed)
{
InheritableBoolean propValue = instanceOfNestedClass.ImplementINotifyPropertyChanged;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<InheritableBoolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Inherit") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("implementINotifyPropertyChanged", serializedPropValue);
}
}
}
}
protected override void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
base.WritePropertiesAsAttributes(serializationContext, element, writer);
ModelProperty instanceOfModelProperty = element as ModelProperty;
global::System.Diagnostics.Debug.Assert(instanceOfModelProperty != null, "Expecting an instance of ModelProperty");
// Column
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelProperty.Column;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("column", propValue);
}
}
// ColumnType
if (!serializationContext.Result.Failed)
{
NHibernateType propValue = instanceOfModelProperty.ColumnType;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<NHibernateType>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "String") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("columnType", serializedPropValue);
}
}
}
// CustomColumnType
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelProperty.CustomColumnType;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, string.Empty) != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("customColumnType", propValue);
}
}
}
// CustomMemberType
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelProperty.CustomMemberType;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, string.Empty) != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("customMemberType", propValue);
}
}
}
// Formula
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelProperty.Formula;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("formula", propValue);
}
}
// Insert
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModelProperty.Insert;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "true") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("insert", serializedPropValue);
}
}
}
// Length
if (!serializationContext.Result.Failed)
{
global::System.Int32 propValue = instanceOfModelProperty.Length;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Int32>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
writer.WriteAttributeString("length", serializedPropValue);
}
}
// NotNull
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModelProperty.NotNull;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("notNull", serializedPropValue);
}
}
}
// Unique
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModelProperty.Unique;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("unique", serializedPropValue);
}
}
}
// UnsavedValue
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelProperty.UnsavedValue;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("unsavedValue", propValue);
}
}
// Update
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModelProperty.Update;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "true") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("update", serializedPropValue);
}
}
}
// Generator
if (!serializationContext.Result.Failed)
{
PrimaryKeyType propValue = instanceOfModelProperty.Generator;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<PrimaryKeyType>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Native") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("generator", serializedPropValue);
}
}
}
// KeyType
if (!serializationContext.Result.Failed)
{
KeyType propValue = instanceOfModelProperty.KeyType;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<KeyType>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "None") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("keyType", serializedPropValue);
}
}
}
// Params
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelProperty.Params;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("params", propValue);
}
}
// SequenceName
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelProperty.SequenceName;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("sequenceName", propValue);
}
}
// Accessor
if (!serializationContext.Result.Failed)
{
Accessor propValue = instanceOfModelProperty.Accessor;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<Accessor>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Public") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("accessor", serializedPropValue);
}
}
}
// CompositeKeyName
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelProperty.CompositeKeyName;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("compositeKeyName", propValue);
}
}
// PropertyType
if (!serializationContext.Result.Failed)
{
PropertyType propValue = instanceOfModelProperty.PropertyType;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<PropertyType>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Property") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("propertyType", serializedPropValue);
}
}
}
// DebuggerDisplay
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModelProperty.DebuggerDisplay;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("debuggerDisplay", serializedPropValue);
}
}
}
// Validator
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelProperty.Validator;
if (!serializationContext.Result.Failed)
{
if (propValue != null)
writer.WriteAttributeString("validator", propValue);
}
}
// UniqueKey
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelProperty.UniqueKey;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("uniqueKey", propValue);
}
}
// Index
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelProperty.Index;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("index", propValue);
}
}
// SqlType
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelProperty.SqlType;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("sqlType", propValue);
}
}
// Check
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelProperty.Check;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("check", propValue);
}
}
// DefaultMember
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModelProperty.DefaultMember;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("defaultMember", serializedPropValue);
}
}
}
}
protected override void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
base.WritePropertiesAsAttributes(serializationContext, element, writer);
ModelClass instanceOfModelClass = element as ModelClass;
global::System.Diagnostics.Debug.Assert(instanceOfModelClass != null, "Expecting an instance of ModelClass");
// Cache
if (!serializationContext.Result.Failed)
{
CacheEnum propValue = instanceOfModelClass.Cache;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<CacheEnum>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Undefined") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("cache", serializedPropValue);
}
}
}
// DiscriminatorColumn
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelClass.DiscriminatorColumn;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("discriminatorColumn", propValue);
}
}
// DiscriminatorType
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelClass.DiscriminatorType;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("discriminatorType", propValue);
}
}
// DiscriminatorValue
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelClass.DiscriminatorValue;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("discriminatorValue", propValue);
}
}
// Lazy
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModelClass.Lazy;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("lazy", serializedPropValue);
}
}
}
// Proxy
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelClass.Proxy;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("proxy", propValue);
}
}
// Schema
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelClass.Schema;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("schema", propValue);
}
}
// Table
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelClass.Table;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("table", propValue);
}
}
// Where
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelClass.Where;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("where", propValue);
}
}
// DynamicInsert
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModelClass.DynamicInsert;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("dynamicInsert", serializedPropValue);
}
}
}
// DynamicUpdate
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModelClass.DynamicUpdate;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("dynamicUpdate", serializedPropValue);
}
}
}
// Persister
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelClass.Persister;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("persister", propValue);
}
}
// SelectBeforeUpdate
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModelClass.SelectBeforeUpdate;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("selectBeforeUpdate", serializedPropValue);
}
}
}
// Polymorphism
if (!serializationContext.Result.Failed)
{
Polymorphism propValue = instanceOfModelClass.Polymorphism;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<Polymorphism>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Implicit") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("polymorphism", serializedPropValue);
}
}
}
// Mutable
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModelClass.Mutable;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "true") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("mutable", serializedPropValue);
}
}
}
// BatchSize
if (!serializationContext.Result.Failed)
{
global::System.Int32 propValue = instanceOfModelClass.BatchSize;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Int32>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "1") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("batchSize", serializedPropValue);
}
}
}
// Locking
if (!serializationContext.Result.Failed)
{
OptimisticLocking propValue = instanceOfModelClass.Locking;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<OptimisticLocking>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Version") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("locking", serializedPropValue);
}
}
}
// UseAutoImport
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfModelClass.UseAutoImport;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "true") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("useAutoImport", serializedPropValue);
}
}
}
// BaseClassName
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelClass.BaseClassName;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("baseClassName", propValue);
}
}
// UseGenerics
if (!serializationContext.Result.Failed)
{
InheritableBoolean propValue = instanceOfModelClass.UseGenerics;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<InheritableBoolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Inherit") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("useGenerics", serializedPropValue);
}
}
}
// ImplementINotifyPropertyChanged
if (!serializationContext.Result.Failed)
{
InheritableBoolean propValue = instanceOfModelClass.ImplementINotifyPropertyChanged;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<InheritableBoolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Inherit") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("implementINotifyPropertyChanged", serializedPropValue);
}
}
}
// UseGenericRelations
if (!serializationContext.Result.Failed)
{
InheritableBoolean propValue = instanceOfModelClass.UseGenericRelations;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<InheritableBoolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Inherit") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("useGenericRelations", serializedPropValue);
}
}
}
}
protected virtual void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
NestedClassReferencesModelClasses instanceOfNestedClassReferencesModelClasses = element as NestedClassReferencesModelClasses;
global::System.Diagnostics.Debug.Assert(instanceOfNestedClassReferencesModelClasses != null, "Expecting an instance of NestedClassReferencesModelClasses");
// MapType
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfNestedClassReferencesModelClasses.MapType;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("mapType", propValue);
}
}
// Insert
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfNestedClassReferencesModelClasses.Insert;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "true") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("insert", serializedPropValue);
}
}
}
// Update
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfNestedClassReferencesModelClasses.Update;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "true") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("update", serializedPropValue);
}
}
}
// ColumnPrefix
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfNestedClassReferencesModelClasses.ColumnPrefix;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("columnPrefix", propValue);
}
}
// Description
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfNestedClassReferencesModelClasses.Description;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("description", propValue);
}
}
// PropertyName
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfNestedClassReferencesModelClasses.PropertyName;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("propertyName", propValue);
}
}
}
/// <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();
}
protected virtual void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
Comment instanceOfComment = element as Comment;
global::System.Diagnostics.Debug.Assert(instanceOfComment != null, "Expecting an instance of Comment");
// Text
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfComment.Text;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("text", propValue);
}
}
}
protected virtual void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
NamedElement instanceOfNamedElement = element as NamedElement;
global::System.Diagnostics.Debug.Assert(instanceOfNamedElement != null, "Expecting an instance of NamedElement");
// Name
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfNamedElement.Name;
if (!serializationContext.Result.Failed)
{
writer.WriteAttributeString("name", propValue);
}
}
}
protected override void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
base.WritePropertiesAsAttributes(serializationContext, element, writer);
Operation instanceOfOperation = element as Operation;
global::System.Diagnostics.Debug.Assert(instanceOfOperation != null, "Expecting an instance of Operation");
// Name
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfOperation.Name;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("name", propValue);
}
}
// Description
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfOperation.Description;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("description", propValue);
}
}
}
protected override void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
base.WritePropertiesAsAttributes(serializationContext, element, writer);
ClassOperation instanceOfClassOperation = element as ClassOperation;
global::System.Diagnostics.Debug.Assert(instanceOfClassOperation != null, "Expecting an instance of ClassOperation");
// IsAbstract
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfClassOperation.IsAbstract;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "False") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("isAbstract", serializedPropValue);
}
}
}
}
protected override void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
base.WritePropertiesAsAttributes(serializationContext, element, writer);
ModelRoot instanceOfModelRoot = element as ModelRoot;
global::System.Diagnostics.Debug.Assert(instanceOfModelRoot != null, "Expecting an instance of ModelRoot");
// OntologyUri
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelRoot.OntologyUri;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, "http://tempuri.com/ontology/") != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("ontologyUri", propValue);
}
}
}
}
protected virtual void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
Association instanceOfAssociation = element as Association;
global::System.Diagnostics.Debug.Assert(instanceOfAssociation != null, "Expecting an instance of Association");
// SourceMultiplicity
if (!serializationContext.Result.Failed)
{
Multiplicity propValue = instanceOfAssociation.SourceMultiplicity;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<Multiplicity>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "ZeroMany") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("sourceMultiplicity", serializedPropValue);
}
}
}
// SourceRoleName
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfAssociation.SourceRoleName;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, string.Empty) != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("sourceRoleName", propValue);
}
}
}
// TargetMultiplicity
if (!serializationContext.Result.Failed)
{
Multiplicity propValue = instanceOfAssociation.TargetMultiplicity;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<Multiplicity>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "ZeroMany") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("targetMultiplicity", serializedPropValue);
}
}
}
// TargetRoleName
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfAssociation.TargetRoleName;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, string.Empty) != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("targetRoleName", propValue);
}
}
}
// ResourceUri
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfAssociation.ResourceUri;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("resourceUri", propValue);
}
}
}
protected virtual void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
Generalization instanceOfGeneralization = element as Generalization;
global::System.Diagnostics.Debug.Assert(instanceOfGeneralization != null, "Expecting an instance of Generalization");
// Discriminator
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfGeneralization.Discriminator;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, string.Empty) != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("discriminator", propValue);
}
}
}
}
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
}
/// <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();
}
protected override void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer, DslEditorModeling::SerializationOptions options)
{
global::Tum.TestLanguage.Test instance = element as global::Tum.TestLanguage.Test;
global::System.Diagnostics.Debug.Assert(instance != null, "Expecting an instance of Test");
// Domain Element Id
string valueId = TestLanguageSerializationHelper.Instance.ConvertIdTo(serializationContext, element.Id);
writer.WriteAttributeString(TestLanguageSerializationBehavior.Instance.IdSerializationNameDefaultContext, valueId);
if (!serializationContext.Result.Failed)
{
WritePropertyAsAttributeName(serializationContext, instance, writer, options);
}
if (!serializationContext.Result.Failed)
{
WritePropertyAsAttributeNumber(serializationContext, instance, writer, options);
}
}
protected override void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
base.WritePropertiesAsAttributes(serializationContext, element, writer);
ModelClass instanceOfModelClass = element as ModelClass;
global::System.Diagnostics.Debug.Assert(instanceOfModelClass != null, "Expecting an instance of ModelClass");
// Kind
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelClass.Kind;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, string.Empty) != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("kind", propValue);
}
}
}
// IsAbstract
if (!serializationContext.Result.Failed)
{
InheritanceModifier propValue = instanceOfModelClass.IsAbstract;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<InheritanceModifier>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "None") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("isAbstract", serializedPropValue);
}
}
}
// ResourceUri
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelClass.ResourceUri;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("resourceUri", propValue);
}
}
}
/// <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();
}
protected override void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
base.WritePropertiesAsAttributes(serializationContext, element, writer);
ModelAttribute instanceOfModelAttribute = element as ModelAttribute;
global::System.Diagnostics.Debug.Assert(instanceOfModelAttribute != null, "Expecting an instance of ModelAttribute");
// Type
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelAttribute.Type;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, string.Empty) != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("type", propValue);
}
}
}
// InitialValue
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelAttribute.InitialValue;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, string.Empty) != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("initialValue", propValue);
}
}
}
// Multiplicity
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelAttribute.Multiplicity;
if (!serializationContext.Result.Failed)
{
if (propValue != null && (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(propValue, "1") != 0))
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("multiplicity", propValue);
}
}
}
// ResourceUri
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfModelAttribute.ResourceUri;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("resourceUri", propValue);
}
}
}
/// <summary>
/// Write schema definitions.
/// </summary>
/// <param name="writer">XmlWriter to write serialized data to.</param>
/// <param name="modelContextName">Name of the model context.</param>
/// <param name="domainModelName">Name of the domain model.</param>
public virtual void WriteSchemaDefinitions(global::System.Xml.XmlWriter writer, string modelContextName, string domainModelName)
{
writer.WriteAttributeString("xmlns", "xi", null, "http://www.w3.org/2001/XInclude");
writer.WriteAttributeString("xmlns", "xsi", null, "http://www.w3.org/2001/XMLSchema-instance");
}
protected virtual void WritePropertiesAsAttributes(DslModeling::SerializationContext serializationContext, DslModeling::ModelElement element, global::System.Xml.XmlWriter writer)
{
OneToOneRelation instanceOfOneToOneRelation = element as OneToOneRelation;
global::System.Diagnostics.Debug.Assert(instanceOfOneToOneRelation != null, "Expecting an instance of OneToOneRelation");
// SourceAccess
if (!serializationContext.Result.Failed)
{
PropertyAccess propValue = instanceOfOneToOneRelation.SourceAccess;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<PropertyAccess>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Property") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("sourceAccess", serializedPropValue);
}
}
}
// SourceCascade
if (!serializationContext.Result.Failed)
{
CascadeEnum propValue = instanceOfOneToOneRelation.SourceCascade;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<CascadeEnum>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "None") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("sourceCascade", serializedPropValue);
}
}
}
// SourceConstrained
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfOneToOneRelation.SourceConstrained;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("sourceConstrained", serializedPropValue);
}
}
}
// SourceCustomAccess
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfOneToOneRelation.SourceCustomAccess;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("sourceCustomAccess", propValue);
}
}
// SourceOuterJoin
if (!serializationContext.Result.Failed)
{
OuterJoinEnum propValue = instanceOfOneToOneRelation.SourceOuterJoin;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<OuterJoinEnum>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Auto") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("sourceOuterJoin", serializedPropValue);
}
}
}
// TargetAccess
if (!serializationContext.Result.Failed)
{
PropertyAccess propValue = instanceOfOneToOneRelation.TargetAccess;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<PropertyAccess>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Property") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("targetAccess", serializedPropValue);
}
}
}
// TargetCascade
if (!serializationContext.Result.Failed)
{
CascadeEnum propValue = instanceOfOneToOneRelation.TargetCascade;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<CascadeEnum>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "None") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("targetCascade", serializedPropValue);
}
}
}
// TargetConstrained
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfOneToOneRelation.TargetConstrained;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("targetConstrained", serializedPropValue);
}
}
}
// TargetCustomAccess
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfOneToOneRelation.TargetCustomAccess;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("targetCustomAccess", propValue);
}
}
// TargetOuterJoin
if (!serializationContext.Result.Failed)
{
OuterJoinEnum propValue = instanceOfOneToOneRelation.TargetOuterJoin;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<OuterJoinEnum>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "Auto") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("targetOuterJoin", serializedPropValue);
}
}
}
// SourceDescription
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfOneToOneRelation.SourceDescription;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("sourceDescription", propValue);
}
}
// TargetDescription
if (!serializationContext.Result.Failed)
{
global::System.String propValue = instanceOfOneToOneRelation.TargetDescription;
if (!serializationContext.Result.Failed)
{
if (!string.IsNullOrEmpty(propValue))
writer.WriteAttributeString("targetDescription", propValue);
}
}
// Lazy
if (!serializationContext.Result.Failed)
{
global::System.Boolean propValue = instanceOfOneToOneRelation.Lazy;
string serializedPropValue = DslModeling::SerializationUtilities.GetString<global::System.Boolean>(serializationContext, propValue);
if (!serializationContext.Result.Failed)
{
if (serializationContext.WriteOptionalPropertiesWithDefaultValue || string.CompareOrdinal(serializedPropValue, "false") != 0)
{ // No need to write the value out if it's the same as default value.
writer.WriteAttributeString("lazy", serializedPropValue);
}
}
}
}
