/// <summary>
/// Creates a SimpleFieldPointer
/// </summary>
/// <param name="parentPointer">The parent of this pointer</param>
/// <param name="element">The element being wrapped</param>
/// <param name="version">The SifVersion to use for resolving XPaths</param>
/// set of fields</param>
internal SimpleFieldPointer(
INodePointer parentPointer,
Element element,
SifVersion version )
: base(parentPointer, element, version)
{
}
/// <summary>
/// Creates a new pointer to a SimpleField that is represented as an XML Attribute
/// </summary>
/// <param name="parentPointer">The parent pointer</param>
/// <param name="element">The attribute being wrapped</param>
/// <param name="version">The SifVersion</param>
public SimpleFieldAttributePointer(
INodePointer parentPointer,
Element element,
SifVersion version )
: base(parentPointer, element, version)
{
}
private void CreatePredicateValues(INodePointer current, AdkExpression predicate, XsltContext evalContext)
{
if (predicate is AdkEqualOperation)
{
AdkExpression[] components = ((AdkEqualOperation)predicate).Arguments;
AdkLocPath lp = (AdkLocPath)components[0];
AdkNodeNameTest attrName = (AdkNodeNameTest)lp.Steps[0].NodeTest;
INodePointer attr = current.CreateAttribute(this, attrName.NodeName);
Object value = components[1].ComputeValue(evalContext);
attr.SetValue(value);
return;
}
// This might be the 'adk:x()' function
if (predicate is AdkAndOperation)
{
foreach (AdkExpression expr in ((AdkAndOperation)predicate).Arguments)
{
if (expr is AdkFunction && ((AdkFunction)expr).FunctionName.Equals("adk:x"))
{
// This is the special marker function that tells the ADK to always
// create the parent repeatable element. Don't evaluate it.
continue;
}
else
{
CreatePredicateValues(current, expr, evalContext);
}
}
return;
}
// Unrecognized predicate
throw new ArgumentException("Cannot evaluate expression predicate: " + predicate);
}
/// <summary>
/// Creates a new AdkElementPointer
/// </summary>
/// <param name="parentPointer">The parent of this element</param>
/// <param name="element">The element being wrapped</param>
/// <param name="version">The SifVersion in use</param>
/// within its parent list</param>
protected AdkElementPointer(INodePointer parentPointer, Element element, SifVersion version)
: base(parentPointer)
{
fVersion = version;
fElement = element;
fElementDef = element.ElementDef;
}
/// <summary>
/// Creates a SimpleFieldPointer
/// </summary>
/// <param name="parentPointer">The parent of this pointer</param>
/// <param name="element">The element being wrapped</param>
/// <param name="version">The SifVersion to use for resolving XPaths</param>
/// set of fields</param>
internal SimpleFieldPointer(
INodePointer parentPointer,
Element element,
SifVersion version)
: base(parentPointer, element, version)
{
}
/// <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>
/// 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>
/// Creates a new pointer to a SimpleField that is represented as an XML Attribute
/// </summary>
/// <param name="parentPointer">The parent pointer</param>
/// <param name="element">The attribute being wrapped</param>
/// <param name="version">The SifVersion</param>
public SimpleFieldAttributePointer
(
INodePointer parentPointer,
Element element,
SifVersion version)
: base(parentPointer, element, version)
{
}
/// <summary>
/// Returns true if the iterator has moved to the previous node. Otherwise false.
/// </summary>
public bool MovePrevious()
{
INodePointer previous = fCurrentIterator.MovePrevious();
if (previous != null)
{
fCurrentPointer = previous;
return(true);
}
return(false);
}
/// <summary>
/// Returns true if the iterator has moved to the next node. Otherwise false.
/// </summary>
public bool MoveNext()
{
INodePointer next = fCurrentIterator.MoveNext();
if (next != null)
{
fCurrentPointer = next;
return(true);
}
return(false);
}
/// <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));
}
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));
}
/// <summary>
/// Called by the ADK XPath traversal code when it is traversing the given element
/// in a legacy version of SIF
/// </summary>
/// <param name="parentPointer">The parent element pointer</param>
/// <param name="sourceElement">The Element to create a node pointer for</param>
/// <param name="version">The SIFVersion in effect</param>
/// <returns>A NodePointer representing the current element</returns>
public INodePointer CreateNodePointer(INodePointer parentPointer, Element sourceElement, SifVersion version)
{
// 1) Find the field referenced by the XPathSurrogate expression
// If it doesn't exist, return null
Element referencedField = FindReferencedElement(sourceElement);
if (referencedField == null)
{
return(null);
}
// 2) If it does exist, build out a fake set of node pointers representing the
// SIF 1.5r1 path and return the root pointer.
return(BuildLegacyPointers(parentPointer, referencedField));
}
/// <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 );
}
private INodePointer BuildLegacyPointers(INodePointer parent, Element referencedField)
{
String[] xPathParts = fLegacyXpath.Split('/');
int currentSegment = 0;
INodePointer root = null;
INodePointer currentParent = parent;
// Build the path
while (currentSegment < xPathParts.Length - 1)
{
FauxSifElementPointer pointer = new FauxSifElementPointer(currentParent, xPathParts[currentSegment]);
if (currentParent != null && currentParent is FauxSifElementPointer)
{
((FauxSifElementPointer)currentParent).SetChild(pointer, xPathParts[currentSegment]);
}
currentParent = pointer;
if (root == null)
{
root = pointer;
}
currentSegment++;
}
String finalSegment = xPathParts[currentSegment];
bool isAttribute = false;
if (finalSegment.StartsWith("@"))
{
// This is an attribute
finalSegment = finalSegment.Substring(1);
isAttribute = true;
}
SurrogateSimpleFieldPointer fieldPointer =
new SurrogateSimpleFieldPointer(currentParent, finalSegment, referencedField, isAttribute);
if (currentParent != null && currentParent is FauxSifElementPointer)
{
((FauxSifElementPointer)currentParent).SetChild(fieldPointer, finalSegment);
}
if (root == null)
{
root = fieldPointer;
}
return(root);
}
INavCursor INavCursor.Clone()
{
INodeIterator clonedIterator = fCurrentIterator.Clone();
INavCursor clonedParent = null;
if (fParentIterator != null)
{
clonedParent = fParentIterator.Clone();
}
INodePointer clonedPointer = null;
if (fCurrentPointer != null)
{
clonedPointer = fCurrentPointer.Clone();
}
return(new NavigableIterator(clonedIterator, clonedParent, clonedPointer));
}
/// <summary>
/// Called by the ADK XPath traversal code when it is traversing the given element
/// in a legacy version of SIF
/// </summary>
/// <param name="parentPointer">The parent element pointer</param>
/// <param name="element">The Element to create a node pointer for</param>
/// <param name="version">The SIFVersion in effect</param>
/// <returns>A NodePointer representing the current element</returns>
public INodePointer CreateNodePointer( INodePointer parentPointer, Element element, SifVersion version )
{
return null;
}
/// <summary>
/// Manually builds out a path to support the necessary mapping needs of the
/// ADK. By default, the JXPath implementation does not allow
/// context-dependend predicates (e.g. PhoneNumber[@Type='0096'] to be used
/// in XPaths that create the path. This implementation manually steps
/// through the XPath and builds it out. It's primary intent is to provide
/// the behavior that was present in the ADK before JXPath was used for
/// mapping
/// </summary>
/// <param name="expr">The Path expression to build out</param>
/// <param name="context"></param>
/// <returns></returns>
private INodePointer BuildADKPathWithPredicates(String expr, XsltContext context)
{
// Use the set of expression steps to determine which parts of the
// path already exist. Note that the order of evaluation used is optimized
// for first-time creation of elements. In other words, the path chosen was
// to evalaute the expression steps from the beginning rather than the end
// because for outbound mappings, that order will generally be the most efficient
AdkXPathStep[] steps = XPathParser.Parse(expr);
int currentStep = 0;
StringBuilder pathSoFar = new StringBuilder();
INodePointer parent = fContextPointer;
INodePointer current = null;
for ( ; currentStep < steps.Length; currentStep++)
{
current = FindChild(fDefaultNavigator, pathSoFar, steps[currentStep]);
if (current == null)
{
break;
}
pathSoFar.Append("/");
pathSoFar.Append(steps[currentStep].ToString());
parent = current;
}
if (current != null)
{
// We traversed the entire path and came up with a result.
// That means that the element we are trying to build the
// path to already exists. We will not create this path, so
// return null;
return(null);
}
// We've traversed down to the level where we think we need to
// add a child. However, there are cases where this is not the proper
// location. For example, in SIF 1.5r1, the StudentAddressList element is
// repeatable and Address is not. It would not be proper to add a new Address
// element under StudentAddressList. Instead, the algorithm needs to back
// up the stack until it reaches the next repeatable element for the current
// version of SIF
// The following code is primarily in place for the StudentAddressList case, which is
// why the isContextDependent() logic applies. Currently, there is no known other place
// where this checking needs to occur.
if (currentStep > 0 && steps[currentStep].IsContextDependent())
{
int step = currentStep;
INodePointer stepParent = parent;
while (step > -1)
// don't evaluate step 0 at the root of the object because this problem doesn't apply there
{
if (parent is SifElementPointer)
{
SifElementPointer sifParentPointer = (SifElementPointer)stepParent;
AdkNodeTest nt = steps[step].NodeTest;
if (nt is AdkNodeNameTest)
{
SifElementPointer.AddChildDirective result =
sifParentPointer.GetAddChildDirective(((AdkNodeNameTest)nt).NodeName);
if (result != SifElementPointer.AddChildDirective.DONT_ADD_NOT_REPEATABLE)
{
break;
}
}
}
else
{
break;
}
step--;
stepParent = stepParent.Parent;
}
if (step > -1 && step != currentStep)
{
currentStep = step;
parent = stepParent;
}
}
// At this point, we have a parent element and the index of the current
// step to evaluate
//InitialContext context = new InitialContext( new RootContext( this, (NodePointer) getContextPointer()));
for ( ; currentStep < steps.Length; currentStep++)
{
AdkNodeTest nt = steps[currentStep].NodeTest;
if (nt is AdkNodeNameTest)
{
current = parent.CreateChild(this, ((AdkNodeNameTest)nt).NodeName, 0);
if (current == null)
{
throw new ArgumentException("Cannot evaluate expression step: " + steps[currentStep]);
}
foreach (AdkExpression predicate in steps[currentStep].Predicates)
{
CreatePredicateValues(current, predicate, context);
}
}
else
{
throw new ArgumentException("Cannot evaluate expression step: " + steps[currentStep]);
}
parent = current;
}
// At the end, the 'parent' variable will contain the last element created by this function
return(parent);
}
private SingleNodeIterator( INodePointer iteratedItem, int position )
{
fPointer = iteratedItem;
fPosition = position;
}
/// <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)
{
// TODO Auto-generated method stub
return(null);
}
public FauxAttribute(INodePointer parent, string fauxName, String value) : base(parent, fauxName, true)
{
fValue = value;
}
private INodePointer BuildLegacyPointers( INodePointer parent, Element referencedField )
{
String[] xPathParts = fLegacyXpath.Split( '/' );
int currentSegment = 0;
INodePointer root = null;
INodePointer currentParent = parent;
// Build the path
while ( currentSegment < xPathParts.Length - 1 )
{
FauxSifElementPointer pointer = new FauxSifElementPointer( currentParent, xPathParts[currentSegment] );
if ( currentParent != null && currentParent is FauxSifElementPointer )
{
((FauxSifElementPointer) currentParent).SetChild( pointer, xPathParts[currentSegment] );
}
currentParent = pointer;
if ( root == null )
{
root = pointer;
}
currentSegment++;
}
String finalSegment = xPathParts[currentSegment];
bool isAttribute = false;
if ( finalSegment.StartsWith( "@" ) )
{
// This is an attribute
finalSegment = finalSegment.Substring( 1 );
isAttribute = true;
}
SurrogateSimpleFieldPointer fieldPointer =
new SurrogateSimpleFieldPointer( currentParent, finalSegment, referencedField, isAttribute );
if ( currentParent != null && currentParent is FauxSifElementPointer )
{
((FauxSifElementPointer) currentParent).SetChild( fieldPointer, finalSegment );
}
if ( root == null )
{
root = fieldPointer;
}
return root;
}
public AbstractNodePointer(INodePointer parent)
{
fParentPointer = parent;
}
/// <summary>
/// Creates an instance of SIFXPathNavigator
/// </summary>
/// <param name="context">The SIFXPathContext around this navigator</param>
/// <param name="pointer">The pointer that this navigator initial points to </param>
internal SifXPathNavigator(SifXsltContext context, INodePointer pointer)
{
fParentContext = context;
fNameTable = new NameTable();
fCursor = new RootCursor(pointer);
}
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 FauxSifElementPointer( INodePointer parent, string fauxName )
: base(parent, fauxName, false)
{
}
public RootCursor(INodePointer root)
{
fRoot = root;
}
public FauxSifElementPointer(INodePointer parent, string fauxName)
: base(parent, fauxName, false)
{
}
/// <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 )
{
return null;
}
protected FauxElementPointer( INodePointer parent, String fauxName, bool isAttribute )
: base(parent)
{
fFieldName = fauxName;
fIsAttribute = isAttribute;
}
/// <summary>
/// Called by the ADK XPath traversal code when it is traversing the given element
/// in a legacy version of SIF
/// </summary>
/// <param name="parentPointer">The parent element pointer</param>
/// <param name="element">The Element to create a node pointer for</param>
/// <param name="version">The SIFVersion in effect</param>
/// <returns>A NodePointer representing the current element</returns>
public INodePointer CreateNodePointer(INodePointer parentPointer, Element element, SifVersion version)
{
return(null);
}
private void CreatePredicateValues( INodePointer current, AdkExpression predicate, XsltContext evalContext )
{
if ( predicate is AdkEqualOperation )
{
AdkExpression[] components = ((AdkEqualOperation) predicate).Arguments;
AdkLocPath lp = (AdkLocPath) components[0];
AdkNodeNameTest attrName = (AdkNodeNameTest) lp.Steps[0].NodeTest;
INodePointer attr = current.CreateAttribute( this, attrName.NodeName );
Object value = components[1].ComputeValue( evalContext );
attr.SetValue( value );
return;
}
// This might be the 'adk:x()' function
if ( predicate is AdkAndOperation )
{
foreach ( AdkExpression expr in ((AdkAndOperation) predicate).Arguments )
{
if ( expr is AdkFunction && ((AdkFunction) expr).FunctionName.Equals( "adk:x" ) )
{
// This is the special marker function that tells the ADK to always
// create the parent repeatable element. Don't evaluate it.
continue;
}
else
{
CreatePredicateValues( current, expr, evalContext );
}
}
return;
}
// Unrecognized predicate
throw new ArgumentException( "Cannot evaluate expression predicate: " + predicate );
}
public SingleNodeIterator( INodePointer iteratedItem )
{
fPointer = iteratedItem;
}
public AbstractNodePointer( INodePointer parent )
{
fParentPointer = parent;
}
/// <summary>
/// Creates the specified path and returns a pointer
/// </summary>
/// <param name="xpath"></param>
/// <returns></returns>
public INodePointer CreatePath(String xpath)
{
INodePointer np = BuildADKPathWithPredicates(xpath, fContext);
return(np);
}
private SingleNodeIterator(INodePointer iteratedItem, int position)
{
fPointer = iteratedItem;
fPosition = position;
}
/// <summary>
/// Called by the ADK XPath traversal code when it is traversing the given element
/// in a legacy version of SIF
/// </summary>
/// <param name="parentPointer">The parent element pointer</param>
/// <param name="sourceElement">The Element to create a node pointer for</param>
/// <param name="version">The SIFVersion in effect</param>
/// <returns>A NodePointer representing the current element</returns>
public INodePointer CreateNodePointer( INodePointer parentPointer, Element sourceElement, SifVersion version )
{
// 1) Find the field referenced by the XPathSurrogate expression
// If it doesn't exist, return null
Element referencedField = FindReferencedElement( sourceElement );
if ( referencedField == null )
{
return null;
}
// 2) If it does exist, build out a fake set of node pointers representing the
// SIF 1.5r1 path and return the root pointer.
return BuildLegacyPointers( parentPointer, referencedField );
}
protected FauxElementPointer(INodePointer parent, String fauxName, bool isAttribute) : base(parent)
{
fFieldName = fauxName;
fIsAttribute = isAttribute;
}
/// <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 )
{
// TODO Auto-generated method stub
return null;
}
protected SurrogateElementPointer(INodePointer parent, String fauxName)
: base(parent, fauxName, false)
{
}
public SurrogateSimpleFieldPointer(INodePointer parent, string fauxName, Element pointedNode,
Boolean isAttribute)
: base(parent, fauxName, pointedNode, isAttribute)
{
}
protected SurrogateElementPointer(INodePointer parent, String fauxName, T pointedNode, bool isAttribute)
: base(parent, fauxName, isAttribute)
{
fElement = pointedNode;
}
/// <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)
{
return(null);
}
private NavigableIterator(INodeIterator wrappedIterator, INavCursor parentIterator, INodePointer current)
{
fCurrentIterator = wrappedIterator;
fParentIterator = parentIterator;
fCurrentPointer = current;
}
public FauxAttribute( INodePointer parent, string fauxName, String value )
: base(parent, fauxName, true)
{
fValue = value;
}
public SingleNodeIterator(INodePointer iteratedItem)
{
fPointer = iteratedItem;
}
