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> /// Called on the subclass when a specific NodePointer is requested by SIFXPath /// </summary> /// <param name="parent"></param> /// <param name="element"></param> /// <returns></returns> protected override INodePointer GetNodePointer(SifElementPointer parent, Element element) { if (element is SimpleField) { return(SimpleFieldPointer.Create(parent, (SimpleField)element)); } else { return(SifElementPointer.Create(parent, (SifElement)element, parent.Version)); } }
/// <summary> /// Called on the subclass when a specific NodePointer is requested by SIFXPath /// </summary> /// <param name="parent"></param> /// <param name="element"></param> /// <returns></returns> protected override INodePointer GetNodePointer( SifElementPointer parent, Element element ) { if ( element is SimpleField ) { return SimpleFieldPointer.Create( parent, (SimpleField) element ); } else { return SifElementPointer.Create( parent, (SifElement) element, parent.Version ); } }
public void testFauxAttribute010() { SifElementPointer sep = new SifElementPointer(null, new StudentPersonal(), SifVersion.SIF15r1); FauxAttribute fa = new FauxAttribute(sep, "Type", "Projected"); // Assert base functionality Assert.AreEqual( "Type", fa.Name ); Assert.AreEqual("Projected", fa.Value); Assert.AreEqual(sep, fa.Parent ); // Assert XPath functionality Assert.AreEqual( XPathNodeType.Attribute, fa.NodeType ); }
internal AdkAttributeIterator(SifElementPointer parent) : base(parent) { SifVersion version = parent.Version; SifElement node = (SifElement)parent.Node; // Capture all fields foreach (SimpleField field in node.GetFields()) { IElementDef fieldDef = field.ElementDef; if (fieldDef.IsSupported(version) && fieldDef.IsAttribute(version)) { addNodeToIterate(field); } } }
internal AdkAttributeIterator( SifElementPointer parent ) : base(parent) { SifVersion version = parent.Version; SifElement node = (SifElement) parent.Node; // Capture all fields foreach ( SimpleField field in node.GetFields() ) { IElementDef fieldDef = field.ElementDef; if ( fieldDef.IsSupported( version ) && fieldDef.IsAttribute( version ) ) { addNodeToIterate( field ); } } }
/// <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> /// 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> /// Creates a new NodePointer representing the SimpleField /// </summary> /// <param name="pointerParent"></param> /// <param name="field"></param> /// <returns></returns> public static INodePointer Create( SifElementPointer pointerParent, SimpleField field) { SifVersion version = pointerParent.Version; if (pointerParent.IsLegacyVersion) { IElementDef fieldDef = field.ElementDef; IRenderSurrogate rs = fieldDef.GetVersionInfo(version).GetSurrogate(); if (rs != null) { return(rs.CreateNodePointer(pointerParent, field, version)); } } if (field.ElementDef.IsAttribute(version)) { return(new SimpleFieldAttributePointer(pointerParent, field, version)); } else { return(new SimpleFieldElementPointer(pointerParent, field, version)); } }
/// <summary> /// Creates a new NodePointer representing the SimpleField /// </summary> /// <param name="pointerParent"></param> /// <param name="field"></param> /// <returns></returns> public static INodePointer Create( SifElementPointer pointerParent, SimpleField field ) { SifVersion version = pointerParent.Version; if ( pointerParent.IsLegacyVersion ) { IElementDef fieldDef = field.ElementDef; IRenderSurrogate rs = fieldDef.GetVersionInfo( version ).GetSurrogate(); if ( rs != null ) { return rs.CreateNodePointer( pointerParent, field, version ); } } if ( field.ElementDef.IsAttribute( version ) ) { return new SimpleFieldAttributePointer( pointerParent, field, version ); } else { return new SimpleFieldElementPointer( pointerParent, field, version ); } }
public AdkElementIterator( SifElementPointer parent, IList<Element> nodesToIterate ) : base(parent, nodesToIterate) { }
/// <summary> /// Creates a new instance of ADKNodeIterator /// </summary> /// <param name="parent"></param> /// <param name="nodesToIterate"></param> protected AdkNodeIterator( SifElementPointer parent, IList<Element> nodesToIterate ) { fParent = parent; fChildNodes = nodesToIterate; }
/// <summary> /// Creates a new instance of ADKNodeIterator /// </summary> /// <param name="parent"></param> protected AdkNodeIterator( SifElementPointer parent ) { fParent = parent; fChildNodes = new List<Element>(); }
/// <summary> /// Called on the subclass when a specific NodePointer is requested by SIFXPath /// </summary> /// <param name="parent"></param> /// <param name="element"></param> /// <returns></returns> protected abstract INodePointer GetNodePointer( SifElementPointer parent, Element element );
/// <summary> /// Called on the subclass when a specific NodePointer is requested by SIFXPath /// </summary> /// <param name="parent"></param> /// <param name="element"></param> /// <returns></returns> protected abstract INodePointer GetNodePointer(SifElementPointer parent, Element element);
/// <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); }
public AdkElementIterator(SifElementPointer parent, IList <Element> nodesToIterate) : base(parent, nodesToIterate) { }
/// <summary> /// Creates a new instance of ADKNodeIterator /// </summary> /// <param name="parent"></param> /// <param name="nodesToIterate"></param> protected AdkNodeIterator(SifElementPointer parent, IList <Element> nodesToIterate) { fParent = parent; fChildNodes = nodesToIterate; }
private AdkAttributeIterator( SifElementPointer parent, IList<Element> children ) : base(parent) { fChildNodes = children; }
/// <summary> /// Called on the subclass when a specific NodePointer is requested by SIFXPath /// </summary> /// <param name="parent"></param> /// <param name="element"></param> /// <returns></returns> protected override INodePointer GetNodePointer(SifElementPointer parent, Element element) { return(SimpleFieldPointer.Create(parent, (SimpleField)element)); }
private AdkAttributeIterator(SifElementPointer parent, IList <Element> children) : base(parent) { fChildNodes = children; }
/// <summary> /// Called on the subclass when a specific NodePointer is requested by SIFXPath /// </summary> /// <param name="parent"></param> /// <param name="element"></param> /// <returns></returns> protected override INodePointer GetNodePointer( SifElementPointer parent, Element element ) { return SimpleFieldPointer.Create( parent, (SimpleField) element ); }
/// <summary> /// Creates a new instance of ADKNodeIterator /// </summary> /// <param name="parent"></param> protected AdkNodeIterator(SifElementPointer parent) { fParent = parent; fChildNodes = new List <Element>(); }