/// <summary>
/// Sets the value of this field
/// </summary>
/// <param name="id"></param>
/// <param name="value"></param>
/// <returns></returns>
public override SimpleField SetField(IElementDef id, SifSimpleType value)
{
// verify the parameter values
if (id == null || !(CommonDTD.PARTIALDATETYPE.Name.Equals(id.Name)))
{
throw new ArgumentException("ElementDef must be CommonDTD.PARTIALDATETYPE");
}
if (value != null && value.DataType != SifDataType.String)
{
throw new ArgumentException("Value type must be SIFDataType.STRING");
}
// Allow any datatype to be set, but convert it to a string
// This is important, because the value of this could be set to
// an int from mappings, because it was an int in SIF 1.5
if (value != null && value.DataType != SifDataType.String)
{
value = new SifString(value.ToString());
}
// Parse the text value into its representative parts
SimpleField returnValue = base.SetField(id, value);
parseTextValue();
return(returnValue);
}
public void TestxsiNill_SDOObjectXML()
{
LearnerPersonal lp = new LearnerPersonal();
// Add a null UPN
SifString str = new SifString(null);
lp.SetField(LearnerDTD.LEARNERPERSONAL_UPN, str);
// Add a null AlertMsg
AlertMsg msg = new AlertMsg(AlertMsgType.DISCIPLINE, null);
lp.AlertMsgList = new AlertMsgList(msg);
msg.SetField(CommonDTD.ALERTMSG, new SifString(null));
// Write the object to a file
Console.WriteLine("Writing to file...");
using (Stream fos = File.Open("SifWriterTest.Temp.xml", FileMode.Create, FileAccess.Write))
{
SifWriter writer = new SifWriter(fos);
lp.SetChanged(true);
writer.Write(lp);
writer.Flush();
fos.Close();
}
// Parse the object from the file
Console.WriteLine("Parsing from file...");
SifParser p = SifParser.NewInstance();
using (Stream fis = File.OpenRead("SifWriterTest.Temp.xml"))
{
lp = (LearnerPersonal)p.Parse(fis, null);
}
SimpleField upn = lp.GetField(LearnerDTD.LEARNERPERSONAL_UPN);
Assert.IsNotNull(upn);
SifString rawValue = (SifString)upn.SifValue;
Assert.IsNotNull(rawValue);
Assert.IsNull(rawValue.Value);
Assert.IsNull(upn.Value);
AlertMsgList alertMsgs = lp.AlertMsgList;
Assert.IsNotNull(alertMsgs);
Assert.IsTrue(alertMsgs.Count == 1);
msg = (AlertMsg)alertMsgs.GetChildList()[0];
Assert.IsNull(msg.Value);
SifSimpleType msgValue = msg.SifValue;
Assert.IsNotNull(msgValue);
Assert.IsNull(msgValue.RawValue);
}
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));
}
}
public SifSimpleType Evaluate(SifXPathContext xpathContext, SifVersion version, bool returnDefault)
{
SifSimpleType value = null;
if (fRule != null)
{
value = fRule.Evaluate(xpathContext, version);
}
if (value == null && fDefValue != null && returnDefault)
{
// TODO: Support all data types
try
{
return(SifTypeConverters.GetConverter(fDatatype).Parse(Adk.TextFormatter, fDefValue));
}
catch (AdkParsingException adkpe)
{
throw new AdkSchemaException(
"Error parsing default value: '" + fDefValue + "' for field " + fField + " : " + adkpe, null,
adkpe);
}
}
return(value);
}
/// <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 object ExtractRawValue(SifSimpleType data)
{
if (data == null)
{
return(null);
}
return(data.RawValue);
}
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>
/// Sets the specified value
/// </summary>
/// <param name="fieldName"></param>
/// <param name="resultingValue"></param>
/// <param name="mapping"></param>
public void SetSifValue(String fieldName, SifSimpleType resultingValue, FieldMapping mapping)
{
if (fOverwriteValues || !fMap.Contains(fieldName))
{
Object mapValue = ToMapValue(resultingValue);
fMap[fieldName] = mapValue;
}
}
/// <summary>
/// Sets a value that has been retrieved from a SIF Element in an inbound field
/// mapping operation.
/// </summary>
/// <param name="fieldName">The field name that is mapped to a SIFElement</param>
/// <param name="value">The value of the SIF element</param>
/// <param name="mapping">The FieldMappings that will be used to set this value or null</param>
public override void SetSifValue(string fieldName, SifSimpleType value, FieldMapping mapping)
{
int ordinal = SafeGetOrdinal(fieldName);
if (ordinal > -1)
{
fDataRow[ordinal] = value.RawValue;
}
}
protected SifSimpleType GetSIFSimpleTypeValue(IElementDef def, object rawValue)
{
if (rawValue is SifSimpleType)
{
return((SifSimpleType)rawValue);
}
SifSimpleType sst = def.TypeConverter.GetSifSimpleType(rawValue);
return(sst);
}
private void assertByXPath(SifXPathContext context, String xPath,
String assertedValue)
{
Element e = (Element)context.GetValue(xPath);
Assertion.AssertNotNull("Field is null for path " + xPath, e);
SifSimpleType value = e.SifValue;
Assertion.AssertNotNull("Value is null for path " + xPath, value);
Assertion.AssertEquals(xPath, assertedValue, value.ToString());
}
/// <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));
}
public void testCourseCodeSIF15r1()
{
Adk.SifVersion = SifVersion.SIF15r1;
SchoolCourseInfo sci = new SchoolCourseInfo();
sci.SetCourseCredits(CreditType.C0108_0585, 2);
SifXPathContext spc = SifXPathContext.NewSIFContext(sci);
Element value = (Element)spc.GetValue("CourseCredits[@Code='0585']");
SifSimpleType elementValue = value.SifValue;
Assertion.AssertNotNull("Value by XPath", elementValue);
Assertion.AssertEquals("Value By XPath", 2, elementValue.RawValue);
}
protected void SetFieldValue(Element field, Object value)
{
SifSimpleType sifValue = null;
if (value is SifSimpleType)
{
sifValue = (SifSimpleType)value;
}
else
{
sifValue = field.ElementDef.TypeConverter.GetSifSimpleType(value);
}
field.SifValue = sifValue;
}
public override INodePointer CreateAttribute(SifXPathContext context, String name)
{
IElementDef subEleDef = GetChildDef(name);
SifElement sifElement = (SifElement)fElement;
if (subEleDef.Field)
{
SifSimpleType ssf = subEleDef.TypeConverter.GetSifSimpleType(null);
SimpleField sf = ssf.CreateField(sifElement, subEleDef);
sifElement.SetField(sf);
return(SimpleFieldPointer.Create(this, sf));
}
throw new ArgumentException(
"Factory could not create a child node for path: " + Name
+ "/" + name);
}
/// <summary>
/// Converts a SIF datatype value to the java native type to be stored
/// in the Map. The default implementation of this class stores the
/// native Java value, but subclasses can override this method to convert
/// the value to the form they want to use.
/// </summary>
/// <param name="value">The SIF value to stored in the Map</param>
/// <returns>The converted value stored in the Map</returns>
protected virtual Object ToMapValue(SifSimpleType value)
{
return(value.RawValue);
}
/// <summary>
/// Converts a SIF datatype value to the java native type to be stored
/// in the Map. The default implementation of this class stores the
/// native Java value, but subclasses can override this method to convert
/// the value to the form they want to use.
/// </summary>
/// <param name="value">The SIF value to stored in the Map</param>
/// <returns>The converted value stored in the Map</returns>
protected virtual Object ToMapValue(SifSimpleType value)
{
return value.RawValue;
}
/// <summary>
/// Sets the specified value
/// </summary>
/// <param name="fieldName"></param>
/// <param name="resultingValue"></param>
/// <param name="mapping"></param>
public void SetSifValue(String fieldName, SifSimpleType resultingValue, FieldMapping mapping)
{
if (fOverwriteValues || !fMap.Contains(fieldName))
{
Object mapValue = ToMapValue(resultingValue);
fMap[fieldName] = mapValue;
}
}
/// <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);
}
public override void SetValue(object rawValue)
{
SifSimpleType sst = GetSIFSimpleTypeValue(fElementDef, rawValue);
fElement.SifValue = sst;
}
/// <summary>
/// Sets a value that has been retrieved from a SIF Element in an inbound field
/// mapping operation.
/// </summary>
/// <param name="fieldName">The field name that is mapped to a SIFElement</param>
/// <param name="value">The value of the SIF element</param>
/// <param name="mapping">The FieldMappings that will be used to set this value or null</param>
public override void SetSifValue(string fieldName, SifSimpleType value, FieldMapping mapping)
{
int ordinal = SafeGetOrdinal(fieldName);
if( ordinal > -1 )
{
fDataRow[ordinal] = value.RawValue;
}
}
/// <summary> /// Sets a value that has been retrieved from a SIF Element in an inbound field /// mapping operation. /// </summary> /// <param name="fieldName">The field name that is mapped to a SIFElement</param> /// <param name="value">The value of the SIF element</param> /// <param name="mapping">The FieldMappings that will be used to set this value or null</param> public abstract void SetSifValue(string fieldName, SifSimpleType value, FieldMapping mapping);
/// <summary>
/// Sets a value that has been retrieved from a SIF Element in an inbound field
/// mapping operation.
/// </summary>
/// <param name="fieldName">The field name that is mapped to a SIFElement</param>
/// <param name="value">The value of the SIF element</param>
/// <param name="mapping">The FieldMappings that will be used to set this value or null</param>
public void SetSifValue(string fieldName, SifSimpleType value, FieldMapping mapping)
{
throw new NotSupportedException("Unable to set values to a DataReader");
}
/// <summary> /// Sets a value that has been retrieved from a SIF Element in an inbound field /// mapping operation. /// </summary> /// <param name="fieldName">The field name that is mapped to a SIFElement</param> /// <param name="value">The value of the SIF element</param> /// <param name="mapping">The FieldMappings that will be used to set this value or null</param> public abstract void SetSifValue(string fieldName, SifSimpleType value, FieldMapping mapping);
public bool ReadRaw(
XmlReader reader,
SifVersion version,
SifElement parent,
SifFormatter formatter)
{
String value = null;
//
// STEP 1
// Determine if this surrogate can handle the parsing of this node.
// Retrieve the node value as a string
//
String[] xPathParts = fLegacyXpath.Split('/');
XmlNodeType eventType = reader.NodeType;
String localName = reader.LocalName;
if (eventType == XmlNodeType.Element &&
localName.Equals(xPathParts[0]))
{
try
{
int currentSegment = 0;
int lastSegment = xPathParts.Length - 1;
if (xPathParts[lastSegment].StartsWith("@"))
{
lastSegment--;
}
while (currentSegment < lastSegment)
{
reader.Read();
currentSegment++;
if (!reader.LocalName.Equals(xPathParts[currentSegment]))
{
ThrowParseException
("Element {" + reader.LocalName +
"} is not supported by XPathSurrogate path " + fLegacyXpath,
version);
}
}
// New we are at the last segment in the XPath, and the XMLStreamReader
// should be positioned on the proper node. The last segment is either
// an attribute or an element, which need to be read differently
String finalSegment = xPathParts[xPathParts.Length - 1];
if (finalSegment.StartsWith("@"))
{
value = reader.GetAttribute(finalSegment.Substring(1));
}
else
{
value = ReadElementTextValue(reader);
}
// Note: Unlike the Java ADK, Surrogates in the the .NET ADK do not have to worry about
// completely consuming the XMLElement and advancing to the next tag. The .NET
// Surrogates are handed a reader that only allows reading the current node and
// the parent reader is automatically advanced when the surrogate is done.
}
catch (Exception xse)
{
ThrowParseException(xse, reader.LocalName, version);
}
}
else
{
// No match was found
return(false);
}
//
// STEP 2
// Find the actual field to set the value to
//
IElementDef fieldDef;
SifElement targetElement = parent;
if (fValueXpath.Equals(".") && fElementDef.Field)
{
fieldDef = fElementDef;
}
else
{
// This indicates a child SifElement that needs to be created
try
{
targetElement = SifElement.Create(parent, fElementDef);
}
catch (AdkSchemaException adkse)
{
ThrowParseException(adkse, reader.LocalName, version);
}
formatter.AddChild(parent, targetElement, version);
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 InvalidOperationException
("Support for value path {" + fValueXpath +
"} is not supported by XPathSurrogate.");
}
//
// STEP 3
// Set the value to the field
//
TypeConverter converter = fieldDef.TypeConverter;
if (converter == null)
{
// TODO: Determine if we should be automatically creating a converter
// for elementDefs that don't have one, or whether we should just throw the
// spurious data away.
converter = SifTypeConverters.STRING;
}
SifSimpleType data = converter.Parse(formatter, value);
targetElement.SetField(fieldDef, data);
return(true);
}
private object ExtractRawValue( SifSimpleType data )
{
if ( data == null )
{
return null;
}
return data.RawValue;
}
/// <summary>
/// Sets the value to the underlying dictionary using a SifFormatter
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
protected override Object ToMapValue(SifSimpleType value)
{
// Store items in the map using a string value
return(value.ToString(fDataFormatter));
}
/// <summary>
/// Sets a value that has been retrieved from a SIF Element in an inbound field
/// mapping operation.
/// </summary>
/// <param name="fieldName">The field name that is mapped to a SIFElement</param>
/// <param name="value">The value of the SIF element</param>
/// <param name="mapping">The FieldMappings that will be used to set this value or null</param>
public void SetSifValue(string fieldName, SifSimpleType value, FieldMapping mapping)
{
throw new NotSupportedException("Unable to set values to a DataReader");
}
