public override INodePointer CreateChild(SifXPathContext context, string name, int i)
{
SifVersion version = Version;
IElementDef subEleDef = GetChildDef(name);
SifFormatter formatter = Adk.Dtd.GetFormatter(version);
SifElement sifElement = (SifElement)fElement;
// Check to see if this child has a render surrogate defined
IRenderSurrogate rs = subEleDef.GetVersionInfo(version).GetSurrogate();
if (rs != null)
{
return(rs.CreateChild(this, formatter, version, context));
}
if (subEleDef.Field)
{
SifSimpleType ssf = subEleDef.TypeConverter.GetSifSimpleType(null);
SimpleField sf = formatter.SetField(sifElement, subEleDef, ssf, version);
return(SimpleFieldPointer.Create(this, sf));
}
else
{
SifElement newEle = SifElement.Create(sifElement, subEleDef);
formatter.AddChild(sifElement, newEle, version);
return(new SifElementPointer(this, newEle, version));
}
}
/// <summary>
/// Throws an exception if a developer attempts to add the wrong type
/// of child to this list, which is typed to contain only a single type of element
/// </summary>
/// <param name="child"></param>
private void _throwInvalidChild(SifElement child)
{
throw new InvalidCastException
(string.Format
("This <{0}> instance is in an invalid state. Cannot contain a child of type <{1}>.",
ElementDef.Name, child.ElementDef.Name));
}
/// <summary>
/// Use by SIFXPathContext when determining if it can add a child
/// or not
/// </summary>
/// <param name="childName"></param>
/// <returns></returns>
public AddChildDirective GetAddChildDirective(string childName)
{
SifElement sifElement = (SifElement)fElement;
if (sifElement.ChildCount == 0)
{
// There are no children. Don't even check for repeatability.
// This child can be added.
return(AddChildDirective.ADD);
}
IElementDef candidate = GetChildDef(childName);
if (candidate.Field)
{
// Don't evaluate repeatability
return(AddChildDirective.ADD);
}
SifElement instance = sifElement.GetChild(candidate);
if (instance == null)
{
// There are no siblings of this type. This child can be
// added
return(AddChildDirective.ADD);
}
if (candidate.IsRepeatable(Version))
{
// This element is repeatable. This child can be added
return(AddChildDirective.ADD);
}
// A sibling exists, and the element is not repeatable
return(AddChildDirective.DONT_ADD_NOT_REPEATABLE);
}
/// <summary>
/// Adds a SimpleField parsed from a specific version of SIF to the parent.
/// </summary>
/// <param name="contentParent">The element to add content to</param>
/// <param name="fieldDef">The metadata definition of the field to set</param>
/// <param name="data">The value to set to the field</param>
/// <param name="version">The version of SIF that the SIFElement is being constructed
/// from</param>
/// <returns></returns>
public virtual SimpleField SetField(SifElement contentParent,
IElementDef fieldDef,
SifSimpleType data,
SifVersion version)
{
return(contentParent.SetField(fieldDef, data));
}
private void AssertMessageStreamer(MessageStreamer streamer, SifVersion version)
{
long length = streamer.Length;
MemoryStream ms = new MemoryStream();
streamer.CopyTo(ms);
// Copy to a string for debugging purposes
Console.WriteLine("********************************************************************");
string data = Encoding.UTF8.GetString(ms.ToArray());
Console.WriteLine("RawLength:{0}, Text Length:{1}", ms.Length, data.Length);
Console.WriteLine(data);
Assert.AreEqual(length, ms.Length, "Length property and final length are not the same.");
// Try parsing the final stream to see if it is a valid message
SifParser parser = SifParser.NewInstance();
ms.Seek(0, SeekOrigin.Begin);
StreamReader reader = new StreamReader(ms);
SifElement o = parser.Parse(reader, null, SifParserFlags.None, version);
Assert.IsNotNull(o);
}
/// <summary>
/// Creates a new SifXPathContext instance to use for traversing the
/// specified SIF Data Object
/// </summary>
/// <remarks>
/// Contexts that are created from other contexts automatically inherit all
/// custom variables and functions that are defined in the other context
/// </remarks>
/// <param name="parent">The SifXPathContext to share custom functions and
/// variables with</param>
/// <param name="sdo">The SIF Data Object or SIFElement to traverse</param>
/// <returns>an instance of SifXPathContext</returns>
public static SifXPathContext NewSIFContext(SifXPathContext parent,
SifElement sdo)
{
SifXPathContext context = new SifXPathContext(parent, sdo);
return(context);
}
/// <summary>
/// Creates a new SifXPathContext instance to use for traversing the
/// specified SIF Data Object
/// </summary>
/// <remarks>
/// NOTE: The SIFDataObject.setSIFVersion(version) is automatically
/// called and set to the target version.
/// </remarks>
/// <param name="sdo">The SIF Data Object or SIFElement to traverse</param>
/// <returns>an instance of SifXPathContext</returns>
/// <param name="version">The SIFVersion to use when traversing this object using XPath.</param>
public static SifXPathContext NewSIFContext(SifElement sdo, SifVersion version)
{
sdo.SifVersion = version;
SifXPathContext context = NewSIFContext(sdo);
return(context);
}
/// <summary>
/// Adds a SimpleField parsed from a specific version of SIF to the parent.
/// </summary>
/// <param name="contentParent">The element to add content to</param>
/// <param name="fieldDef">The metadata definition of the field to set</param>
/// <param name="data">The value to set to the field</param>
/// <param name="version">The version of SIF that the SIFElement is being constructed
/// from</param>
/// <returns></returns>
public override SimpleField SetField(SifElement contentParent,
IElementDef fieldDef,
SifSimpleType data,
SifVersion version)
{
return(GetContainer(contentParent, fieldDef, version).SetField(fieldDef, data));
}
private SifElement GetContainer(SifElement contentParent, IElementDef childDef, SifVersion version)
{
IElementDef elementParentDef = childDef.Parent;
if (elementParentDef != null && elementParentDef != contentParent.ElementDef)
{
// The element does not appear to belong to this parent. Attempt to look
// for a container element that might be missing in between the two
// If the parent of this element were collapsed in a previous version
// of SIF, check for or re-add the parent element and add this new
// child instead.
//
// For example, a child could be an Email element from the
// common package that's being added to StudentPersonal. In this
// case,
// we need to actually find or create an instance of the new
// EmailList
// container element and add the child to it, instead of to "this"
String tag = elementParentDef.Tag(Adk.SifVersion);
IElementDef missingLink = Adk.Dtd.LookupElementDef(contentParent.ElementDef, tag);
if (missingLink != null && missingLink.IsCollapsed(version))
{
SifElement container = contentParent.GetChild(missingLink);
if (container == null)
{
container = SifElement.Create(contentParent, missingLink);
}
AddChild(contentParent, container, version);
return(container);
}
}
return(contentParent);
}
/// <summary>
/// Gets the content from the SIFElement for the specified version of SIF. Only
/// elements that apply to the requested version of SIF will be returned.
/// </summary>
/// <param name="element">The element to retrieve content from</param>
/// <param name="version"></param>
/// <returns></returns>
public virtual IList <Element> GetContent(SifElement element, SifVersion version)
{
List <Element> returnValue = new List <Element>();
ICollection <SimpleField> fields = element.GetFields();
foreach (SimpleField val in fields)
{
IElementDef def = val.ElementDef;
if (def.IsSupported(version) &&
!def.IsAttribute(version) &&
def.Field)
{
returnValue.Add(val);
}
}
IList <SifElement> children = element.GetChildList();
foreach (SifElement val in children)
{
IElementDef def = val.ElementDef;
if (def.IsSupported(version))
{
returnValue.Add(val);
}
}
MergeSort.Sort <Element>(returnValue, ElementSorter <Element> .GetInstance(version));
//returnValue.Sort( ElementSorter<Element>.GetInstance( version ) );
return(returnValue);
}
/// <summary>
/// Adds a SIFElement parsed from a specific version of SIF to the parent.
/// The formatter instance may use version-specific rules to ensure that the
/// hierarchy is properly maintained when the source of the content is from
/// this version of SIF
/// </summary>
/// <param name="contentParent"> The element to add content to</param>
/// <param name="content">The element to add</param>
/// <param name="version"> The version of SIF that the SIFElement is being constructed
/// from</param>
public override SifElement AddChild(
SifElement contentParent,
SifElement content,
SifVersion version)
{
contentParent.RestoreImplementationDef(content);
return GetContainer(contentParent, content.ElementDef, version).AddChild(content);
}
/// <summary>
/// Creates a new SifElementPointer
/// </summary>
/// <param name="parentPointer">The parent of this pointer</param>
/// <param name="element">The element being wrapped</param>
/// <param name="version">The SifVersion in effect</param>
public SifElementPointer(
INodePointer parentPointer,
SifElement element,
SifVersion version )
: base(parentPointer, element, version)
{
fSifElement = element;
}
/// <summary>
/// Parses the XML string value and returns the proper SimpleField instance to hold
/// the element value
/// </summary>
/// <param name="parent">The parent SIFElement of this field</param>
/// <param name="id">The metadata definition of the field</param>
/// <param name="formatter">The formatter to use for the specific version of SIF being parsed</param>
/// <param name="xmlValue">A string representing the XML payload being used for this version of SIF</param>
/// <returns>A simple field initialized with the proper value</returns>
/// <exception cref="AdkTypeParseException">thrown if the value cannot be parsed according to the
/// formatting rules for this version of SIF</exception>
public SimpleField ParseField(
SifElement parent,
IElementDef id,
SifFormatter formatter,
string xmlValue)
{
return(Parse(formatter, xmlValue).CreateField(parent, id));
}
public override void SetValue(object rawValue)
{
SifElementPointer immediateParent = (SifElementPointer)Parent;
SifElement parentElement = immediateParent.Element as SifElement;
SifSimpleType sst = GetSIFSimpleTypeValue(fElementDef, rawValue);
parentElement.SetField(fElementDef, sst);
}
/// <summary>
/// Validates that the child being added is the same type as TValue
/// </summary>
/// <param name="element">The child that is about to be added</param>
protected override void EvaluateChild(SifElement element)
{
base.EvaluateChild(element);
if (!(element is TValue))
{
_throwInvalidChild(element);
}
}
/// <summary>
/// Creates a new SifElementPointer
/// </summary>
/// <param name="parentPointer">The parent of this pointer</param>
/// <param name="element">The element being wrapped</param>
/// <param name="version">The SifVersion in effect</param>
public SifElementPointer(
INodePointer parentPointer,
SifElement element,
SifVersion version)
: base(parentPointer, element, version)
{
fSifElement = element;
}
/// <summary>
/// Adds a SIFElement parsed from a specific version of SIF to the parent.
/// The formatter instance may use version-specific rules to ensure that the
/// hierarchy is properly maintained when the source of the content is from
/// this version of SIF
/// </summary>
/// <param name="contentParent"> The element to add content to</param>
/// <param name="content">The element to add</param>
/// <param name="version"> The version of SIF that the SIFElement is being constructed
/// from</param>
public override SifElement AddChild(
SifElement contentParent,
SifElement content,
SifVersion version)
{
contentParent.RestoreImplementationDef(content);
return(GetContainer(contentParent, content.ElementDef, version).AddChild(content));
}
private SIF_Ack SifSystemControl(SifElement command, ZoneImpl zone)
{
SIF_SystemControl msg = new SIF_SystemControl(zone.HighestEffectiveZISVersion);
SIF_SystemControlData cmd = new SIF_SystemControlData();
cmd.AddChild(command);
msg.SIF_SystemControlData = cmd;
return(zone.Dispatcher.send(msg));
}
public void testInheritRules()
{
String configFileText1_ = "<agent id=\"mcmTest.MappingsTest\" sifVersion=\"2.0\">\n"
+ " <mappings id=\"Default\">\n"
+ " <object object=\"StudentPersonal\">\n"
+ " <field name=\"StudentPers_guid\">@RefId</field>\n"
+ " <field name=\"LastName\">Name[@Type='01']/LastName</field>\n"
+ " <field name=\"FirstName\">Name[@Type='01']/FirstName</field>\n"
+ " <field name=\"MiddleName\">Name[@Type='01']/MiddleName</field>\n"
+
" <field name=\"Street\">StudentAddress[@PickupOrDropoff='NA',@DayOfWeek='NA']/Address[@Type='01']/Street/Line1</field>\n"
+
" <field name=\"City\">StudentAddress[@PickupOrDropoff='NA',@DayOfWeek='NA']/Address[@Type='01']/City</field>\n"
+
" <field name=\"State\">StudentAddress[@PickupOrDropoff='NA',@DayOfWeek='NA']/Address[@Type='01']/StateProvince</field>\n"
+
" <field name=\"Zip\">StudentAddress[@PickupOrDropoff='NA',@DayOfWeek='NA']/Address[@Type='01']/PostalCode</field>\n"
+ " </object>\n"
+ " <mappings id=\"Zone A\" zoneId=\"Zone A\">\n"
+ " <object object=\"StudentPersonal\">\n"
+ " <field name=\"LastName\">Name[@Type='06']/LastName</field>\n"
+ " <field name=\"FirstName\">Name[@Type='06']/FirstName</field>\n"
+ " <field name=\"MiddleName\">Name[@Type='06']/MiddleName</field>\n"
+ " </object>\n"
+ " </mappings>\n"
+ " </mappings>\n"
+ "</agent>";
IDictionary psValueMap = new Dictionary <String, String>();
psValueMap["StudentPers_guid"] = "14050614103526133C3FD2324C5BC8FF";
psValueMap["LastName"] = "Finale";
psValueMap["FirstName"] = "Prima";
psValueMap["MiddleName"] = "Mediccio";
psValueMap["Street"] = "667 Gate Way";
psValueMap["City"] = "Sacramento";
psValueMap["State"] = "CA";
psValueMap["Zip"] = "91020";
StringMapAdaptor sma = new StringMapAdaptor(psValueMap);
StudentPersonal sp = doOutboundMappingSelect(sma, configFileText1_,
"Zone A", null, null);
Assertion.AssertNotNull("Student should not be null", sp);
SifElement address = (SifElement)sp
.GetElementOrAttribute(
"StudentAddress[@PickupOrDropoff='NA',@DayOfWeek='NA']/Address[@Type='01']");
Assertion.AssertNotNull("Student Address should have mapped", address);
SifElement name = (SifElement)sp
.GetElementOrAttribute("Name[@Type='06']");
Assertion.AssertNotNull("Name should have mapped to '06'", name);
}
public bool ReadRaw(XmlReader reader,
SifVersion version,
SifElement parent,
SifFormatter formatter)
{
string name = reader.LocalName;
if (name.Equals(fDateElement))
{
String dateValue = ConsumeElementTextValue(reader, version);
DateTime?date = formatter.ToDate(dateValue);
if (date.HasValue)
{
DateTime tsValue = date.Value;
SifDateTime dateTime = new SifDateTime(tsValue);
parent.SetField(dateTime.CreateField(parent, fElementDef));
}
}
else if (name.Equals(fTimeElement))
{
String timeValue = ConsumeElementTextValue(reader, version);
DateTime?time = formatter.ToTime(timeValue);
if (time.HasValue)
{
DateTime val = time.Value;
// See if the Timestamp field already exists on the parent
SimpleField timeStampField = parent.GetField(fElementDef);
if (timeStampField == null)
{
// Doesn't exist, create it
SifDateTime dateTime = new SifDateTime(val);
parent.SetField(dateTime.CreateField(parent, fElementDef));
}
else
{
// Exists, update the time portion of the date
SifDateTime sdt = (SifDateTime)timeStampField.SifValue;
if (sdt != null && sdt.Value.HasValue)
{
DateTime tsValue = sdt.Value.Value;
tsValue = tsValue.Add(val.TimeOfDay);
sdt = new SifDateTime(tsValue);
// Overwrite the current value
parent.SetField(sdt.CreateField(parent, fElementDef));
}
}
}
}
else
{
return(false);
}
return(true);
}
public void testSetPacketNumberAndMorePackets()
{
MessageDispatcher testDispatcher = new MessageDispatcher(this.Zone);
this.Zone.SetDispatcher(testDispatcher);
this.Zone.Connect(ProvisioningFlags.None);
InMemoryProtocolHandler testProto = (InMemoryProtocolHandler)this.Zone.ProtocolHandler;
testProto.clear();
// Send a single SIF_Response with a small Authentication object
String SifRequestMsgId = Adk.MakeGuid();
String sourceId = "TEST_SOURCEID";
SifVersion testVersion = SifVersion.LATEST;
int maxBufferSize = int.MaxValue;
int packetNumber = 999;
YesNo morePacketsValue = YesNo.YES;
IElementDef[] testRestrictions = new IElementDef[] { InfrastructureDTD.AUTHENTICATION_REFID };
SifResponseSender srs = new SifResponseSender();
srs.Open(this.Zone, SifRequestMsgId, sourceId, testVersion, maxBufferSize, testRestrictions);
srs.SIF_PacketNumber = packetNumber;
srs.SIF_MorePackets = morePacketsValue;
// Assert the values of the properties set before writing
Assert.AreEqual(packetNumber, srs.SIF_PacketNumber);
Assert.AreEqual(morePacketsValue, srs.SIF_MorePackets);
srs.Write(new Authentication(Adk.MakeGuid(), Adk.MakeGuid(), AuthSifRefIdType.EMPLOYEEPERSONAL));
srs.Close();
// Assert the values of the properties set after writing
Assert.AreEqual(packetNumber, srs.SIF_PacketNumber);
Assert.AreEqual(morePacketsValue, srs.SIF_MorePackets);
// Retrieve the SIF_Response message off the protocol handler and asssert the results
SIF_Response response = (SIF_Response)testProto.readMsg();
Assert.AreEqual(SifRequestMsgId, response.SIF_RequestMsgId);
Assert.AreEqual(packetNumber, response.SIF_PacketNumber.Value);
Assert.AreEqual(morePacketsValue.ToString(), response.SIF_MorePackets);
SIF_Header header = response.SIF_Header;
Assert.AreEqual(sourceId, header.SIF_DestinationId);
SifElement responseObject = response.SIF_ObjectData.GetChildList()[0];
Assert.IsNotNull(responseObject);
}
public void testSifResponseSenderMultiplePackets()
{
MessageDispatcher testDispatcher = new MessageDispatcher(Zone);
Zone.Properties.OneObjectPerResponse = true;
Zone.SetDispatcher(testDispatcher);
Zone.Connect(ProvisioningFlags.None);
InMemoryProtocolHandler testProto = (InMemoryProtocolHandler)Zone.ProtocolHandler;
testProto.clear();
// Send a single SIF_Response with a small Authentication object
String SifRequestMsgId = Adk.MakeGuid();
String sourceId = "TEST_SOURCEID";
SifVersion testVersion = SifVersion.LATEST;
int maxBufferSize = int.MaxValue;
IElementDef[] testRestrictions = new IElementDef[] { InfrastructureDTD.AUTHENTICATION_REFID };
SifResponseSender srs = new SifResponseSender();
srs.Open(Zone, SifRequestMsgId, sourceId, testVersion, maxBufferSize, testRestrictions);
srs.Write(new Authentication(Adk.MakeGuid(), Adk.MakeGuid(), AuthSifRefIdType.EMPLOYEEPERSONAL));
srs.Write(new Authentication(Adk.MakeGuid(), Adk.MakeGuid(), AuthSifRefIdType.EMPLOYEEPERSONAL));
srs.Write(new Authentication(Adk.MakeGuid(), Adk.MakeGuid(), AuthSifRefIdType.EMPLOYEEPERSONAL));
srs.Write(new Authentication(Adk.MakeGuid(), Adk.MakeGuid(), AuthSifRefIdType.EMPLOYEEPERSONAL));
srs.Write(new Authentication(Adk.MakeGuid(), Adk.MakeGuid(), AuthSifRefIdType.EMPLOYEEPERSONAL));
srs.Close();
for (int x = 0; x < 5; x++)
{
// Retrieve the SIF_Response message off the protocol handler and asssert the results
SIF_Response response = (SIF_Response)testProto.readMsg();
Assert.AreEqual(SifRequestMsgId, response.SIF_RequestMsgId);
Assert.AreEqual(x + 1, response.SIF_PacketNumber.Value);
if (x == 4)
{
Assert.AreEqual("No", response.SIF_MorePackets);
}
else
{
Assert.AreEqual("Yes", response.SIF_MorePackets);
}
SIF_Header header = response.SIF_Header;
Assert.AreEqual(sourceId, header.SIF_DestinationId);
SifElement responseObject = response.SIF_ObjectData.GetChildList()[0];
Assert.IsNotNull(responseObject);
}
}
/// <summary>
/// Gets the content from the SIFElement for the specified version of SIF. Only
/// elements that apply to the requested version of SIF will be returned.
/// </summary>
/// <param name="element">The element to retrieve content from</param>
/// <param name="version"></param>
/// <returns></returns>
public override IList <Element> GetContent(SifElement element, SifVersion version)
{
List <Element> returnValue = new List <Element>();
ICollection <SimpleField> fields = element.GetFields();
foreach (SimpleField val in fields)
{
IElementDef def = val.ElementDef;
if (def.IsSupported(version) &&
!def.IsAttribute(version) &&
def.Field)
{
returnValue.Add(val);
}
}
IList <SifElement> children = element.GetChildList();
foreach (SifElement val in children)
{
IElementDef def = val.ElementDef;
if (def.IsSupported(version))
{
if (def.IsCollapsed(version))
{
ICollection <Element> subElements = GetContent(val, version);
// FIXUP the ElementDef for this version of SIF.
// for example, StudentPersonal/EmailList/Email needs it's
// ElementDef set to "StudentPersonal_Email"
foreach (Element e in subElements)
{
IElementDef subElementDef = e.ElementDef;
if (version.CompareTo(subElementDef.EarliestVersion) >= 0)
{
String tag = subElementDef.Tag(Adk.SifVersion);
IElementDef restoredDef = Adk.Dtd.LookupElementDef(element.ElementDef, tag);
if (restoredDef != null)
{
e.ElementDef = restoredDef;
}
returnValue.Add(e);
}
}
}
else
{
returnValue.Add(val);
}
}
}
MergeSort.Sort <Element>(returnValue, ElementSorter <Element> .GetInstance(version));
//returnValue.Sort(ElementSorter<Element>.GetInstance(version));
return(returnValue);
}
private void SetFieldValueFromAttribute(
SifElement element,
XmlReader reader,
IDtd dtd,
SifVersion version,
SifFormatter formatter,
IZone zone)
{
IElementDef elementDef = element.ElementDef;
IElementDef field = dtd.LookupElementDef(element.ElementDef, reader.LocalName);
if (field == null && reader.Prefix != null)
{
if (reader.LocalName == SifWriter.NIL && reader.NamespaceURI == XmlSchema.InstanceNamespace)
{
TypeConverter converter = elementDef.TypeConverter;
if (converter != null)
{
SifSimpleType sst = converter.GetSifSimpleType(null);
element.SetField(elementDef, sst);
}
return;
}
else if (reader.Name.StartsWith("xmlns"))
{
return;
}
else
{
field = dtd.LookupElementDef(elementDef, reader.Prefix + ":" + reader.LocalName);
}
}
if (field != null)
{
string strVal = reader.Value.Trim();
SifSimpleType val = ParseValue(field, strVal, version, formatter, zone);
element.SetField(field, val);
}
else if (element.ElementDef.EarliestVersion >= SifVersion.SIF20 && version < SifVersion.SIF20)
{
Adk.Log.Warn("Field " + element.ElementDef.ClassName + "." + (reader.Prefix == null ? reader.LocalName : reader.Prefix + ":" + reader.LocalName) + " does not exist in the sif 2.0 specification onwards. It may or may not be valid in sif 1.5r1. It will be ignored.");
}
else
{
// TODO: Log and gracefully ignore, depending on whether the ADK is set to strict or loose parsing
throw new SifException
(SifErrorCategoryCode.Xml, SifErrorCodes.XML_GENERIC_VALIDATION_3,
"Unknown element or attribute",
reader.LocalName + " is not a recognized attribute of the " +
elementDef.Name + " element (SIF " +
element.EffectiveSIFVersion.ToString() + ")", zone);
}
}
/// <summary> Parses a SIF data element into a <c>SifElement</c>.
///
/// </summary>
/// <param name="msg">The content to parse
/// </param>
/// <param name="zone">The Zone from which the message was received, or null if
/// not applicable or not known
/// </param>
/// <param name="flags">One or more <c>FLG_</c> constants, or zero if no
/// flags are applicable
/// </param>
/// <param name="version">The version of SIF that will be associated with the
/// returned object. By default, SifParser uses the default version of
/// SIF in effect for the agent when parsing messages that do not have
/// a SIF_Message envelope. By specifying a value to this parameter, you
/// can change the version of SIF associated with the returned object in
/// the event there is no SIF_Message envelope present in the XML
/// content. Note that when parsing XML content with a SIF_Message
/// envelope, SifParser ignores this parameter and instead uses the
/// version indicated by the <i>Version</i> and <i>xmlns</i> attributes
///
/// </param>
/// <returns> A SifElement object encapsulating the message payload (e.g.
/// a OpenADK.Library.us.Student.StudentPersonal object)
///
/// </returns>
/// <exception cref="OpenADK.Library.AdkParsingException">AdkParsingException is thrown if unable to
/// parse the message</exception>
/// <exception cref="System.IO.IOException"> IOException is thrown if an error is reported while reading
/// the message content</exception>
public SifElement Parse(string msg,
IZone zone,
SifParserFlags flags,
SifVersion version)
{
using (StringReader reader = new StringReader(msg))
{
SifElement element = Parse(reader, zone, flags, version);
reader.Close();
return(element);
}
}
/// <summary>
/// Creates a child element, if supported by this node
/// </summary>
/// <param name="parentPointer"></param>
/// <param name="formatter"></param>
/// <param name="version"></param>
/// <param name="context"></param>
/// <returns></returns>
public INodePointer CreateChild(INodePointer parentPointer, SifFormatter formatter, SifVersion version,
SifXPathContext context)
{
// 1) Create an instance of the SimpleField with a null value (It's assigned later)
//
// STEP 2
// Find the actual field to set the value to
//
SifElement parent = (SifElement)((SifElementPointer)parentPointer).Element;
SifElement targetElement = parent;
if (!fElementDef.Field)
{
// This indicates a child SifElement that needs to be created
targetElement = SifElement.Create(parent, fElementDef);
formatter.AddChild(parent, targetElement, version);
}
IElementDef fieldDef = null;
if (fValueXpath.Equals("."))
{
fieldDef = fElementDef;
}
else
{
String fieldName = fValueXpath;
if (fValueXpath.StartsWith("@"))
{
fieldName = fValueXpath.Substring(1);
}
fieldDef = Adk.Dtd.LookupElementDef(fElementDef, fieldName);
}
if (fieldDef == null)
{
throw new ArgumentException("Support for value path {" + fValueXpath +
"} is not supported by XPathSurrogate.");
}
SifSimpleType ssf = fieldDef.TypeConverter.GetSifSimpleType(null);
SimpleField sf = ssf.CreateField(targetElement, fieldDef);
targetElement.SetField(sf);
// 2) built out a fake set of node pointers representing the SIF 1.5r1 path and
// return the root pointer from that stack
return(BuildLegacyPointers(parentPointer, sf));
}
/// <summary>
/// Gets the content from the SIFElement for the specified version of SIF. Only
/// elements that apply to the requested version of SIF will be returned.
/// </summary>
/// <param name="element">The element to retrieve content from</param>
/// <param name="version"></param>
/// <returns></returns>
public override IList<Element> GetContent(SifElement element, SifVersion version)
{
List<Element> returnValue = new List<Element>();
ICollection<SimpleField> fields = element.GetFields();
foreach (SimpleField val in fields)
{
IElementDef def = val.ElementDef;
if (def.IsSupported(version) &&
!def.IsAttribute(version) &&
def.Field )
{
returnValue.Add(val);
}
}
IList<SifElement> children = element.GetChildList();
foreach (SifElement val in children)
{
IElementDef def = val.ElementDef;
if (def.IsSupported(version))
{
if (def.IsCollapsed(version))
{
ICollection<Element> subElements = GetContent(val, version);
// FIXUP the ElementDef for this version of SIF.
// for example, StudentPersonal/EmailList/Email needs it's
// ElementDef set to "StudentPersonal_Email"
foreach (Element e in subElements)
{
IElementDef subElementDef = e.ElementDef;
if (version.CompareTo(subElementDef.EarliestVersion) >= 0)
{
String tag = subElementDef.Tag(Adk.SifVersion);
IElementDef restoredDef = Adk.Dtd.LookupElementDef(element.ElementDef, tag);
if (restoredDef != null)
{
e.ElementDef = restoredDef;
}
returnValue.Add(e);
}
}
}
else
{
returnValue.Add(val);
}
}
}
MergeSort.Sort<Element>(returnValue, ElementSorter<Element>.GetInstance(version));
//returnValue.Sort(ElementSorter<Element>.GetInstance(version));
return returnValue;
}
private void Write(SifElement o, int mode, Boolean isLegacy)
{
if (!Include(o))
{
return;
}
// "<tag [attr...]>[text]" or "<tag [attr...]/>"
string tag = o.ElementDef.Tag(fVersion);
fWriter.WriteStartElement(tag);
if (!fRootAttributesWritten)
{
writeRootAttributes(false);
}
WriteAttributes(o);
if (mode == EMPTY)
{
fWriter.WriteEndElement();
}
else
{
// Check for a text value (or an xs:nil value)
SimpleField elementValue = o.GetField(o.ElementDef);
if (elementValue != null)
{
SifSimpleType sst = elementValue.SifValue;
if (sst == null || sst.RawValue == null)
{
// The value of this element has been set and it is
// null. This should be rendered as 'xs:nil' in SIF 2.x and greater
if (!isLegacy)
{
fWriter.WriteAttributeString(NIL, XmlSchema.InstanceNamespace, "true");
}
}
else
{
if (o.DoNotEncode)
{
fWriter.WriteRaw(o.TextValue);
}
else
{
String xmlValue = sst.ToString(fFormatter);
fWriter.WriteString(xmlValue);
}
}
}
}
}
/**
* Perform a mapping operation on the specified SIFElement. The mapping operation
* will be either inbound or outbound, depending on whether this class was returned
* from {@link Mappings#selectInbound(ElementDef, SIFVersion, String, String)} or
* {@link Mappings#selectOutbound(ElementDef, SIFVersion, String, String)}
* @param mappedElement The SIFElement to perform the mappings operation on
* @param adaptor The FieldAdaptor to use for getting or setting data
* @throws ADKMappingException
*/
public void Map(SifElement mappedElement, IFieldAdaptor adaptor)
{
SifXPathContext context = GetXPathContext(mappedElement, adaptor);
if (fDirection == MappingDirection.Inbound)
{
fMappings.MapInbound(context, adaptor, mappedElement, fFieldMappings, fSIFVersion);
}
else if (fDirection == MappingDirection.Outbound)
{
fMappings.MapOutbound(context, adaptor, mappedElement, fFieldMappings, fValueBuilder, fSIFVersion);
}
}
internal static INodePointer Create(INodePointer parent, SifElement element, SifVersion version)
{
if (version.Major < 2)
{
IElementDef fieldDef = element.ElementDef;
IRenderSurrogate rs = fieldDef.GetVersionInfo(version).GetSurrogate();
if (rs != null)
{
return(rs.CreateNodePointer(parent, element, version));
}
}
return(new SifElementPointer(parent, element, version));
}
public void UnexpectedEmbeddedSIFMessage()
{
// this test should throw an exception because we are not passing "ExpectInnerEnvelope" in the
// parser flags
using (Stream aStream = GetResourceStream("GetNextMessageResponse.xml"))
{
TextReader aReader = new StreamReader(aStream);
SifParser parser = SifParser.NewInstance();
SifElement element = parser.Parse(aReader, null, SifParserFlags.None, SifVersion.SIF11);
aReader.Close();
aStream.Close();
}
}
/**
* Runs a schema validation test on a single object using the ADK
* @param sdo
* @throws Exception
*/
protected void testSchemaElement(SifElement se)
{
bool validated = fSchemaValidator.Validate( se, fVersion );
// 4) If validation failed, write the object out for tracing purposes
if ( !validated ) {
SifWriter outWriter = new SifWriter( fOutput );
outWriter.Write( se, fVersion );
outWriter.Flush();
fSchemaValidator.PrintProblems( fOutput );
Assertion.Assert( "Errors validating...", false );
}
}
public void ParsingSIFTime()
{
SifElement element = null;
using (Stream aStream = GetResourceStream("LibraryPatronStatus.xml"))
{
SifParser parser = SifParser.NewInstance();
element = parser.Parse(aStream, null);
aStream.Close();
}
Assert.IsNotNull(element, "SIFElement was not parsed");
}
public void ParsingSectionInfo()
{
SifElement element = null;
using (Stream aStream = GetResourceStream("SectionInfo_SchoolCourseInfoOverride.xml"))
{
SifParser parser = SifParser.NewInstance();
element = parser.Parse(aStream, null);
aStream.Close();
}
Assert.IsNotNull(element, "SIFElement was not parsed");
}
/// <summary>
/// Creates a new SifXPathContext
/// </summary>
/// <param name="parent"></param>
/// <param name="context"></param>
private SifXPathContext( SifXPathContext parent, SifElement context )
{
if ( parent != null )
{
fContext = parent.fContext;
}
else
{
fContext = new SifXsltContext();
fContext.AddFunctions( "adk", new ClassFunctions( typeof ( AdkFunctions ), null ) );
}
SifVersion version = context.SifVersion;
if( version == null )
{
version = SifVersion.LATEST;
}
fContextElement = context;
fContextPointer = new SifElementPointer( null, fContextElement, version );
fDefaultNavigator = new SifXPathNavigator( fContext, fContextPointer );
}
/// <summary>
/// Write a SIF element in the version of SIF currently in effect for this
/// SIFWriter.
/// </summary>
/// <param name="o"></param>
private void WriteElement( SifElement o )
{
WriteElement( o, fVersion.CompareTo( SifVersion.SIF20 ) < 0 );
}
/// <summary>
/// Adds a SimpleField parsed from a specific version of SIF to the parent.
/// </summary>
/// <param name="contentParent">The element to add content to</param>
/// <param name="fieldDef">The metadata definition of the field to set</param>
/// <param name="data">The value to set to the field</param>
/// <param name="version">The version of SIF that the SIFElement is being constructed
/// from</param>
/// <returns></returns>
public virtual SimpleField SetField(SifElement contentParent,
IElementDef fieldDef,
SifSimpleType data,
SifVersion version)
{
return contentParent.SetField(fieldDef, data);
}
private void SetFieldValueFromAttribute(
SifElement element,
XmlReader reader,
IDtd dtd,
SifVersion version,
SifFormatter formatter,
IZone zone )
{
IElementDef elementDef = element.ElementDef;
IElementDef field = dtd.LookupElementDef( element.ElementDef, reader.LocalName );
if ( field == null && reader.Prefix != null )
{
if(reader.LocalName == SifWriter.NIL && reader.NamespaceURI == XmlSchema.InstanceNamespace )
{
TypeConverter converter = elementDef.TypeConverter;
if ( converter != null )
{
SifSimpleType sst = converter.GetSifSimpleType( null );
element.SetField(elementDef, sst);
}
return;
}
else if( reader.Name.StartsWith( "xmlns" ) )
{
return;
}
else
{
field = dtd.LookupElementDef(elementDef, reader.Prefix + ":" + reader.LocalName);
}
}
if( field != null )
{
string strVal = reader.Value.Trim();
SifSimpleType val = ParseValue( field, strVal, version, formatter, zone );
element.SetField( field, val );
}
else if (element.ElementDef.EarliestVersion >= SifVersion.SIF20 && version < SifVersion.SIF20)
{
Adk.Log.Warn("Field " + element.ElementDef.ClassName + "." + (reader.Prefix == null ? reader.LocalName : reader.Prefix + ":" + reader.LocalName ) + " does not exist in the sif 2.0 specification onwards. It may or may not be valid in sif 1.5r1. It will be ignored." );
}
else
{
// TODO: Log and gracefully ignore, depending on whether the ADK is set to strict or loose parsing
throw new SifException
(SifErrorCategoryCode.Xml, SifErrorCodes.XML_GENERIC_VALIDATION_3,
"Unknown element or attribute",
reader.LocalName + " is not a recognized attribute of the " +
elementDef.Name + " element (SIF " +
element.EffectiveSIFVersion.ToString() + ")", zone);
}
}
private void SetFieldValueFromElement( IElementDef def,
SifElement element,
XmlReader reader,
SifVersion version,
SifFormatter formatter,
IZone zone )
{
// Check for xsi:nill
if ( reader.IsEmptyElement )
{
// no data to set
return;
}
// Look for the xsi:nill attribute that signals a null value
while ( reader.MoveToNextAttribute() )
{
if (reader.LocalName == SifWriter.NIL && reader.NamespaceURI == XmlSchema.InstanceNamespace)
{
SifSimpleType val = def.TypeConverter.GetSifSimpleType( null );
element.SetField( def, val );
while (reader.NodeType != XmlNodeType.EndElement)
{
reader.Read();
}
return;
}
else
{
// TODO: This is an unknown attribute. Log and continue
}
}
while ( reader.NodeType == XmlNodeType.Element )
{
reader.Read();
}
if ( reader.NodeType == XmlNodeType.Text )
{
SifSimpleType val = ParseValue( def, reader.Value.Trim(), version, formatter, zone );
element.SetField( def, val );
}
// TODO: Not sure if this will always advance as expected.
while ( reader.NodeType != XmlNodeType.EndElement )
{
reader.Read();
}
}
/// <summary>
/// Create a SimpleField from the value that this type represents
/// </summary>
/// <param name="parent">The SIFElement that will be the parent of the field</param>
/// <param name="id">The metatdata definition of the field being set</param>
/// <returns>A SimpleField instance initialized with the proper value</returns>
public virtual SimpleField CreateField( SifElement parent,
IElementDef id )
{
return new SimpleField( parent, id, this );
}
/// <summary> Write the attributes of a SifElement to the output stream</summary>
/// <param name="o">The SifElement whose attributes are to be written
/// </param>
private void WriteAttributes( SifElement o )
{
// TODO: We need to make sure the GetFields() API returns a usable collection
ICollection<SimpleField> fields = fFormatter.GetFields( o, fVersion );
foreach (SimpleField f in fields )
{
IElementVersionInfo evi = f.ElementDef.GetVersionInfo( fVersion );
if ( evi != null && evi.IsAttribute )
{
// Null attribute values are not supported in SIF, unlike
// element values, which can be represented with xs:nil
SifSimpleType sst = f.SifValue;
if (sst.RawValue != null)
{
String tag = evi.Tag;
Boolean handled = false;
if ( tag.StartsWith( "x" ) )
{
if ( evi.Tag.Equals( "xml:lang" ) )
{
fWriter.WriteAttributeString("xml", "lang", null, sst.ToString(fFormatter));
}
else if ( evi.Tag.Equals( "xsi:type" ) )
{
fWriter.WriteAttributeString("type", XmlSchema.InstanceNamespace, sst.ToString(fFormatter));
}
handled = true;
}
if ( !handled )
{
fWriter.WriteStartAttribute( evi.Tag, string.Empty );
fWriter.WriteString( sst.ToString( fFormatter ) );
fWriter.WriteEndAttribute();
}
}
}
}
if ( fSerializeIds && o.XmlId != null )
{
fWriter.WriteAttributeString( "id", XML_NAMESPACE, o.XmlId );
}
}
//private const int CLOSE = 2;
private Boolean HasContent( SifElement o,
SifVersion version )
{
if ( o.ChildCount > 0 )
{
return true;
}
ICollection<SimpleField> fields = o.GetFields();
foreach ( SimpleField f in fields )
{
// TODO: This is a perfect place to optimize. Version-specific lookups
// should be optimized
if ( f.ElementDef.IsSupported( version ) && !f.ElementDef.IsAttribute( version ) )
{
return true;
}
}
return false;
}
private void Write( SifElement o, int mode, Boolean isLegacy )
{
if ( !Include( o ) )
{
return;
}
// "<tag [attr...]>[text]" or "<tag [attr...]/>"
string tag = o.ElementDef.Tag( fVersion );
fWriter.WriteStartElement( tag );
if (!fRootAttributesWritten)
{
writeRootAttributes(false);
}
WriteAttributes( o );
if ( mode == EMPTY )
{
fWriter.WriteEndElement();
}
else
{
// Check for a text value (or an xs:nil value)
SimpleField elementValue = o.GetField( o.ElementDef );
if ( elementValue != null )
{
SifSimpleType sst = elementValue.SifValue;
if ( sst == null || sst.RawValue == null )
{
// The value of this element has been set and it is
// null. This should be rendered as 'xs:nil' in SIF 2.x and greater
if ( !isLegacy )
{
fWriter.WriteAttributeString(NIL, XmlSchema.InstanceNamespace, "true");
}
}
else
{
if ( o.DoNotEncode )
{
fWriter.WriteRaw( o.TextValue );
}
else
{
String xmlValue = sst.ToString( fFormatter );
fWriter.WriteString( xmlValue );
}
}
}
}
}
/// <summary>
/// Creates a new SifXPathContext instance to use for traversing the
/// specified SIF Data Object
/// </summary>
/// <remarks>
/// NOTE: The SIFDataObject.setSIFVersion(version) is automatically
/// called and set to the target version.
/// </remarks>
/// <param name="parent">The SifXPathContext to share custom functions and
/// variables with</param>
/// <param name="sdo">The SIF Data Object or SIFElement to traverse</param>
/// <returns>an instance of SifXPathContext</returns>
/// <param name="version">The SIFVersion to use when traversing this object using XPath.</param>
public static SifXPathContext NewSIFContext( SifXPathContext parent,
SifElement sdo, SifVersion version )
{
sdo.SifVersion = version;
return NewSIFContext( parent, sdo );
}
/// <summary>
/// Creates a new SifXPathContext instance to use for traversing the
/// specified SIF Data Object
/// </summary>
/// <remarks>
/// Contexts that are created from other contexts automatically inherit all
/// custom variables and functions that are defined in the other context
/// </remarks>
/// <param name="parent">The SifXPathContext to share custom functions and
/// variables with</param>
/// <param name="sdo">The SIF Data Object or SIFElement to traverse</param>
/// <returns>an instance of SifXPathContext</returns>
public static SifXPathContext NewSIFContext( SifXPathContext parent,
SifElement sdo )
{
SifXPathContext context = new SifXPathContext( parent, sdo );
return context;
}
/// <summary>
/// Gets the fields from the SIFElement for the specified version of SIF. Only
/// the fields that apply to the requested version of SIF will be returned.
/// </summary>
/// <param name="element"></param>
/// <param name="version"></param>
/// <returns></returns>
public virtual ICollection<SimpleField> GetFields(SifElement element, SifVersion version)
{
ICollection<SimpleField> fields = element.GetFields();
List<SimpleField> returnValue = new List<SimpleField>();
// remove any fields that do not belong in this version of SIF
foreach(SimpleField field in fields )
{
IElementDef def = field.ElementDef;
if (version.CompareTo(def.EarliestVersion) > -1 &&
version.CompareTo(def.LatestVersion) < 1)
{
returnValue.Add( field );
}
}
returnValue.Sort( ElementSorter<SimpleField>.GetInstance( version ) );
return returnValue;
}
public bool ReadRaw( XmlReader reader,
SifVersion version,
SifElement parent,
SifFormatter formatter )
{
String elementName = fElementDef.Name;
if ( !reader.LocalName.Equals( elementName ) )
{
return false;
}
String value = ConsumeElementTextValue( reader, version );
if ( value != null && value.Length > 0 )
{
DateTime? time = formatter.ToTime( value );
SifTime sifTime = new SifTime( time );
parent.SetField( sifTime.CreateField( parent, fElementDef ) );
}
return true;
}
private SifXPathContext GetXPathContext(
SifElement mappedElement, IFieldAdaptor adaptor)
{
lock (this)
{
if (!mappedElement.ElementDef.Name.Equals(fElementDef.Name))
{
throw new AdkMappingException(
"Unable to use object for mapping. MappingsContext expected an object of type '" +
fElementDef.Name + "' but was '" + mappedElement.ElementDef.Name + "'.", null);
}
if (fRootContext == null)
{
fRootContext = SifXPathContext.NewSIFContext(mappedElement, fSIFVersion);
if (adaptor is IXPathVariableLibrary)
{
fRootContext.AddVariables( "", (IXPathVariableLibrary)adaptor);
}
}
return SifXPathContext.NewSIFContext(fRootContext, mappedElement);
}
}
internal static INodePointer Create( INodePointer parent, SifElement element, SifVersion version )
{
if ( version.Major < 2 )
{
IElementDef fieldDef = element.ElementDef;
IRenderSurrogate rs = fieldDef.GetVersionInfo( version ).GetSurrogate();
if ( rs != null )
{
return rs.CreateNodePointer( parent, element, version );
}
}
return new SifElementPointer( parent, element, version );
}
public bool ReadRaw( XmlReader reader,
SifVersion version,
SifElement parent,
SifFormatter formatter )
{
string name = reader.LocalName;
if ( name.Equals( fDateElement ) )
{
String dateValue = ConsumeElementTextValue( reader, version );
DateTime? date = formatter.ToDate( dateValue );
if ( date.HasValue )
{
DateTime tsValue = date.Value;
SifDateTime dateTime = new SifDateTime( tsValue );
parent.SetField( dateTime.CreateField( parent, fElementDef ) );
}
}
else if ( name.Equals( fTimeElement ) )
{
String timeValue = ConsumeElementTextValue( reader, version );
DateTime? time = formatter.ToTime( timeValue );
if ( time.HasValue )
{
DateTime val = time.Value;
// See if the Timestamp field already exists on the parent
SimpleField timeStampField = parent.GetField( fElementDef );
if ( timeStampField == null )
{
// Doesn't exist, create it
SifDateTime dateTime = new SifDateTime( val );
parent.SetField( dateTime.CreateField( parent, fElementDef ) );
}
else
{
// Exists, update the time portion of the date
SifDateTime sdt = (SifDateTime) timeStampField.SifValue;
if ( sdt != null && sdt.Value.HasValue )
{
DateTime tsValue = sdt.Value.Value;
tsValue = tsValue.Add( val.TimeOfDay );
sdt = new SifDateTime( tsValue );
// Overwrite the current value
parent.SetField( sdt.CreateField( parent, fElementDef ) );
}
}
}
}
else
{
return false;
}
return true;
}
/// <summary>
/// Write a SIF element in the version of SIF currently in effect for this
/// SIFWriter
/// </summary>
/// <param name="o">The SIF Element instance to write to the output stream</param>
public virtual void Write( SifElement o )
{
WriteElement( o );
}
public virtual SifElement AddChild(SifElement contentParent, SifElement content, SifVersion version)
{
return contentParent.AddChild(content);
}
/// <summary>
/// Creates a new SifXPathContext instance to use for traversing the
/// specified SIF Data Object
/// </summary>
/// <remarks>
/// NOTE: The SIFDataObject.setSIFVersion(version) is automatically
/// called and set to the target version.
/// </remarks>
/// <param name="sdo">The SIF Data Object or SIFElement to traverse</param>
/// <returns>an instance of SifXPathContext</returns>
/// <param name="version">The SIFVersion to use when traversing this object using XPath.</param>
public static SifXPathContext NewSIFContext( SifElement sdo, SifVersion version )
{
sdo.SifVersion = version;
SifXPathContext context = NewSIFContext( sdo );
return context;
}
/// <summary>
/// Gets the content from the SIFElement for the specified version of SIF. Only
/// elements that apply to the requested version of SIF will be returned.
/// </summary>
/// <param name="element">The element to retrieve content from</param>
/// <param name="version"></param>
/// <returns></returns>
public virtual IList<Element> GetContent( SifElement element, SifVersion version )
{
List<Element> returnValue = new List<Element>();
ICollection<SimpleField> fields = element.GetFields();
foreach (SimpleField val in fields) {
IElementDef def = val.ElementDef;
if (def.IsSupported(version) &&
!def.IsAttribute(version) &&
def.Field)
{
returnValue.Add(val);
}
}
IList<SifElement> children = element.GetChildList();
foreach(SifElement val in children ) {
IElementDef def = val.ElementDef;
if (def.IsSupported(version))
{
returnValue.Add(val);
}
}
MergeSort.Sort<Element>(returnValue, ElementSorter<Element>.GetInstance(version));
//returnValue.Sort( ElementSorter<Element>.GetInstance( version ) );
return returnValue;
}
/// <summary>
/// Creates a new SifXPathContext instance to use for traversing the
/// specified SIF Data Object
/// </summary>
/// <param name="sdo">The SIF Data Object or SIFElement to traverse</param>
/// <returns>an instance of SifXPathContext</returns>
public static SifXPathContext NewSIFContext( SifElement sdo )
{
return NewSIFContext( null, sdo );
}
private IElementDef LookupElementDef( SifElement parent,
XmlReader reader,
IDtd dtd,
SifVersion version,
IZone zone )
{
// Lookup the ElementDef metadata in the SifDtd object for the
// version of SIF we are parsing. First try looking up a ElementDef
// for a field or complex object that is a child of another element,
// such as StudentPersonal_Name, SIF_Ack_SIF_Header, etc. If none
// found then look for a root-level element such as StudentPersonal,
// SIF_Ack, etc. If still nothing is found we don't know how to
// parse this element -- it is neither a top-level object element
// nor a child field element for this version of SIF.
String elementName = reader.LocalName;
IElementDef def = null;
if ( parent != null )
{
def = dtd.LookupElementDef( parent.ElementDef, elementName );
}
if ( def == null )
{
def = dtd.LookupElementDef( elementName );
}
// Beginning with SIF 1.5 *any* object can have a SIF_ExtendedElements
// child, so we need to check for that case since the Adk metadata
// does not add SIF_ExtendedElements to all object types
if ( def == null && elementName.Equals( "SIF_ExtendedElements" ) )
{
def = GlobalDTD.SIF_EXTENDEDELEMENTS;
}
// Beginning with SIF 2.0 *any* object can have a SIF_ExtendedElements
// child, so we need to check for that case since the Adk metadata
// does not add SIF_ExtendedElements to all object types
if ( def == null && elementName.Equals( "SIF_Metadata" ) )
{
// TODO: Add support for SIF_Metadata back in to the .NET ADK
def = null; // DatamodelDTD.SIF_METADATA;
}
// Note: def returned can be null.
return def;
}
private void ParseLegacyXML(
XmlReader reader,
SifVersion version,
IZone zone,
SifElement currentElement,
SifFormatter formatter,
String xmlName )
{
bool handled = false;
// Determine if any surrogate formatters that are defined as children
// of the current element can resolve it
// NOTE: Until we fix this in the ADK, elements from the common package loose their
// metadata information that was originally defined.
IElementDef currentDef = currentElement.ElementDef;
IList<IElementDef> children = currentDef.Children;
if ( children == null || children.Count == 0 )
{
// try to get the actual element def
// WARNING! this is somewhat of a hack until
// we get support for what we need in the ADK metadata
try
{
SifElement copy =
(SifElement) ClassFactory.CreateInstance( currentDef.FQClassName );
children = copy.ElementDef.Children;
}
catch ( Exception cnfe )
{
throw new SifException(
SifErrorCategoryCode.Xml,
SifErrorCodes.XML_GENERIC_VALIDATION_3,
"Unable to parse" + xmlName + " " + version.ToString() + cnfe.Message, zone );
}
}
using (XmlReader subtreeReader = reader.ReadSubtree())
{
subtreeReader.Read();
foreach ( IElementDef candidate in children )
{
if ( candidate.EarliestVersion.CompareTo( version ) > 0 )
{
continue;
}
IElementVersionInfo evi = candidate.GetVersionInfo( version );
if ( evi != null )
{
IRenderSurrogate rs = evi.GetSurrogate();
if ( rs != null )
{
try
{
bool surrogateHandled = rs.ReadRaw( subtreeReader, version, currentElement, formatter );
if ( surrogateHandled )
{
handled = true;
break;
}
}
catch ( AdkTypeParseException e )
{
HandleTypeParseException( "Unable to parse element or attribute value: " + e.Message, e,
zone );
handled = true;
break;
}
catch ( AdkParsingException e )
{
throw new SifException( SifErrorCategoryCode.Xml,
SifErrorCodes.XML_GENERIC_VALIDATION_3,
"unable to parse xml: " + e.Message
+ version.ToString(), zone );
}
}
}
}
subtreeReader.Close();
}
// advance to the next tag
reader.Read();
if ( !handled )
{
String _tag = currentElement != null
? currentElement.ElementDef.Name + "/" + xmlName
: xmlName;
throw new SifException(
SifErrorCategoryCode.Xml,
SifErrorCodes.XML_GENERIC_VALIDATION_3, "Unknown element or attribute",
_tag + " is not a recognized element of SIF " + version.ToString(), zone );
}
}
private SifElement ReadSifElementFromElementNode(
IElementDef def,
XmlReader reader,
IDtd dtd,
SifElement parent,
SifFormatter formatter,
SifVersion version,
IZone zone )
{
SifElement element;
try
{
element = SifElement.Create( parent, def );
}
catch ( TypeLoadException tle )
{
throw new AdkParsingException
( "Could not create an instance of " + def.FQClassName + " to wrap a " +
reader.LocalName + " element because that class doesn't exist", zone, tle );
}
catch ( Exception ex )
{
throw new AdkParsingException
( "Could not create an instance of " + def.FQClassName, zone, ex );
}
element.ElementDef = def;
element.SifVersion = version;
if ( parent != null )
{
element = formatter.AddChild( parent, element, version );
}
// Set the attributes to fields of the SifElement
while ( reader.MoveToNextAttribute() )
{
SetFieldValueFromAttribute( element, reader, dtd, version, formatter, zone );
}
return element;
}
/**
* Perform a mapping operation on the specified SIFElement. The mapping operation
* will be either inbound or outbound, depending on whether this class was returned
* from {@link Mappings#selectInbound(ElementDef, SIFVersion, String, String)} or
* {@link Mappings#selectOutbound(ElementDef, SIFVersion, String, String)}
* @param mappedElement The SIFElement to perform the mappings operation on
* @param adaptor The FieldAdaptor to use for getting or setting data
* @throws ADKMappingException
*/
public void Map(SifElement mappedElement, IFieldAdaptor adaptor)
{
SifXPathContext context = GetXPathContext(mappedElement, adaptor);
if (fDirection == MappingDirection.Inbound)
{
fMappings.MapInbound(context, adaptor, mappedElement, fFieldMappings, fSIFVersion);
}
else if (fDirection == MappingDirection.Outbound)
{
fMappings.MapOutbound(context, adaptor, mappedElement, fFieldMappings, fValueBuilder, fSIFVersion);
}
}
/// <summary> Write a SIF element in the version of SIF currently in effect for this
/// SifWriter.
/// </summary>
/// <param name="element">The SIF Element instance to Write to the output stream
/// <param name="isLegacy">if true, this method assumes that it needs to do more work,
/// such as looking for rendering surrogates for the specific version of SIF</param>
/// </param>
private void WriteElement( SifElement element, bool isLegacy )
{
IElementDef def = element.ElementDef;
if ( !(Include( element ) && def.IsSupported( fVersion ) ) )
{
return;
}
if (isLegacy)
{
IRenderSurrogate surrogate = def.GetVersionInfo(fVersion).GetSurrogate();
if (surrogate != null)
{
surrogate.RenderRaw(fWriter, fVersion, element, fFormatter);
return;
}
}
if ( element.IsEmpty() || !HasContent( element, fVersion ) )
{
if (element is XMLData)
{
XmlDocument doc = ((XMLData) element).Xml;
doc.Save( fWriter );
}
else
{
Write( element, EMPTY, isLegacy );
}
}
else
{
Write( element, OPEN, isLegacy );
ICollection<Element> elements = fFormatter.GetContent( element, fVersion );
foreach ( Element childElement in elements )
{
if ( childElement is SifElement )
{
WriteElement( (SifElement) childElement, isLegacy );
}
else
{
Write( (SimpleField) childElement, isLegacy );
}
}
fWriter.WriteEndElement();
}
}
