public void ShouldReturnAsmxDataContractEnumLink()
{
DataContractEnum enumElement = new DataContractEnum(Store);
enumElement.DataContractModel = new DataContractModel(Store);
AsmxDataContractEnum asmxDCEnum = new AsmxDataContractEnum();
asmxDCEnum.ModelElement = enumElement;
Assert.IsInstanceOfType(asmxDCEnum.ArtifactLink, typeof(AsmxDataContractEnumLink));
}
public override void ElementAdded(ElementAddedEventArgs e)
{
DataContractEnum dataContractEnum = e.ModelElement as DataContractEnum;
DataContractModel root = dataContractEnum.DataContractModel;
if (root != null &&
root.ImplementationTechnology != null)
{
ExtensionProviderHelper.AttachObjectExtender(dataContractEnum, root.ImplementationTechnology);
}
}
private DataContractEnum CreateDefaultDataContractEnum()
{
DataContractEnum rootElement = new DataContractEnum(Store);
rootElement.DataContractModel = new DataContractModel(Store);
rootElement.DataContractModel.ProjectMappingTable = "ASMX";
rootElement.Name = ElementName;
rootElement.Namespace = ElementNamespace;
return rootElement;
}
/// <summary>
/// Constructor
/// Creates a DataContractEnumHasEnumNamedValues link in the same Partition as the given DataContractEnum
/// </summary>
/// <param name="source">DataContractEnum to use as the source of the relationship.</param>
/// <param name="target">EnumNamedValue to use as the target of the relationship.</param>
public DataContractEnumHasEnumNamedValues(DataContractEnum source, EnumNamedValue target)
: base((source != null ? source.Partition : null), new DslModeling::RoleAssignment[]{new DslModeling::RoleAssignment(DataContractEnumHasEnumNamedValues.DataContractEnumDomainRoleId, source), new DslModeling::RoleAssignment(DataContractEnumHasEnumNamedValues.EnumNamedValueDomainRoleId, target)}, null)
{
}
public void TestMembersWithPrimitiveEnumTypeGeneration()
{
ProjectMappingManagerSetup.InitializeManager(ServiceProvider, "ProjectMapping.DataContractDsl.Tests.xml");
DataContract rootElement = CreateDefaultDataContract();
DataContractEnum enumElement = new DataContractEnum(Store);
enumElement.Name = PrimitiveDataElementName1;
rootElement.DataContractModel.Contracts.Add(enumElement);
rootElement.DataMembers.AddRange(LoadLinkedElements(enumElement));
string content = RunTemplate(rootElement);
this.EnsureType(ref content, PrimitiveDataElementName1);
Type generatedType = CompileAndGetType(content);
KnownTypeAttribute knownTypeAttr = TypeAsserter.AssertAttribute<KnownTypeAttribute>(generatedType);
Assert.AreEqual<string>(PrimitiveDataElementName1, knownTypeAttr.Type.Name);
}
public static DslModeling::LinkedElementCollection<EnumNamedValue> GetEnumNamedValues(DataContractEnum element)
{
return GetRoleCollection<DslModeling::LinkedElementCollection<EnumNamedValue>, EnumNamedValue>(element, DataContractEnumDomainRoleId);
}
public static void SetDataContractEnum(EnumNamedValue element, DataContractEnum newDataContractEnum)
{
DslModeling::DomainRoleInfo.SetLinkedElement(element, EnumNamedValueDomainRoleId, newDataContractEnum);
}
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, DataContractEnum element, global::System.Xml.XmlWriter writer)
{
// DataContractEnumHasEnumNamedValues
global::System.Collections.ObjectModel.ReadOnlyCollection<DataContractEnumHasEnumNamedValues> allDataContractEnumHasEnumNamedValuesInstances = DataContractEnumHasEnumNamedValues.GetLinksToEnumNamedValues(element);
if (!serializationContext.Result.Failed && allDataContractEnumHasEnumNamedValuesInstances.Count > 0)
{
writer.WriteStartElement("enumNamedValues");
global::System.Type typeofDataContractEnumHasEnumNamedValues = typeof(DataContractEnumHasEnumNamedValues);
foreach (DataContractEnumHasEnumNamedValues eachDataContractEnumHasEnumNamedValuesInstance in allDataContractEnumHasEnumNamedValuesInstances)
{
if (serializationContext.Result.Failed)
break;
if (eachDataContractEnumHasEnumNamedValuesInstance.GetType() != typeofDataContractEnumHasEnumNamedValues)
{ // Derived relationships will be serialized in full-form.
DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachDataContractEnumHasEnumNamedValuesInstance.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachDataContractEnumHasEnumNamedValuesInstance.GetDomainClass().Name + "!");
derivedRelSerializer.Write(serializationContext, eachDataContractEnumHasEnumNamedValuesInstance, writer);
}
else
{ // No need to serialize the relationship itself, just serialize the role-player directly.
DslModeling::ModelElement targetElement = eachDataContractEnumHasEnumNamedValuesInstance.EnumNamedValue;
DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer(targetElement.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert(targetSerializer != null, "Cannot find serializer for " + targetElement.GetDomainClass().Name + "!");
targetSerializer.Write(serializationContext, targetElement, writer);
}
}
writer.WriteEndElement();
}
}
/// <summary>
/// Reads all instances of relationship DataContractEnumHasEnumNamedValues.
/// </summary>
/// <remarks>
/// The caller will position the reader at the open tag of the first XML element inside the relationship tag, so it can be
/// either the first instance, or a bogus tag. This method will deserialize all instances and ignore all bogus tags. When the
/// method returns, the reader will be positioned at the end tag of the relationship (or EOF if somehow that happens).
/// </remarks>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="element">In-memory DataContractEnum instance that will get the deserialized data.</param>
/// <param name="reader">XmlReader to read serialized data from.</param>
private static void ReadDataContractEnumHasEnumNamedValuesInstances(DslModeling::SerializationContext serializationContext, DataContractEnum element, global::System.Xml.XmlReader reader)
{
while (!serializationContext.Result.Failed && !reader.EOF && reader.NodeType == global::System.Xml.XmlNodeType.Element)
{
DslModeling::DomainClassXmlSerializer newEnumNamedValueOfDataContractEnumHasEnumNamedValuesSerializer = serializationContext.Directory.GetSerializer(EnumNamedValue.DomainClassId);
global::System.Diagnostics.Debug.Assert(newEnumNamedValueOfDataContractEnumHasEnumNamedValuesSerializer != null, "Cannot find serializer for EnumNamedValue!");
EnumNamedValue newEnumNamedValueOfDataContractEnumHasEnumNamedValues = newEnumNamedValueOfDataContractEnumHasEnumNamedValuesSerializer.TryCreateInstance(serializationContext, reader, element.Partition) as EnumNamedValue;
if (newEnumNamedValueOfDataContractEnumHasEnumNamedValues != null)
{
element.EnumNamedValues.Add(newEnumNamedValueOfDataContractEnumHasEnumNamedValues);
DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer (newEnumNamedValueOfDataContractEnumHasEnumNamedValues.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert (targetSerializer != null, "Cannot find serializer for " + newEnumNamedValueOfDataContractEnumHasEnumNamedValues.GetDomainClass().Name + "!");
targetSerializer.Read(serializationContext, newEnumNamedValueOfDataContractEnumHasEnumNamedValues, reader);
}
else
{
global::System.Type typeofDataContractEnumHasEnumNamedValues = typeof(DataContractEnumHasEnumNamedValues);
DslModeling::DomainRelationshipXmlSerializer newDataContractEnumHasEnumNamedValuesSerializer = serializationContext.Directory.GetSerializer(DataContractEnumHasEnumNamedValues.DomainClassId) as DslModeling::DomainRelationshipXmlSerializer;
global::System.Diagnostics.Debug.Assert(newDataContractEnumHasEnumNamedValuesSerializer != null, "Cannot find serializer for DataContractEnumHasEnumNamedValues!");
DataContractEnumHasEnumNamedValues newDataContractEnumHasEnumNamedValues = newDataContractEnumHasEnumNamedValuesSerializer.TryCreateInstance (serializationContext, reader, element.Partition) as DataContractEnumHasEnumNamedValues;
if (newDataContractEnumHasEnumNamedValues != null)
{
if (newDataContractEnumHasEnumNamedValues.GetType() == typeofDataContractEnumHasEnumNamedValues)
{ // The relationship should be serialized in short-form.
DataContractDslSerializationBehaviorSerializationMessages.ExpectingShortFormRelationship(serializationContext, reader, typeof(DataContractEnumHasEnumNamedValues));
}
DslModeling::DomainRoleInfo.SetRolePlayer (newDataContractEnumHasEnumNamedValues, DataContractEnumHasEnumNamedValues.DataContractEnumDomainRoleId, element);
DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer (newDataContractEnumHasEnumNamedValues.GetDomainClass().Id);
global::System.Diagnostics.Debug.Assert (targetSerializer != null, "Cannot find serializer for " + newDataContractEnumHasEnumNamedValues.GetDomainClass().Name + "!");
targetSerializer.Read(serializationContext, newDataContractEnumHasEnumNamedValues, reader);
}
else
{ // Unknown element, skip
DslModeling::SerializationUtilities.Skip(reader);
}
}
}
}
/// <summary>
/// This method deserializes all child model elements.
/// </summary>
/// <remarks>
/// The caller will position the reader at the open tag of the first child XML element to deserialized.
/// This method will read as many child elements as it can. It returns under three circumstances:
/// 1) When an unknown child XML element is encountered. In this case, this method will position the reader at the
/// open tag of the unknown element. This implies that if the first child XML element is unknown, this method
/// should return immediately and do nothing.
/// 2) When all child XML elemnets are read. In this case, the reader will be positioned at the end tag of the parent element.
/// 3) EOF.
/// </remarks>
/// <param name="serializationContext">Serialization context.</param>
/// <param name="reader">XmlReader to read serialized data from.</param>
/// <param name="element">In-memory DataContractEnum instance that will get the deserialized data.</param>
private static void ReadChildElements(DslModeling::SerializationContext serializationContext, DataContractEnum element, global::System.Xml.XmlReader reader)
{
if (!serializationContext.Result.Failed && !reader.EOF && reader.NodeType == global::System.Xml.XmlNodeType.Element)
{
if (string.Compare(reader.LocalName, "enumNamedValues", global::System.StringComparison.CurrentCulture) == 0)
{
if (reader.IsEmptyElement)
{ // No instance of this relationship, just skip
DslModeling::SerializationUtilities.Skip(reader);
}
else
{
DslModeling::SerializationUtilities.SkipToFirstChild(reader); // Skip the open tag of <enumNamedValues>
ReadDataContractEnumHasEnumNamedValuesInstances(serializationContext, element, reader);
DslModeling::SerializationUtilities.Skip(reader); // Skip the close tag of </enumNamedValues>
}
}
}
}