public Property(IXPathNavigable path) : base(path) {
// Get Navigator
XPathNavigator navigator = path.CreateNavigator();
// Key
XPathNavigator navigatorKey = navigator.SelectSingleNode("Key");
if (navigatorKey != null) {
this._key = navigatorKey.Value;
}
// Type & Value
XPathNavigator navigatorValue = navigator.SelectSingleNode("Value");
if (navigatorValue == null) {
// Set VALUE to null if the node does not exist
this._value = null;
}
else {
// Type
this._type = navigatorValue.GetAttribute(Xml._TYPE, Xml.XMLSCHEMAINSTANCE);
// Value
if (this._type == "esri:XMLPersistedObject") {
XPathNavigator navigatorBytes = navigatorValue.SelectSingleNode("Bytes");
if (navigatorBytes != null) {
this._value = navigatorBytes.Value;
}
}
else {
this._value = navigatorValue.Value;
}
}
}
public GeometricNetworkControllerMembership(IXPathNavigable path) : base(path) {
// Get Navigator
XPathNavigator navigator = path.CreateNavigator();
// <GeometricNetworkName>Empty_Net</GeometricNetworkName>
XPathNavigator navigatorGeometricNetworkName = navigator.SelectSingleNode("GeometricNetworkName");
if (navigatorGeometricNetworkName != null) {
this._geometricNetworkName = navigatorGeometricNetworkName.Value;
}
// <EnabledFieldName>Enabled</EnabledFieldName>
XPathNavigator navigatorEnabledFieldName = navigator.SelectSingleNode("EnabledFieldName");
if (navigatorEnabledFieldName != null) {
this._enabledFieldName = navigatorEnabledFieldName.Value;
}
// <AncillaryRoleFieldName />
XPathNavigator navigatorAncillaryRoleFieldName = navigator.SelectSingleNode("AncillaryRoleFieldName");
if (navigatorAncillaryRoleFieldName != null) {
this._ancillaryRoleFieldName = navigatorAncillaryRoleFieldName.Value;
}
// <NetworkClassAncillaryRole>esriNCARNone</NetworkClassAncillaryRole>
XPathNavigator navigatorNetworkClassAncillaryRole = navigator.SelectSingleNode("NetworkClassAncillaryRole");
if (navigatorNetworkClassAncillaryRole != null) {
this._networkClassAncillaryRole = (esriNetworkClassAncillaryRole)Enum.Parse(typeof(esriNetworkClassAncillaryRole), navigatorNetworkClassAncillaryRole.Value, true);
}
}
public SubtypeField(IXPathNavigable path) : base(path) {
XPathNavigator navigator = path.CreateNavigator();
// <FieldName></FieldName>
XPathNavigator navigatorFieldName = navigator.SelectSingleNode("FieldName");
if (navigatorFieldName != null) {
this._fieldName = navigatorFieldName.Value;
}
// <DomainName></DomainName>
XPathNavigator navigatorDomainName = navigator.SelectSingleNode("DomainName");
if (navigatorDomainName != null) {
this._domainName = navigatorDomainName.Value;
}
// <DefaultValue></DefaultValue>
XPathNavigator navigatorDefaultValue = navigator.SelectSingleNode("DefaultValue");
if (navigatorDefaultValue != null) {
this._defaultValue = navigatorDefaultValue.Value;
}
// Initialize
this.UpdateText();
// Set Element Properties
this.Image = new Crainiate.ERM4.Image("Resource.publicfield.gif", "Crainiate.ERM4.Component");
}
public static XmlEquivalent To(IXPathNavigable source)
{
if (source == null)
throw new ArgumentNullException("source");
return XmlEquivalent.To(GetElement(source));
}
private void setupTabs(IXPathNavigable data) {
GraphSetupTabPage graphSetupTabPage = null;
TabPage tabPage = null;
for (int i = 0; i < tabCount; i++) {
// graphSetupTabPage
graphSetupTabPage = new GraphSetupTabPage(i, data);
graphSetupTabPage.Location = new System.Drawing.Point(-4, 0);
graphSetupTabPage.Name = "graphSetupTabPage" + i;
graphSetupTabPage.Size = new System.Drawing.Size(332, 200);
graphSetupTabPage.ActivateEvent +=
new GraphSetupTabPage.EventHandler(this.graphSetupTabPage_ActivateEvent);
if (i > 0) //enable only the first tab
graphSetupTabPage.Enabled = false;
// tabPage1
tabPage = new TabPage("Graph " + (i + 1));
tabPage.Controls.Add(graphSetupTabPage);
tabPage.Location = new System.Drawing.Point(4, 22);
tabPage.Name = "tabPage" + i;
tabPage.Padding = new System.Windows.Forms.Padding(3);
tabPage.Size = new System.Drawing.Size(324, 193);
tabPage.TabIndex = i;
tabPage.UseVisualStyleBackColor = true;
this.graphPanel.Controls.Add(tabPage);
}
}
/// <summary>
/// The preferred way to save - this should be a <see cref="System.Xml.XmlDocument" /> straight from CCP.
/// </summary>
/// <param name="filename">The filename.</param>
/// <param name="xdoc">The xml to save.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException"></exception>
public static async Task SaveAsync(string filename, IXPathNavigable xdoc)
{
xdoc.ThrowIfNull(nameof(xdoc));
EveMonClient.EnsureCacheDirInit();
XmlDocument xmlDoc = (XmlDocument)xdoc;
XmlNode characterNode = xmlDoc.SelectSingleNode("//name");
filename = characterNode?.InnerText ?? filename;
// Writes in the target file
string fileName = Path.Combine(EveMonClient.EVEMonXmlCacheDir, $"{filename}.xml");
string content = Util.GetXmlStringRepresentation(xdoc);
await FileHelper.OverwriteOrWarnTheUserAsync(fileName,
async fs =>
{
using (StreamWriter writer = new StreamWriter(fs, Encoding.UTF8))
{
await writer.WriteAsync(content);
await writer.FlushAsync();
await fs.FlushAsync();
}
return true;
});
}
public static void AreXmlEquivalent(string expected, IXPathNavigable actual)
{
if (expected == null) throw new ArgumentNullException("expected");
if (actual == null) throw new ArgumentNullException("actual");
AreXmlEquivalent(GetElement(expected), GetElement(actual));
}
public Index(IXPathNavigable path): base(path) {
// Suspend Events
this.SuspendEvents = true;
// Get Naviagator
XPathNavigator navigator = path.CreateNavigator();
// <Name></Name>
XPathNavigator navigatorIndexName = navigator.SelectSingleNode("Name");
if (navigatorIndexName != null) {
this._name = navigatorIndexName.Value;
}
// <IsUnique></IsUnique>
XPathNavigator navigatorIsUnique = navigator.SelectSingleNode("IsUnique");
if (navigatorIsUnique != null) {
this._isUnique = navigatorIsUnique.ValueAsBoolean;
}
// <IsAscending></IsAscending>
XPathNavigator navigatorIsAscending = navigator.SelectSingleNode("IsAscending");
if (navigatorIsAscending != null) {
this._isAscending = navigatorIsAscending.ValueAsBoolean;
}
// Initialize Text
this.UpdateText();
// Collapse group
this.Expanded = false;
// Resume Events
this.SuspendEvents = false;
}
//
// CONSTRUCTOR
//
//public EdgeFeatureSource() : base() { }
public EdgeFeatureSource(IXPathNavigable path) : base(path) {
// Get Navigator
XPathNavigator navigator = path.CreateNavigator();
// <FromElevationFieldName>
XPathNavigator navigatorFromElevationFieldName = navigator.SelectSingleNode("FromElevationFieldName");
if (navigatorFromElevationFieldName != null) {
this._fromElevationFieldName = navigatorFromElevationFieldName.Value;
}
// <ToElevationFieldName>
XPathNavigator navigatorToElevationFieldName = navigator.SelectSingleNode("ToElevationFieldName");
if (navigatorToElevationFieldName != null) {
this._toElevationFieldName = navigatorToElevationFieldName.Value;
}
// <Connectivity><PropertyArray><PropertySetProperty>
this._connectivity = new List<Property>();
XPathNodeIterator interatorProperty = navigator.Select("Connectivity/PropertyArray/PropertySetProperty");
while (interatorProperty.MoveNext()) {
// Get <Property>
XPathNavigator navigatorProperty = interatorProperty.Current;
// Add Property
Property property = new Property(navigatorProperty);
this._connectivity.Add(property);
}
}
public TopologyControllerMembership(IXPathNavigable path) : base(path) {
// Get Navigator
XPathNavigator navigator = path.CreateNavigator();
// <TopologyName>Landbase_Topology</TopologyName>
XPathNavigator navigatorTopologyName = navigator.SelectSingleNode("TopologyName");
if (navigatorTopologyName != null) {
this._topologyName = navigatorTopologyName.Value;
}
// <Weight>5</Weight>
XPathNavigator navigatorWeight = navigator.SelectSingleNode("Weight");
if (navigatorWeight != null) {
this._weight = navigatorWeight.ValueAsInt;
}
// <XYRank>1</XYRank>
XPathNavigator navigatorXYRank = navigator.SelectSingleNode("XYRank");
if (navigatorXYRank != null) {
this._xyRank = navigatorXYRank.ValueAsInt;
}
// <ZRank>1</ZRank>
XPathNavigator navigatorZRank = navigator.SelectSingleNode("ZRank");
if (navigatorZRank != null) {
this._zRank = navigatorZRank.ValueAsInt;
}
// <EventNotificationOnValidate>false</EventNotificationOnValidate>
XPathNavigator navigatorEventNotificationOnValidate = navigator.SelectSingleNode("EventNotificationOnValidate");
if (navigatorEventNotificationOnValidate != null) {
this._eventNotificationOnValidate = navigatorEventNotificationOnValidate.ValueAsBoolean;
}
}
public RasterDef(IXPathNavigable path) : base(path) {
// Get Navigator
XPathNavigator navigator = path.CreateNavigator();
// <Description></Description>
XPathNavigator navigatorDescription = navigator.SelectSingleNode("Description");
if (navigatorDescription != null) {
this._description = navigatorDescription.Value;
}
// <IsByRef></IsByRef>
XPathNavigator navigatorIsByRef = navigator.SelectSingleNode("IsByRef");
if (navigatorIsByRef != null) {
this._isByRef = navigatorIsByRef.ValueAsBoolean;
}
// <SpatialReference></SpatialReference>
XPathNavigator navigatorSpatialReference = navigator.SelectSingleNode("SpatialReference");
if (navigatorSpatialReference != null) {
this._spatialReference = new SpatialReference(navigatorSpatialReference);
}
else {
this._spatialReference = new SpatialReference();
}
}
public NetWeight(IXPathNavigable path) : base(path) {
// Get Navigator
XPathNavigator navigator = path.CreateNavigator();
// <WeightID>0</WeightID>
XPathNavigator navigatorWeightID = navigator.SelectSingleNode("WeightID");
if (navigatorWeightID != null) {
this._weightID = navigatorWeightID.ValueAsInt;
}
// <WeightName>MMElectricTraceWeight</WeightName>
XPathNavigator navigatorWeightName = navigator.SelectSingleNode("WeightName");
if (navigatorWeightName != null) {
this._weightName = navigatorWeightName.Value;
}
// <WeightType>esriWTInteger</WeightType>
XPathNavigator navigatorWeightType = navigator.SelectSingleNode("WeightType");
if (navigatorWeightType != null) {
this._weightType = (esriWeightType)Enum.Parse(typeof(esriWeightType), navigatorWeightType.Value, true);
}
// <BitGateSize>0</BitGateSize>
XPathNavigator navigatorBitGateSize = navigator.SelectSingleNode("BitGateSize");
if (navigatorBitGateSize != null) {
this._bitGateSize = navigatorBitGateSize.ValueAsInt;
}
}
public void Transform( IXPathNavigable xpnav, TextWriter writer )
{
// NOTE: Not compatable with .NET 1.0.
// xslTransform.Transform(xpnav, null, writer, null);
xslTransform.Transform(xpnav, null, writer);
}
public NetworkAttributeParameter(IXPathNavigable path) : base(path) {
// Get Navigator
XPathNavigator navigator = path.CreateNavigator();
// <Name>
XPathNavigator navigatorName = navigator.SelectSingleNode("Name");
if (navigatorName != null) {
this._name = navigatorName.Value;
}
// <VarType>
XPathNavigator navigatorVarType = navigator.SelectSingleNode("VarType");
if (navigatorVarType != null) {
this._varType = navigatorVarType.ValueAsInt;
}
// <Value>
XPathNavigator navigatorValue = navigator.SelectSingleNode("Value");
if (navigatorValue != null) {
this._value = navigatorValue.Value;
}
// <DefaultValue>
XPathNavigator navigatorDefaultValue = navigator.SelectSingleNode("DefaultValue");
if (navigatorDefaultValue != null) {
this._defaultValue = navigatorDefaultValue.Value;
}
}
public Domain.ErrorCode Validate(IXPathNavigable configSectionNode)
{
log.Debug("Validating the configuration");
lock (syncLock)
{
try
{
isValid = true;
//TODO: is there a better way to do this?
var navigator = configSectionNode.CreateNavigator();
var doc = new XmlDocument();
doc.LoadXml(navigator.OuterXml);
doc.Schemas.Add(Schema);
doc.Validate(ValidationCallback);
if (isValid)
{
log.Debug("The configuration is valid");
}
else
{
log.Error("The configuration is invalid");
}
}
catch (XmlException ex)
{
log.Error("An error occurred when validating the configuration", ex);
isValid = false;
}
return isValid ? Domain.ErrorCode.Ok : Domain.ErrorCode.InvalidConfig;
}
}
public PolicyResponseSummary(string xmlPath)
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(xmlPath);
m_xmlWrapper = xmlDoc as IXPathNavigable;
}
//
// CONSTRUCTOR
//
//public NetworkSourceDirections() : base() { }
public NetworkSourceDirections(IXPathNavigable path) : base(path) {
// Get Navigator
XPathNavigator navigator = path.CreateNavigator();
// <AdminAreaFieldName>
XPathNavigator navigatorAdminAreaFieldName = navigator.SelectSingleNode("AdminAreaFieldName");
if (navigatorAdminAreaFieldName != null) {
this._adminAreaFieldName = navigatorAdminAreaFieldName.Value;
}
// <Shields>
XPathNavigator navigatorShields = navigator.SelectSingleNode("Shields");
if (navigatorShields != null) {
this._shields = new Shields(navigatorShields);
}
else {
this._shields = new Shields();
}
// <StreetNameFields><StreetNameFields>
this._streetNameFields = new List<StreetNameFields>();
XPathNodeIterator interatorStreetNameFields = navigator.Select("StreetNameFields/StreetNameFields");
while (interatorStreetNameFields.MoveNext()) {
// Get <StreetNameFields>
XPathNavigator navigatorStreetNameFields = interatorStreetNameFields.Current;
// Add StreetNameFields
StreetNameFields streetNameFields = new StreetNameFields(navigatorStreetNameFields);
this._streetNameFields.Add(streetNameFields);
}
}
public TerrainPyramid(IXPathNavigable path) : base(path) {
// Get Navigator
XPathNavigator navigator = path.CreateNavigator();
//<PyramidLevelStatus>1</PyramidLevelStatus>
XPathNavigator navigatorPyramidLevelStatus = navigator.SelectSingleNode("PyramidLevelStatus");
if (navigatorPyramidLevelStatus != null) {
this._pyramidLevelStatus = (TerrainElementStatus)Enum.Parse(typeof(TerrainElementStatus), navigatorPyramidLevelStatus.Value, true);
}
//<PointCount>-1</PointCount>
XPathNavigator navigatorPointCount = navigator.SelectSingleNode("PointCount");
if (navigatorPointCount != null) {
this._pointCount = navigatorPointCount.ValueAsInt;
}
//<MaxScale>1000</MaxScale>
XPathNavigator navigatorMaxScale = navigator.SelectSingleNode("MaxScale");
if (navigatorMaxScale != null) {
this._maxScale = navigatorMaxScale.ValueAsInt;
}
//<Resolution>2</Resolution>
XPathNavigator navigatorSourceStatus = navigator.SelectSingleNode("Resolution");
if (navigatorSourceStatus != null) {
this._resolution = navigatorSourceStatus.ValueAsDouble;
}
}
public IResourceActions ReadXml(IXPathNavigable idoc)
{
// Basic check on the input
if (idoc == null)
{
Logger.LogError("XmlResourceReader.ReadXml: null XmlDoc input");
throw new ApplicationException(Properties.Resources.COULD_NOT_READ_RESOURCES);
}
XPathNavigator doc = idoc.CreateNavigator();
XPathNavigator rootNode = doc.SelectSingleNode(@"PolicySetResources");
if (rootNode == null)
{
XmlNode node = new XmlDocument().CreateElement("PolicySetResources");
rootNode = node.CreateNavigator();
doc.AppendChild(rootNode);
}
// Check if the document contains an actions node
XPathNavigator actionsNode = rootNode.SelectSingleNode(@"Actions");
if (actionsNode == null)
{
// No actions already defined in the resources so nothing to read
// Return an empty collection of resource actions
return new ResourceActions();
}
return ReadActions(actionsNode);
}
public Feed(IXPathNavigable navigable)
{
navigator = navigable.CreateNavigator();
manager = new XmlNamespaceManager(navigator.NameTable);
manager.AddNamespace("f", "http://hl7.org/fhir");
manager.AddNamespace("atom", "http://www.w3.org/2005/Atom");
}
//
// CONSTRUCTOR
//
public Subtype(IXPathNavigable path) : base(path) {
// Get Navigator
XPathNavigator navigator = path.CreateNavigator();
// <SubtypeName>
XPathNavigator navigatorSubtypeName = navigator.SelectSingleNode("SubtypeName");
if (navigatorSubtypeName != null) {
this._subtypeName = navigatorSubtypeName.Value;
}
// <SubtypeCode>
XPathNavigator navigatorSubtypeCode = navigator.SelectSingleNode("SubtypeCode");
if (navigatorSubtypeCode != null) {
this._subtypeCode = navigatorSubtypeCode.ValueAsInt;
}
// <FieldInfos><SubtypeFieldInfo>
XPathNodeIterator interatorSubtypeFieldInfo = navigator.Select("FieldInfos/SubtypeFieldInfo");
while (interatorSubtypeFieldInfo.MoveNext()) {
// Create Field
XPathNavigator navigatorSubtypeFieldInfo = interatorSubtypeFieldInfo.Current;
SubtypeField subtypeField = new SubtypeField(navigatorSubtypeFieldInfo);
// Add Field To Group
this.Rows.Add(subtypeField);
}
// Refresh
this.Refresh();
}
//
// CONSTRUCTOR
//
public DomainRange(IXPathNavigable path): base(path) {
//
XPathNavigator navigator = path.CreateNavigator();
// Add Min/Max Row
DomainRangeRow row = new DomainRangeRow(navigator);
this.Rows.Add(row);
}
/// <summary>
/// Persists the license document to local storage.
/// </summary>
/// <param name="licenseDocument">The license document to store.</param>
public void Save(IXPathNavigable licenseDocument)
{
if (licenseDocument == null)
{
throw new ArgumentNullException("licenseDocument");
}
((XmlDocument)licenseDocument).Save(_path);
}
/// <summary>
/// Factory method for creating new instances of AuthorizationMap.
/// </summary>
/// <param name="xmlDocument">The XML document.</param>
/// <returns></returns>
public static AuthorizationMap FromXml(IXPathNavigable xmlDocument)
{
var map = new AuthorizationMap();
XmlElement root = ((XmlDocument)xmlDocument).DocumentElement;
map.AddAuthorizationsFromXml(root, "/Authorizations/WebParts/WebPart", "className");
map.AddAuthorizationsFromXml(root, "/Authorizations/NamedBehaviors/NamedBehavior", "name");
return map;
}
public FormAddNode(IXPathNavigable node, Office.CustomXMLPart part)
{
InitializeComponent();
//set up state
m_xn = node as XmlNode;
m_cxp = part;
}
private async Task TransformAsync(IRequestContext context, IXPathNavigable xml)
{
using (var writer = context.Response.GetStreamWriter())
using (var xWriter = new XmlTextWriter(writer)) {
Xslt.Transform(xml, XsltArgs ?? new XsltArgumentList(), xWriter);
await xWriter.FlushAsync();
}
}
public void Load(IXPathNavigable stylesheet, XmlResolver resolver)
{
if (stylesheet == null)
{
throw new ArgumentNullException(nameof(stylesheet));
}
Load(stylesheet.CreateNavigator(), resolver);
}
public XPathDataRow(XPathDataRowRule rule, IXPathNavigable row, Uri uri, int rowIndex, int pageIndex)
{
this.rule = rule;
this.row = row;
this.PageUri = uri;
this.RowIndex = rowIndex;
this.PageIndex = pageIndex;
}
/// <summary>
/// Determines if the XmlDocument has a valid signature.
/// </summary>
/// <param name="xmlDocument">The XmlDocument to check.</param>
/// <returns>True if the document has a valid signature.</returns>
public bool HasValidSignature(IXPathNavigable xmlDocument)
{
var signedXml = ExtractSignature(xmlDocument as XmlDocument);
using (var key = GetPublicKeyAlgorithm())
{
return signedXml.CheckSignature(key);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ReBugContext"/> class.
/// </summary>
/// <param name="bug">The bug.</param>
protected ReBugContext(IXPathNavigable bug)
{
XPathNavigator xml = bug.CreateNavigator();
_QueryString = HttpValueCollection.CreateCollectionFromXmlNode(xml.SelectSingleNode("/bugx/queryString"));
_Form = HttpValueCollection.CreateCollectionFromXmlNode(xml.SelectSingleNode("/bugx/form"));
XPathNavigator cookie = xml.SelectSingleNode("/bugx/headers/Cookie");
if (cookie != null)
{
_Cookies = HttpValueCollection.CreateCollectionFromCookieHeader(cookie.Value);
}
_Headers = HttpValueCollection.CreateCollectionFromXmlNode(xml.SelectSingleNode("/bugx/headers"));
_Session = FillNameValue(xml.Select("/bugx/sessionVariables/add"));
_Cache = FillNameValue(xml.Select("/bugx/cacheVariables/add"));
_Application = FillNameValue(xml.Select("/bugx/applicationVariables/add"));
_Context = FillHashtable(xml.Select("/bugx/contextVariables/add"));
XPathNavigator exception = xml.SelectSingleNode("/bugx/exception");
if (exception != null)
{
try
{
_Exception = (Exception)BugSerializer.Deserialize(exception.Value);
}catch(SerializationException){}
}
XPathNavigator url = xml.SelectSingleNode("/bugx/url");
if (url != null)
{
_Url = new Uri(url.Value);
}
XPathNavigator pathInfo = xml.SelectSingleNode("/bugx/pathInfo");
if (pathInfo != null)
{
_PathInfo = pathInfo.Value;
}
XPathNavigator machineName = xml.SelectSingleNode("/bugx/machineName");
if (machineName != null)
{
_MachineName = machineName.Value;
}
XPathNavigator scriptTimeout = xml.SelectSingleNode("/bugx/scriptTimeout");
if (scriptTimeout != null)
{
_ScriptTimeout = Convert.ToInt32(scriptTimeout.Value, CultureInfo.InvariantCulture);
}
XPathNavigator user = xml.SelectSingleNode("/bugx/user");
if (user != null)
{
try
{
_User = (IPrincipal)BugSerializer.Deserialize(user.Value);
}
catch(SerializationException){}
catch(TargetInvocationException){}
}
}
public static XdmNode ToXdmNode(this IXPathNavigable value, SaxonItemFactory itemFactory) {
if (value == null) throw new ArgumentNullException("value");
return ToXdmNode(value.CreateNavigator(), itemFactory);
}
protected object ProcessResult(object value)
{
if (value is string)
{
return(value);
}
if (value is double)
{
return(value);
}
if (value is bool)
{
return(value);
}
if (value is XPathNavigator)
{
return(value);
}
if (value is int)
{
return((double)(int)value);
}
if (value == null)
{
_queryIterator = XPathEmptyIterator.Instance;
return(this); // We map null to NodeSet to let $null/foo work well.
}
ResetableIterator resetable = value as ResetableIterator;
if (resetable != null)
{
// We need Clone() value because variable may be used several times
// and they shouldn't
_queryIterator = (ResetableIterator)resetable.Clone();
return(this);
}
XPathNodeIterator nodeIterator = value as XPathNodeIterator;
if (nodeIterator != null)
{
_queryIterator = new XPathArrayIterator(nodeIterator);
return(this);
}
IXPathNavigable navigable = value as IXPathNavigable;
if (navigable != null)
{
return(navigable.CreateNavigator());
}
if (value is short)
{
return((double)(short)value);
}
if (value is long)
{
return((double)(long)value);
}
if (value is uint)
{
return((double)(uint)value);
}
if (value is ushort)
{
return((double)(ushort)value);
}
if (value is ulong)
{
return((double)(ulong)value);
}
if (value is float)
{
return((double)(float)value);
}
if (value is decimal)
{
return((double)(decimal)value);
}
return(value.ToString());
}
/// <summary>
/// Initializes a new instance of the class from the specified XML node.
/// </summary>
/// <param name="node">The XML node to initialize from.</param>
/// <param name="builtIn">The value indicating whether the element is built-in.</param>
public ActionElement(IXPathNavigable node, bool builtIn)
: base(node)
{
m_BuiltIn = builtIn;
}
public static IList <XmlScheme> GetXmlTree(IXPathNavigable inputNode, int loopdeep, int outdeep, string xpath, int outype, int stat)
{
IList <XmlScheme> list = new List <XmlScheme>();
if ((outdeep == 0) || (outdeep > 100))
{
outdeep = 100;
}
if (loopdeep < outdeep)
{
System.Xml.XmlNode node = (System.Xml.XmlNode)inputNode;
int num = loopdeep;
num++;
XmlScheme item = new XmlScheme();
item.Level = loopdeep;
item.Station = stat;
item.Path = xpath;
item.Name = node.Name;
item.Text = node.InnerText;
if (!node.HasChildNodes)
{
item.Type = "onlyone";
list.Add(item);
return(list);
}
XmlNodeList childNodes = node.ChildNodes;
IList <System.Xml.XmlNode> list3 = new List <System.Xml.XmlNode>();
bool flag = false;
foreach (System.Xml.XmlNode node2 in childNodes)
{
if (string.Compare(node2.GetType().Name, "XmlElement", StringComparison.OrdinalIgnoreCase) != 0)
{
continue;
}
flag = true;
bool flag2 = false;
if (outype > 0)
{
foreach (System.Xml.XmlNode node3 in list3)
{
if (string.Compare(node3.Name, node2.Name, StringComparison.OrdinalIgnoreCase) == 0)
{
XmlElement element = (XmlElement)node3;
element.SetAttribute("pe_tempshownum", (Convert.ToInt32(element.GetAttribute("pe_tempshownum")) + 1).ToString());
flag2 = true;
}
}
}
if (!flag2)
{
((XmlElement)node2).SetAttribute("pe_tempshownum", "1");
list3.Add(node2);
}
}
if (flag)
{
item.Type = "havechile";
}
else
{
item.Type = "nochile";
}
XmlElement element3 = (XmlElement)node;
if (element3.HasAttribute("pe_tempshownum"))
{
item.Repnum = Convert.ToInt32(element3.GetAttribute("pe_tempshownum").ToString());
}
list.Add(item);
foreach (System.Xml.XmlNode node4 in list3)
{
int num3 = 0;
if (list3.IndexOf(node4) == 0)
{
num3 = 1;
}
else if (list3.IndexOf(node4) == (list3.Count - 1))
{
num3 = 2;
}
if (string.Compare(node4.Name, "#text", StringComparison.OrdinalIgnoreCase) > 0)
{
string str = xpath + "/" + node.Name;
foreach (XmlScheme scheme2 in GetXmlTree(node4, num, outdeep, str, outype, num3))
{
list.Add(scheme2);
}
continue;
}
}
}
return(list);
}
// SxS: This method does not take any resource name and does not expose any resources to the caller.
// It's OK to suppress the SxS warning.
public void Load(IXPathNavigable stylesheet)
{
Reset();
LoadInternal(stylesheet, XsltSettings.Default, CreateDefaultResolver());
}
protected object ProcessResult(object value)
{
if (value is string)
{
return(value);
}
if (value is double)
{
return(value);
}
if (value is bool)
{
return(value);
}
if (value is XPathNavigator)
{
return(value);
}
if (value is Int32)
{
return((double)(Int32)value);
}
if (value == null)
{
queryIterator = XPathEmptyIterator.Instance;
return(this); // We map null to NodeSet to let $null/foo work well.
}
ResetableIterator resetable = value as ResetableIterator;
if (resetable != null)
{
// We need Clone() value because variable may be used several times
// and they shouldn't
queryIterator = (ResetableIterator)resetable.Clone();
return(this);
}
XPathNodeIterator nodeIterator = value as XPathNodeIterator;
if (nodeIterator != null)
{
queryIterator = new XPathArrayIterator(nodeIterator);
return(this);
}
IXPathNavigable navigable = value as IXPathNavigable;
if (navigable != null)
{
return(navigable.CreateNavigator());
}
if (value is Int16)
{
return((double)(Int16)value);
}
if (value is Int64)
{
return((double)(Int64)value);
}
if (value is UInt32)
{
return((double)(UInt32)value);
}
if (value is UInt16)
{
return((double)(UInt16)value);
}
if (value is UInt64)
{
return((double)(UInt64)value);
}
if (value is Single)
{
return((double)(Single)value);
}
if (value is Decimal)
{
return((double)(Decimal)value);
}
return(value.ToString());
}
//
// CONSTRUCTOR
//
public NetworkAssignment(IXPathNavigable path) : base(path)
{
// Get Navigator
XPathNavigator navigator = path.CreateNavigator();
// <IsDefault>
XPathNavigator navigatorIsDefault = navigator.SelectSingleNode("IsDefault");
if (navigatorIsDefault != null)
{
this._isDefault = navigatorIsDefault.ValueAsBoolean;
}
// <ID>
XPathNavigator navigatorID = navigator.SelectSingleNode("ID");
if (navigatorID != null)
{
this._id = navigatorID.ValueAsInt;
}
// <NetworkAttributeName>
XPathNavigator navigatorNetworkAttributeName = navigator.SelectSingleNode("NetworkAttributeName");
if (navigatorNetworkAttributeName != null)
{
this._networkAttributeName = navigatorNetworkAttributeName.Value;
}
// <NetworkElementType>
XPathNavigator navigatorNetworkElementType = navigator.SelectSingleNode("NetworkElementType");
if (navigatorNetworkElementType != null)
{
this._networkElementType = (esriNetworkElementType)Enum.Parse(typeof(esriNetworkElementType), navigatorNetworkElementType.Value, true);
}
// <NetworkSourceName>
XPathNavigator navigatorNetworkSourceName = navigator.SelectSingleNode("NetworkSourceName");
if (navigatorNetworkSourceName != null)
{
this._networkSourceName = navigatorNetworkSourceName.Value;
}
// <NetworkEvaluatorCLSID>
XPathNavigator navigatorNetworkEvaluatorCLSID = navigator.SelectSingleNode("NetworkEvaluatorCLSID");
if (navigatorNetworkEvaluatorCLSID != null)
{
this._networkEvaluatorCLSID = navigatorNetworkEvaluatorCLSID.Value;
}
// <NetworkEdgeDirection>
XPathNavigator navigatorNetworkEdgeDirection = navigator.SelectSingleNode("NetworkEdgeDirection");
if (navigatorNetworkEdgeDirection != null)
{
this._networkEdgeDirection = (esriNetworkEdgeDirection)Enum.Parse(typeof(esriNetworkEdgeDirection), navigatorNetworkEdgeDirection.Value, true);
}
// <NetworkEvaluatorData><PropertyArray><PropertySetProperty>
this._networkEvaluatorData = new List <Property>();
XPathNodeIterator interatorProperty = navigator.Select("NetworkEvaluatorData/PropertyArray/PropertySetProperty");
while (interatorProperty.MoveNext())
{
// Get <PropertySetProperty>
XPathNavigator navigatorProperty = interatorProperty.Current;
// Add PropertySetProperty
Property property = new Property(navigatorProperty);
this._networkEvaluatorData.Add(property);
}
}
/// <summary>
/// Pravi proizvoljan query
/// </summary>
/// <param name="__xPath"></param>
/// <param name="__source"></param>
public xPathQueryCache(String __xPath, IXPathNavigable __source)
{
basic(__xPath, __source);
}
/// <summary>
/// Handles the Load event of the Page control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
protected void Page_Load(object sender, EventArgs e)
{
DataTable dt = new DataTable();
dt.Columns.Add(new DataColumn("Title", typeof(string)));
dt.Columns.Add(new DataColumn("ImageUrl", typeof(string)));
DataRow dr;
IXPathNavigable navigable = XmlBuilder.GetXml(StructureType.Navigation);
XPathNavigator tabs = navigable.CreateNavigator().SelectSingleNode("Navigation/Tabs");
foreach (XPathNavigator tabItem in tabs.SelectChildren(string.Empty, string.Empty))
{
dr = dt.NewRow();
string title = UtilHelper.GetResFileString(tabItem.GetAttribute("text", string.Empty));
string id = tabItem.GetAttribute("id", string.Empty);
CommandParameters param = new CommandParameters(id);
param.CommandArguments = new Dictionary <string, string>();
param.CommandArguments.Add("permissions", tabItem.GetAttribute("permissions", string.Empty));
string enableHandler = String.Empty;
if (!ProfileConfiguration.Instance.EnablePermissions)
{
enableHandler = tabItem.GetAttribute("enableHandler", string.Empty);
}
else
{
enableHandler = tabItem.GetAttribute("enableHandler2", string.Empty);
}
if (!String.IsNullOrEmpty(enableHandler))
{
ICommandEnableHandler enHandler = (ICommandEnableHandler)AssemblyUtil.LoadObject(enableHandler);
if (enHandler != null && !enHandler.IsEnable(sender, param))
{
continue;
}
}
string imageUrl = tabItem.GetAttribute("imageUrl", string.Empty);
if (String.IsNullOrEmpty(imageUrl))
{
imageUrl = "~/App_Themes/Default/Images/ext/default/s.gif";
}
string type = tabItem.GetAttribute("contentType", string.Empty).ToLower();
if (String.IsNullOrEmpty(type))
{
type = "default";
}
string configUrl = tabItem.GetAttribute("configUrl", string.Empty);
string checkUrl = configUrl;
if (checkUrl.IndexOf("?") >= 0)
{
checkUrl = checkUrl.Substring(0, checkUrl.IndexOf("?"));
}
if (type.Equals("default") && String.IsNullOrEmpty(checkUrl))
{
checkUrl = "~/Apps/Shell/Pages/TreeSource.aspx";
configUrl = "~/Apps/Shell/Pages/TreeSource.aspx?tab=" + id;
}
if (File.Exists(Server.MapPath(checkUrl)))
{
switch (type)
{
case "default":
ClientScript.RegisterStartupScript(this.Page, this.Page.GetType(), Guid.NewGuid().ToString("N"), String.Format("leftTemplate_ECFAddMenuTab('{0}', '{1}', '{2}');", id, title, ResolveClientUrl(configUrl)), true);
break;
case "custom":
break;
default:
break;
}
}
dr["Title"] = title;
dr["ImageUrl"] = imageUrl;
dt.Rows.Add(dr);
}
TabItems.DataSource = dt.DefaultView;
TabItems.DataBind();
RegisterScripts();
//Register navigation commands
IList <XmlCommand> list = XmlCommand.GetListNavigationCommands("", "", "");
CommandManager cm = CommandManager.GetCurrent(this.Page);
foreach (XmlCommand cmd in list)
{
cm.AddCommand("", "", "", cmd.CommandName);
}
}
public void Transform(IXPathNavigable input, XsltArgumentList arguments, XmlWriter results)
{
CheckArguments(input, results);
Transform(input, arguments, results, CreateDefaultResolver());
}
private static void CheckFieldNames(IXPathNavigable xml)
{
XPathNavigator rootNav = xml.CreateNavigator();
XmlNamespaceManager nsmgr = new XmlNamespaceManager(rootNav.NameTable);
nsmgr.AddNamespace("x", ContentDefinitionXmlNamespace);
XPathNodeIterator x = rootNav.Select("/x:ContentType", nsmgr);
x.MoveNext();
XPathNavigator rootNode = x.Current;
string ctdName = rootNode.GetAttribute("name", "");
List <string> allBindings = new List <string>();
foreach (XPathNavigator fieldNode in rootNav.Select("//x:Field", nsmgr))
{
string name = fieldNode.GetAttribute("name", "");
List <string> bindings = new List <string>();
foreach (XPathNavigator bindNode in fieldNode.Select("x:Bind", nsmgr))
{
string property = bindNode.GetAttribute("property", "");
bindings.Add(property);
}
if (bindings.Count == 0)
{
bindings.Add(name);
}
allBindings.AddRange(bindings);
}
Dictionary <string, string> names = new Dictionary <string, string>();
foreach (string name in allBindings)
{
if (names.ContainsKey(name.ToLower()))
{
if (names[name.ToLower()] != name)
{
throw new RegistrationException(String.Concat(
SR.Exceptions.Registration.Msg_InvalidContentTypeDefinitionXml, ": '", ctdName, "'. ",
"Two Field or Binding names are case insensitive equal, but case sensitive they are not equal: '", names[name.ToLower()], "' != '", name, "'"));
}
}
else
{
names.Add(name.ToLower(), name);
}
}
foreach (PropertyType propType in ActiveSchema.PropertyTypes)
{
string newName;
if (names.TryGetValue(propType.Name.ToLower(), out newName))
{
if (propType.Name != newName)
{
throw new RegistrationException(String.Concat(
SR.Exceptions.Registration.Msg_InvalidContentTypeDefinitionXml, ": '", ctdName, "'. ",
"A Field or Binding name and an existing RepositoryProperty name are case insensitive equal, but case sensitive they are not equal: '", propType.Name,
"', Field or Binding name: '", newName, "'"));
}
}
}
}
/// <summary>
/// Signs the specified xml document with the certificate found in
/// the local machine matching the provided friendly name and
/// referring to the specified target reference ID.
/// </summary>
/// <param name="certFriendlyName">
/// Friendly Name of the X509Certificate to be retrieved
/// from the LocalMachine keystore and used to sign the xml document.
/// Be sure to have appropriate permissions set on the keystore.
/// </param>
/// <param name="xmlDoc">
/// XML document to be signed.
/// </param>
/// <param name="targetReferenceId">
/// Reference element that will be specified as signed.
/// </param>
/// <param name="includePublicKey">
/// Flag to determine whether to include the public key in the
/// signed xml.
/// </param>
public static void SignXml(string certFriendlyName, IXPathNavigable xmlDoc, string targetReferenceId, bool includePublicKey)
{
if (string.IsNullOrEmpty(certFriendlyName))
{
throw new Saml2Exception(Resources.SignedXmlInvalidCertFriendlyName);
}
if (xmlDoc == null)
{
throw new Saml2Exception(Resources.SignedXmlInvalidXml);
}
if (string.IsNullOrEmpty(targetReferenceId))
{
throw new Saml2Exception(Resources.SignedXmlInvalidTargetRefId);
}
X509Certificate2 cert = FedletCertificateFactory.GetCertificateByFriendlyName(certFriendlyName);
if (cert == null)
{
throw new Saml2Exception(Resources.SignedXmlCertNotFound);
}
XmlDocument xml = (XmlDocument)xmlDoc;
SignedXml signedXml = new SignedXml(xml);
signedXml.SigningKey = cert.PrivateKey;
if (includePublicKey)
{
KeyInfo keyInfo = new KeyInfo();
keyInfo.AddClause(new KeyInfoX509Data(cert));
signedXml.KeyInfo = keyInfo;
}
Reference reference = new Reference();
reference.Uri = "#" + targetReferenceId;
XmlDsigEnvelopedSignatureTransform envelopSigTransform = new XmlDsigEnvelopedSignatureTransform();
reference.AddTransform(envelopSigTransform);
signedXml.AddReference(reference);
signedXml.ComputeSignature();
XmlElement xmlSignature = signedXml.GetXml();
XmlNamespaceManager nsMgr = new XmlNamespaceManager(xml.NameTable);
nsMgr.AddNamespace("ds", SignedXml.XmlDsigNamespaceUrl);
nsMgr.AddNamespace("saml", Saml2Constants.NamespaceSamlAssertion);
nsMgr.AddNamespace("samlp", Saml2Constants.NamespaceSamlProtocol);
XmlNode issuerNode = xml.DocumentElement.SelectSingleNode("saml:Issuer", nsMgr);
if (issuerNode != null)
{
xml.DocumentElement.InsertAfter(xmlSignature, issuerNode);
}
else
{
// Insert as a child to the target reference id
XmlNode targetNode = xml.DocumentElement.SelectSingleNode("//*[@ID='" + targetReferenceId + "']", nsMgr);
targetNode.PrependChild(xmlSignature);
}
}
/// <summary>
/// Populates this <see cref="BasicV2"/> instance from the data in the XML.
/// </summary>
///
/// <param name="typeSpecificXml">
/// The XML to get the basic data from.
/// </param>
///
/// <exception cref="InvalidOperationException">
/// The first node in <paramref name="typeSpecificXml"/> is not
/// a basic node.
/// </exception>
///
protected override void ParseXml(IXPathNavigable typeSpecificXml)
{
XPathNavigator basicNav =
typeSpecificXml.CreateNavigator().SelectSingleNode("basic");
Validator.ThrowInvalidIfNull(basicNav, Resources.BasicUnexpectedNode);
XPathNavigator genderNav =
basicNav.SelectSingleNode("gender");
if (genderNav != null)
{
string genderString = genderNav.Value;
if (string.Equals(
genderString,
"m",
StringComparison.Ordinal))
{
_gender = ItemTypes.Gender.Male;
}
else if (
string.Equals(
genderString,
"f",
StringComparison.Ordinal))
{
_gender = ItemTypes.Gender.Female;
}
else
{
_gender = ItemTypes.Gender.Unknown;
}
}
_birthYear = XPathHelper.GetOptNavValueAsInt(basicNav, "birthyear");
_country = XPathHelper.GetOptNavValue <CodableValue>(basicNav, "country");
_postalCode = XPathHelper.GetOptNavValue(basicNav, "postcode");
_city = XPathHelper.GetOptNavValue(basicNav, "city");
_stateOrProvince =
XPathHelper.GetOptNavValue <CodableValue>(basicNav, "state");
XPathNavigator dayOfWeekNav =
basicNav.SelectSingleNode("firstdow");
if (dayOfWeekNav != null)
{
_firstDayOfWeek = (DayOfWeek)(dayOfWeekNav.ValueAsInt - 1);
}
XPathNodeIterator languageIterator =
basicNav.Select("language");
if (languageIterator != null)
{
foreach (XPathNavigator languageNav in languageIterator)
{
Language newLanguage = new Language();
newLanguage.ParseXml(languageNav);
_languages.Add(newLanguage);
}
}
}
/// <summary>
/// Process XML document.
/// </summary>
/// <typeparam name="T">The type to deserialize from the document</typeparam>
/// <param name="transform">The XSL transformation to apply. May be <c>null</c>.</param>
/// <param name="doc">The XML document to deserialize from.</param>
/// <returns>The result of the deserialization.</returns>
private static CCPAPIResult <T> DeserializeAPIResultCore <T>(IXPathNavigable doc, XslCompiledTransform transform = null)
{
CCPAPIResult <T> result;
try
{
// Deserialization with a transform
using (XmlNodeReader reader = new XmlNodeReader((XmlDocument)doc))
{
XmlSerializer xs = new XmlSerializer(typeof(CCPAPIResult <T>));
if (transform != null)
{
MemoryStream stream = GetMemoryStream();
using (XmlTextWriter writer = new XmlTextWriter(stream, Encoding.UTF8))
{
// Apply the XSL transform
writer.Formatting = Formatting.Indented;
transform.Transform(reader, writer);
writer.Flush();
// Deserialize from the given stream
stream.Seek(0, SeekOrigin.Begin);
result = (CCPAPIResult <T>)xs.Deserialize(stream);
}
}
// Deserialization without transform
else
{
result = (CCPAPIResult <T>)xs.Deserialize(reader);
}
}
// Fix times
if (result.Result is ISynchronizableWithLocalClock)
{
DateTime requestTime = DateTime.UtcNow;
double offsetCCP = result.CurrentTime.Subtract(requestTime).TotalMilliseconds;
result.SynchronizeWithLocalClock(offsetCCP);
}
}
// An error occurred during the XSL transform
catch (XsltException exc)
{
ExceptionHandler.LogException(exc, true);
result = new CCPAPIResult <T>(exc);
}
// An error occurred during the deserialization
catch (InvalidOperationException exc)
{
ExceptionHandler.LogException(exc, true);
result = new CCPAPIResult <T>(exc);
}
catch (XmlException exc)
{
ExceptionHandler.LogException(exc, true);
result = new CCPAPIResult <T>(exc);
}
// Stores XMLDocument
result.XmlDocument = doc;
return(result);
}
/// <summary>
/// Validates a signed xml document with the given certificate,
/// the xml signature, and the target reference id.
/// </summary>
/// <param name="cert">
/// X509Certificate used to verify the signature of the xml document.
/// </param>
/// <param name="xmlDoc">
/// XML document whose signature will be checked.
/// </param>
/// <param name="xmlSignature">Signature of the XML document.</param>
/// <param name="targetReferenceId">
/// Reference element that should be signed.
/// </param>
public static void ValidateSignedXml(X509Certificate2 cert, IXPathNavigable xmlDoc, IXPathNavigable xmlSignature, string targetReferenceId)
{
SignedXml signedXml = new SignedXml((XmlDocument)xmlDoc);
signedXml.LoadXml((XmlElement)xmlSignature);
bool results = signedXml.CheckSignature(cert, true);
if (results == false)
{
throw new Saml2Exception(Resources.SignedXmlCheckSignatureFailed);
}
bool foundValidSignedReference = false;
foreach (Reference r in signedXml.SignedInfo.References)
{
string referenceId = r.Uri.Substring(1);
if (referenceId == targetReferenceId)
{
foundValidSignedReference = true;
}
}
if (!foundValidSignedReference)
{
throw new Saml2Exception(Resources.SignedXmlInvalidReference);
}
}
public int TransformResolver(string szXmlFile, XmlResolver xr, bool errorCase, TransformType transformType, DocType docType)
{
lock (s_outFileMemoryLock)
{
szXmlFile = FullFilePath(szXmlFile);
_output.WriteLine("Loading XML {0}", szXmlFile);
IXPathNavigable xd = LoadXML(szXmlFile, docType);
_output.WriteLine("Executing transform");
xrXSLT = null;
Stream strmTemp = null;
switch (transformType)
{
case TransformType.Reader:
xrXSLT = xslt.Transform(xd, null, xr);
using (FileStream outFile = new FileStream(_strOutFile, FileMode.Create, FileAccess.ReadWrite))
using (XmlWriter writer = XmlWriter.Create(outFile))
{
writer.WriteNode(xrXSLT, true);
}
if (errorCase)
{
try
{
while (xrXSLT.Read())
{
}
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (xrXSLT != null)
{
xrXSLT.Dispose();
}
}
}
break;
case TransformType.Stream:
try
{
strmTemp = new FileStream(_strOutFile, FileMode.Create, FileAccess.ReadWrite);
xslt.Transform(xd, null, strmTemp, xr);
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (strmTemp != null)
{
strmTemp.Dispose();
}
}
break;
case TransformType.Writer:
XmlWriter xw = null;
try
{
xw = new XmlTextWriter(_strOutFile, Encoding.UTF8);
xw.WriteStartDocument();
xslt.Transform(xd, null, xw, xr);
}
catch (Exception ex)
{
throw (ex);
}
finally
{
if (xw != null)
{
xw.Dispose();
}
}
break;
case TransformType.TextWriter:
TextWriter tw = null;
try
{
using (FileStream outFile = new FileStream(_strOutFile, FileMode.Create, FileAccess.Write))
{
tw = new StreamWriter(outFile, Encoding.UTF8);
xslt.Transform(xd, null, tw, xr);
}
}
catch (Exception ex)
{
throw (ex);
}
break;
}
return(1);
}
}
//
// CONSTRUCTOR
//
public EvaluatedNetworkAttribute(IXPathNavigable path) : base(path)
{
}
// SxS: This method does not take any resource name and does not expose any resources to the caller.
// It's OK to suppress the SxS warning.
public void Load(IXPathNavigable stylesheet)
{
Reset();
LoadInternal(stylesheet, XsltSettings.Default, XmlNullResolver.Singleton);
}
/// <summary>
/// Initializes a new instance of the class from the specified XML node.
/// </summary>
/// <param name="node">The XML node to initialize from.</param>
public SupportElement(IXPathNavigable node) : base(node)
{
}
// SxS: This method does not take any resource name and does not expose any resources to the caller.
// It's OK to suppress the SxS warning.
public void Load(IXPathNavigable stylesheet, XsltSettings settings, XmlResolver stylesheetResolver)
{
Reset();
LoadInternal(stylesheet, settings, stylesheetResolver);
}
/// <summary>
/// Initializes a new instance of the class from the specified XML node.
/// </summary>
/// <param name="node">The XML node to initialize from.</param>
public ActionElement(IXPathNavigable node) : base(node)
{
}
public void Transform(IXPathNavigable input, XsltArgumentList arguments, XmlWriter results)
{
CheckArguments(input, results);
Transform(input, arguments, results, XmlNullResolver.Singleton);
}
// SxS: This method does not take any resource name and does not expose any resources to the caller.
// It's OK to suppress the SxS warning.
public void Transform(IXPathNavigable input, XsltArgumentList arguments, XmlWriter results, XmlResolver documentResolver)
{
CheckArguments(input, results);
CheckCommand();
_command.Execute((object)input.CreateNavigator(), documentResolver, arguments, results);
}
public XPathAdapter(IXPathNavigable source)
{
Source = source;
Context = new XPathContext();
root = source.CreateNavigator();
}
/// <summary>
/// Initializes a new instance of the class from the specified XML node.
/// </summary>
/// <param name="node">The XML node to initialize from.</param>
public WebsiteConfiguration(IXPathNavigable node) : base(node)
{
}
//
// CONSTRUCTOR
//
public NetworkAttribute(IXPathNavigable path) : base(path)
{
// Get Navigator
XPathNavigator navigator = path.CreateNavigator();
// <ID>
XPathNavigator navigatorID = navigator.SelectSingleNode("ID");
if (navigatorID != null)
{
this._id = navigatorID.ValueAsInt;
}
// <Name>
XPathNavigator navigatorName = navigator.SelectSingleNode("Name");
if (navigatorName != null)
{
this._name = navigatorName.Value;
}
// <Units>
XPathNavigator navigatorUnits = navigator.SelectSingleNode("Units");
if (navigatorUnits != null)
{
this._units = GeodatabaseUtility.GetNetworkAttributeUnits(navigatorUnits.Value);
}
// <DataType>
XPathNavigator navigatorDataType = navigator.SelectSingleNode("DataType");
if (navigatorDataType != null)
{
this._dataType = (esriNetworkAttributeDataType)Enum.Parse(typeof(esriNetworkAttributeDataType), navigatorDataType.Value, true);
}
// <UsageType>
XPathNavigator navigatorUsageType = navigator.SelectSingleNode("UsageType");
if (navigatorUsageType != null)
{
this._usageType = (esriNetworkAttributeUsageType)Enum.Parse(typeof(esriNetworkAttributeUsageType), navigatorUsageType.Value, true);
}
// <UserData><PropertyArray><PropertySetProperty>
this._userData = new List <Property>();
XPathNodeIterator interatorProperty = navigator.Select("UserData/PropertyArray/PropertySetProperty");
while (interatorProperty.MoveNext())
{
// Get <PropertySetProperty>
XPathNavigator navigatorProperty = interatorProperty.Current;
// Add PropertySetProperty
Property property = new Property(navigatorProperty);
this._userData.Add(property);
}
// <UseByDefault>
XPathNavigator navigatorUseByDefault = navigator.SelectSingleNode("UseByDefault");
if (navigatorUseByDefault != null)
{
this._useByDefault = navigatorUseByDefault.ValueAsBoolean;
}
// <AttributedParameters><AttributedParameter>
this._attributeParameters = new List <NetworkAttributeParameter>();
XPathNodeIterator interatorAttributedParameter = navigator.Select("AttributedParameters/AttributedParameter");
while (interatorAttributedParameter.MoveNext())
{
// Get <AttributedParameter>
XPathNavigator navigatorAttributedParameter = interatorAttributedParameter.Current;
// Add AttributedParameter
NetworkAttributeParameter networkAttributeParameter = new NetworkAttributeParameter(navigatorAttributedParameter);
this._attributeParameters.Add(networkAttributeParameter);
}
}
public static XdmNode ToXdmNode(this IXPathNavigable value, DocumentBuilder documentBuilder) {
if (value == null) throw new ArgumentNullException("value");
return ToXdmNode(value.CreateNavigator(), documentBuilder);
}
internal ClipPath(string name, IXPathNavigable path)
{
Name = name;
Path = path;
}
/// <summary>
/// Initializes a new instance of the <see cref="HtmlInput"/> class.
/// </summary>
/// <param name="page">
/// The owning page.
/// </param>
/// <param name="node">
/// The node.
/// </param>
/// <exception cref="System.ArgumentNullException">
/// The <paramref name="page"/> parameter is <c>null</c>.
/// </exception>
/// <exception cref="System.ArgumentNullException">
/// The <paramref name="node"/> parameter is <c>null</c>.
/// </exception>
public HtmlInput(IHtmlPage page, IXPathNavigable node) : base(page, node)
{
}
/// <summary>
/// Creates <c>XPointerReader</c> instnace with given <see cref="IXPathNavigable"/>
/// and xpointer.
/// </summary>
public XPointerReader(IXPathNavigable doc, string xpointer)
: this(doc.CreateNavigator(), xpointer)
{
}
