/// <summary>
/// Creates a new atom exception instance.
/// </summary>
/// <param name="message">The exception message.</param>
/// <param name="xml">The XML element that cannot be parsed.</param>
/// <param name="innerException">The inner exception.</param>
public AtomException(string message, XElement xml, Exception innerException)
: base(message, innerException)
{
this.elementPrefixName = xml.GetPrefixOfNamespace(xml.Name.NamespaceName);
this.elementLocalName = xml.Name.LocalName;
this.xml = xml.ToString(SaveOptions.None);
}
// unlike other XmlWriters the callers must set xmlns
// attribute to overwrite prefix.
void FillXmlns(XElement el, string prefix, XNamespace xns)
{
if (xns == XNamespace.Xmlns)
{
// do nothing for xmlns attributes
return;
}
if (prefix == null)
{
return;
}
if (xns == XNamespace.None)
{
var xnsPrefix = el.GetPrefixOfNamespace(xns);
if (xnsPrefix != null && xnsPrefix != prefix)
{
el.SetAttributeValue(prefix == String.Empty ? XNamespace.None.GetName("xmlns") : XNamespace.Xmlns.GetName(prefix), xns.NamespaceName);
}
}
else if (el.GetDefaultNamespace() != XNamespace.None)
{
el.SetAttributeValue(XNamespace.None.GetName("xmlns"), xns.NamespaceName);
}
}
string GetPrefix()
{
if (!IsInteractive)
{
return(string.Empty);
}
XElement e = _source as XElement;
if (e != null)
{
string prefix = e.GetPrefixOfNamespace(e.Name.Namespace);
if (prefix != null)
{
return(prefix);
}
return(string.Empty);
}
XAttribute a = _source as XAttribute;
if (a != null)
{
string prefix = a.GetPrefixOfNamespace(a.Name.Namespace);
if (prefix != null)
{
return(prefix);
}
}
return(string.Empty);
}
private string GetPrefix()
{
if (this.IsInteractive)
{
XElement source = this.source as XElement;
if (source != null)
{
string prefixOfNamespace = source.GetPrefixOfNamespace(source.Name.Namespace);
if (prefixOfNamespace != null)
{
return(prefixOfNamespace);
}
return(string.Empty);
}
XAttribute attribute = this.source as XAttribute;
if (attribute != null)
{
string str2 = attribute.GetPrefixOfNamespace(attribute.Name.Namespace);
if (str2 != null)
{
return(str2);
}
}
}
return(string.Empty);
}
private static string GetQName([NotNull] XElement element)
{
var prefix = element.GetPrefixOfNamespace(element.Name.Namespace);
return(element.Name.Namespace == XNamespace.None || prefix is null
? element.Name.LocalName
: $"{prefix}:{element.Name.LocalName}");
}
public override string LookupPrefix (string ns)
{
CheckState ();
if (current == null)
throw new InvalidOperationException ();
XElement el = (current as XElement) ?? current.Parent;
return el != null ? el.GetPrefixOfNamespace (XNamespace.Get (ns)) : null;
}
/// <summary>
/// Creates a new atom instance.
/// </summary>
/// <param name="xmlPrefix">The XML prefix.</param>
/// <param name="xmlName">The XML name.</param>
/// <param name="element">The XML element.</param>
protected Atom(string xmlPrefix, string xmlName, XElement element)
{
// Check the XML element name.
if (!element.HasName(xmlPrefix, xmlName))
{
bool b = element.HasName(xmlPrefix, xmlName);
throw new AtomException("XML element name mismatch. Current name is \'{0}:{1}\'. Expected name is \'{2}:{3}\'".FormatWith(
element.GetPrefixOfNamespace(element.Name.Namespace), element.Name.LocalName, xmlPrefix, xmlName), element);
}
}
public static IEnumerable <XElement> Elements(this XElement element, string prefix, string name)
{
if (string.IsNullOrEmpty(prefix))
{
return(element.Elements().Where(
x => x.Name.LocalName == name && element.GetPrefixOfNamespace(x.Name.Namespace) == null));
}
return(element.Elements(ResolvePrefix(element, prefix) + name));
}
public static string ToString(this XamlContext ctx, XElement elem, XName name) {
var sb = new StringBuilder();
if (name.Namespace != elem.GetDefaultNamespace() &&
name.Namespace != elem.Name.Namespace &&
!string.IsNullOrEmpty(name.Namespace.NamespaceName)) {
sb.Append(elem.GetPrefixOfNamespace(name.Namespace));
sb.Append(':');
}
sb.Append(name.LocalName);
return sb.ToString();
}
protected virtual bool PassesXsiTypeFilter(System.Xml.Linq.XElement element)
{
if (false == this.FilterByXsiType)
{
return(true);
}
var attribute = element.Attribute(XName.Get("type", "http://www.w3.org/2001/XMLSchema-instance"));
if (null == attribute)
{
return(false); // Not the cleanest, could we avoid getting here?
}
string value = attribute.Value ?? String.Empty;
string valueNamespace = String.Empty;
string valueType = value;
if (value.Contains(":"))
{
valueNamespace = value.Substring(0, value.IndexOf(":"));
valueType = value.Substring(value.IndexOf(":") + 1);
}
if (
false == String.IsNullOrWhiteSpace(this.XsiTypeFilterExpectedNamespace)
&&
false == String.IsNullOrWhiteSpace(valueNamespace)
)
{
try
{
var expectedPrefix = element.GetPrefixOfNamespace(XNamespace.Get(this.XsiTypeFilterExpectedNamespace)) ?? String.Empty;
if (false == expectedPrefix.Equals(valueNamespace))
{
return(false);
}
}
catch
{
return(false); // This namespace couldn't be found
}
}
if (
false == String.IsNullOrWhiteSpace(this.XsiTypeFilterExpectedType)
&&
false == String.IsNullOrWhiteSpace(valueType)
)
{
if (false == XsiTypeFilterExpectedType.Equals(valueType))
{
return(false);
}
}
return(true);
}
public override string LookupPrefix(string ns)
{
CheckState();
if (current == null)
{
throw new InvalidOperationException();
}
XElement el = (current as XElement) ?? current.Parent;
if (ns == el.Name.Namespace.NamespaceName)
{
return("");
}
return(el != null?el.GetPrefixOfNamespace(XNamespace.Get(ns)) : null);
}
public static IEnumerable <XElement> Descendants(this XElement element, string prefix, string name)
{
var result = element.Descendants(ResolvePrefix(element, prefix) + name);
if (result.Any())
{
return(result);
}
if (string.IsNullOrEmpty(prefix))
{
return(element.Descendants().Where(
x => x.Name.LocalName == name && element.GetPrefixOfNamespace(x.Name.Namespace) == null));
}
return(XElement.EmptySequence);
}
void AnalyzeElement(XamlContext txt, XElement elem)
{
foreach (var i in elem.Attributes())
if (i.Name.NamespaceName == "http://www.w3.org/2000/xmlns/")
txt.namespaces[i.Name.LocalName] = ParseXmlNs(i.Value, txt);
else if (i.Name.LocalName == "xmlns")
txt.namespaces[""] = ParseXmlNs(i.Value, txt);
XamlName name = XamlName.Parse(elem.Name, txt);
name.Xmlns = elem.GetPrefixOfNamespace(name.Xmlns);
if (name.TypeDef == null)
Logger._Log("> Could not resolve '" + elem.Name.ToString() + "'!");
else if (Assemblies.Contains(name.TypeDef.Module.Assembly))
{
IXmlLineInfo li = elem as IXmlLineInfo;
string line = txt.lines[li.LineNumber - 1];
int end = line.IndexOf(' ', li.LinePosition - 1);
if (end == -1)
end = line.IndexOf('>', li.LinePosition - 1);
string str = line.Substring(li.LinePosition - 1, end - li.LinePosition + 1);
var r = new XamlNameReference() { Name = name };
txt.refers.Add(new XamlRef()
{
lineNum = li.LineNumber - 1,
index = li.LinePosition - 1,
length = end - li.LinePosition + 1,
name = name,
refer = r
});
((name.TypeDef as IAnnotationProvider).Annotations[RenRef] as List<IReference>).Add(r);
}
foreach (var i in elem.Attributes())
if (i.Name.NamespaceName != "http://www.w3.org/2000/xmlns/" &&
i.Name.LocalName != "xmlns")
AnalyzePropertyAttr(name.TypeDef, txt, i);
foreach (var i in elem.Elements())
{
if (i.Name.LocalName.Contains("."))
AnalyzePropertyElem(name.TypeDef, txt, i);
else
AnalyzeElement(txt, i);
}
}
private void WriteElementName(XElement element)
{
if(string.IsNullOrEmpty(element.Name.NamespaceName))
{
XPath.Append(element.Name.LocalName);
return;
}
var namespacePrefix = element.GetPrefixOfNamespace(element.Name.Namespace);
if(string.IsNullOrEmpty(namespacePrefix))
{
WriteElementNameWithoutPrefix(element.Name);
}
else
{
WriteElementNameWithPrefix(namespacePrefix, element.Name.LocalName);
}
}
/// <summary>
/// 7.2.7 propertyAttributeURIs
/// anyURI - ( coreSyntaxTerms | rdf:Description | rdf:li | oldTerms )
/// 7.2.11 nodeElement
/// start-element ( URI == nodeElementURIs,
/// attributes == set ( ( idAttr | nodeIdAttr | aboutAttr )?, propertyAttr* ) )
/// propertyEltList
/// end-element()
/// Process the attribute list for an RDF node element.
/// </summary>
/// <remarks>
/// 7.2.7 propertyAttributeURIs
/// anyURI - ( coreSyntaxTerms | rdf:Description | rdf:li | oldTerms )
/// 7.2.11 nodeElement
/// start-element ( URI == nodeElementURIs,
/// attributes == set ( ( idAttr | nodeIdAttr | aboutAttr )?, propertyAttr* ) )
/// propertyEltList
/// end-element()
/// Process the attribute list for an RDF node element. A property attribute URI is
/// anything other than an RDF term. The rdf:ID and rdf:nodeID attributes are simply ignored,
/// as are rdf:about attributes on inner nodes.
/// </remarks>
/// <param name="xmp">the xmp metadata object that is generated</param>
/// <param name="xmpParent">the parent xmp node</param>
/// <param name="xmlNode">the currently processed XML node</param>
/// <param name="isTopLevel">Flag if the node is a top-level node</param>
/// <exception cref="XmpException">thrown on parsing errors</exception>
private static void Rdf_NodeElementAttrs(XmpMeta xmp, XmpNode xmpParent, XElement xmlNode, bool isTopLevel)
{
// Used to detect attributes that are mutually exclusive.
var exclusiveAttrs = 0;
foreach(var attribute in xmlNode.Attributes())
{
// quick hack, ns declarations do not appear in C++
// ignore "ID" without namespace
var prefix = xmlNode.GetPrefixOfNamespace(attribute.Name.Namespace);
if ("xmlns".Equals(prefix) || (prefix == null && "xmlns".Equals(attribute.Name)))
{
continue;
}
var attrTerm = GetRdfTermKind(attribute);
switch (attrTerm)
{
case RdfTerm.Id:
case RdfTerm.NodeId:
case RdfTerm.About:
{
if (exclusiveAttrs > 0)
{
throw new XmpException("Mutally exclusive about, ID, nodeID attributes", XmpErrorCode.BadRdf);
}
exclusiveAttrs++;
if (isTopLevel && (attrTerm == RdfTerm.About))
{
// This is the rdf:about attribute on a top level node. Set
// the XMP tree name if
// it doesn't have a name yet. Make sure this name matches
// the XMP tree name.
if (!string.IsNullOrEmpty(xmpParent.Name))
{
if (!xmpParent.Name.Equals(attribute.Value))
{
throw new XmpException("Mismatched top level rdf:about values", XmpErrorCode.BadXmp);
}
}
else
{
xmpParent.Name = attribute.Value;
}
}
break;
}
case RdfTerm.Other:
{
AddChildNode(xmp, xmpParent, attribute, attribute.Value, isTopLevel);
break;
}
default:
{
throw new XmpException("Invalid nodeElement attribute", XmpErrorCode.BadRdf);
}
}
}
}
/// <summary>
/// 7.2.15 resourcePropertyElt
/// start-element ( URI == propertyElementURIs, attributes == set ( idAttr? ) )
/// ws* nodeElement ws
/// end-element()
/// This handles structs using an rdf:Description node,
/// arrays using rdf:Bag/Seq/Alt, and typedNodes.
/// </summary>
/// <remarks>
/// 7.2.15 resourcePropertyElt
/// start-element ( URI == propertyElementURIs, attributes == set ( idAttr? ) )
/// ws* nodeElement ws
/// end-element()
/// This handles structs using an rdf:Description node,
/// arrays using rdf:Bag/Seq/Alt, and typedNodes. It also catches and cleans up qualified
/// properties written with rdf:Description and rdf:value.
/// </remarks>
/// <param name="xmp">the xmp metadata object that is generated</param>
/// <param name="xmpParent">the parent xmp node</param>
/// <param name="xmlNode">the currently processed XML node</param>
/// <param name="isTopLevel">Flag if the node is a top-level node</param>
/// <exception cref="XmpException">thrown on parsing errors</exception>
private static void Rdf_ResourcePropertyElement(XmpMeta xmp, XmpNode xmpParent, XElement xmlNode, bool isTopLevel)
{
if (isTopLevel && "iX:changes".Equals(xmlNode.Name))
{
// Strip old "punchcard" chaff which has on the prefix "iX:".
return;
}
var newCompound = AddChildNode(xmp, xmpParent, xmlNode, string.Empty, isTopLevel);
// walk through the attributes
foreach(var attribute in xmlNode.Attributes())
{
var prefix = xmlNode.GetPrefixOfNamespace(attribute.Name.Namespace);
if ("xmlns".Equals(prefix) || (prefix == null && "xmlns".Equals(attribute.Name)))
{
continue;
}
var attrLocal = attribute.Name.LocalName;
var attrNs = attribute.Name.NamespaceName;
if (XmpConstants.XmlLang.Equals("xml:" + attribute.Name.LocalName))
{
AddQualifierNode(newCompound, XmpConstants.XmlLang, attribute.Value);
}
else
{
if ("ID".Equals(attrLocal) && XmpConstants.NsRdf.Equals(attrNs))
{
continue;
}
// Ignore all rdf:ID attributes.
throw new XmpException("Invalid attribute for resource property element", XmpErrorCode.BadRdf);
}
}
// walk through the children
var found = false;
foreach(var currChild in xmlNode.Nodes())
{
if (!IsWhitespaceNode(currChild))
{
if (currChild.NodeType == System.Xml.XmlNodeType.Element && !found)
{
var currChildElem = (XElement)currChild;
var isRdf = XmpConstants.NsRdf.Equals(currChildElem.Name.NamespaceName);
var childLocal = currChildElem.Name.LocalName;
if (isRdf && "Bag".Equals(childLocal))
{
newCompound.Options.IsArray = true;
}
else if (isRdf && "Seq".Equals(childLocal))
{
newCompound.Options.IsArray = true;
newCompound.Options.IsArrayOrdered = true;
}
else if (isRdf && "Alt".Equals(childLocal))
{
newCompound.Options.IsArray = true;
newCompound.Options.IsArrayOrdered = true;
newCompound.Options.IsArrayAlternate = true;
}
else
{
newCompound.Options.IsStruct = true;
if (!isRdf && !"Description".Equals(childLocal))
{
var typeName = currChildElem.Name.NamespaceName;
if (typeName == null)
{
throw new XmpException("All XML elements must be in a namespace", XmpErrorCode.BadXmp);
}
typeName += ':' + childLocal;
AddQualifierNode(newCompound, "rdf:type", typeName);
}
}
Rdf_NodeElement(xmp, newCompound, currChildElem, false);
if (newCompound.HasValueChild)
FixupQualifiedNode(newCompound);
else if (newCompound.Options.IsArrayAlternate)
XmpNodeUtils.DetectAltText(newCompound);
found = true;
}
else
{
if (found)
{
// found second child element
throw new XmpException("Invalid child of resource property element", XmpErrorCode.BadRdf);
}
throw new XmpException("Children of resource property element must be XML elements", XmpErrorCode.BadRdf);
}
}
}
if (!found)
{
// didn't found any child elements
throw new XmpException("Missing child of resource property element", XmpErrorCode.BadRdf);
}
}
// unlike other XmlWriters the callers must set xmlns
// attribute to overwrite prefix.
void FillXmlns (XElement el, string prefix, XNamespace xns)
{
if (xns == XNamespace.Xmlns)
// do nothing for xmlns attributes
return;
if (xns == XNamespace.None)
if (el.GetPrefixOfNamespace (xns) != prefix)
el.SetAttributeValue (prefix == String.Empty ? XNamespace.None.GetName ("xmlns") : XNamespace.Xmlns.GetName (prefix), xns.NamespaceName);
else if (el.GetDefaultNamespace () != XNamespace.None)
el.SetAttributeValue (XNamespace.None.GetName ("xmlns"), xns.NamespaceName);
}
void AnalyzePropertyElem(TypeDefinition typeDef, XamlContext txt, XElement elem)
{
XamlPropertyName name = XamlPropertyName.Parse(typeDef, elem.Name, txt);
name.Xmlns = elem.GetPrefixOfNamespace(name.Xmlns);
var prop = ResolveProperty(name.TypeDef, name.PropertyName);
if (prop != null && Assemblies.Contains(prop.DeclaringType.Module.Assembly))
{
IXmlLineInfo li = elem as IXmlLineInfo;
string line = txt.lines[li.LineNumber - 1];
int end = line.IndexOf('>', li.LinePosition - 1);
string str = line.Substring(li.LinePosition - 1, end - li.LinePosition + 1);
var r = new XamlPropertyNameReference() { Name = name };
txt.refers.Add(new XamlRef()
{
lineNum = li.LineNumber - 1,
index = li.LinePosition - 1,
length = end - li.LinePosition + 1,
name = name,
refer = r
});
((prop as IAnnotationProvider).Annotations[RenRef] as List<IReference>).Add(r);
}
foreach (var i in elem.Elements())
{
if (i.Name.LocalName.Contains("."))
AnalyzePropertyElem(name.TypeDef, txt, i);
else
AnalyzeElement(txt, i);
}
}
/// <summary>
/// 7.2.21 emptyPropertyElt
/// start-element ( URI == propertyElementURIs,
/// attributes == set (
/// idAttr?, ( resourceAttr | nodeIdAttr )?, propertyAttr* ) )
/// end-element()
/// <ns:Prop1/> <!-- a simple property with an empty value -->
/// <ns:Prop2 rdf:resource="http: *www.adobe.com/"/> <!-- a URI value -->
/// <ns:Prop3 rdf:value="..." ns:Qual="..."/> <!-- a simple qualified property -->
/// <ns:Prop4 ns:Field1="..." ns:Field2="..."/> <!-- a struct with simple fields -->
/// An emptyPropertyElt is an element with no contained content, just a possibly empty set of
/// attributes.
/// </summary>
/// <remarks>
/// 7.2.21 emptyPropertyElt
/// start-element ( URI == propertyElementURIs,
/// attributes == set (
/// idAttr?, ( resourceAttr | nodeIdAttr )?, propertyAttr* ) )
/// end-element()
/// <ns:Prop1/> <!-- a simple property with an empty value -->
/// <ns:Prop2 rdf:resource="http: *www.adobe.com/"/> <!-- a URI value -->
/// <ns:Prop3 rdf:value="..." ns:Qual="..."/> <!-- a simple qualified property -->
/// <ns:Prop4 ns:Field1="..." ns:Field2="..."/> <!-- a struct with simple fields -->
/// An emptyPropertyElt is an element with no contained content, just a possibly empty set of
/// attributes. An emptyPropertyElt can represent three special cases of simple XMP properties: a
/// simple property with an empty value (ns:Prop1), a simple property whose value is a URI
/// (ns:Prop2), or a simple property with simple qualifiers (ns:Prop3).
/// An emptyPropertyElt can also represent an XMP struct whose fields are all simple and
/// unqualified (ns:Prop4).
/// It is an error to use both rdf:value and rdf:resource - that can lead to invalid RDF in the
/// verbose form written using a literalPropertyElt.
/// The XMP mapping for an emptyPropertyElt is a bit different from generic RDF, partly for
/// design reasons and partly for historical reasons. The XMP mapping rules are:
/// <list type="bullet">
/// <item> If there is an rdf:value attribute then this is a simple property
/// with a text value.
/// All other attributes are qualifiers.</item>
/// <item> If there is an rdf:resource attribute then this is a simple property
/// with a URI value.
/// All other attributes are qualifiers.</item>
/// <item> If there are no attributes other than xml:lang, rdf:ID, or rdf:nodeID
/// then this is a simple
/// property with an empty value.</item>
/// <item> Otherwise this is a struct, the attributes other than xml:lang, rdf:ID,
/// or rdf:nodeID are fields.</item>
/// </list>
/// </remarks>
/// <param name="xmp">the xmp metadata object that is generated</param>
/// <param name="xmpParent">the parent xmp node</param>
/// <param name="xmlNode">the currently processed XML node</param>
/// <param name="isTopLevel">Flag if the node is a top-level node</param>
/// <exception cref="XmpException">thrown on parsing errors</exception>
private static void Rdf_EmptyPropertyElement(XmpMeta xmp, XmpNode xmpParent, XElement xmlNode, bool isTopLevel)
{
var hasPropertyAttrs = false;
var hasResourceAttr = false;
var hasNodeIdAttr = false;
var hasValueAttr = false;
XAttribute valueNode = null;
// ! Can come from rdf:value or rdf:resource.
if (!(xmlNode.FirstNode == null))
{
throw new XmpException("Nested content not allowed with rdf:resource or property attributes", XmpErrorCode.BadRdf);
}
// First figure out what XMP this maps to and remember the XML node for a simple value.
foreach (var attribute in xmlNode.Attributes())
{
var prefix = xmlNode.GetPrefixOfNamespace(attribute.Name.Namespace);
if ("xmlns".Equals(prefix) || (prefix == null && "xmlns".Equals(attribute.Name)))
{
continue;
}
var attrTerm = GetRdfTermKind(attribute);
switch (attrTerm)
{
case RdfTerm.Id:
{
// Nothing to do.
break;
}
case RdfTerm.Resource:
{
if (hasNodeIdAttr)
{
throw new XmpException("Empty property element can't have both rdf:resource and rdf:nodeID", XmpErrorCode.BadRdf);
}
if (hasValueAttr)
{
throw new XmpException("Empty property element can't have both rdf:value and rdf:resource", XmpErrorCode.BadXmp);
}
hasResourceAttr = true;
if (!hasValueAttr)
{
valueNode = attribute;
}
break;
}
case RdfTerm.NodeId:
{
if (hasResourceAttr)
{
throw new XmpException("Empty property element can't have both rdf:resource and rdf:nodeID", XmpErrorCode.BadRdf);
}
hasNodeIdAttr = true;
break;
}
case RdfTerm.Other:
{
if ("value".Equals(attribute.Name.LocalName) && XmpConstants.NsRdf.Equals(attribute.Name.NamespaceName))
{
if (hasResourceAttr)
{
throw new XmpException("Empty property element can't have both rdf:value and rdf:resource", XmpErrorCode.BadXmp);
}
hasValueAttr = true;
valueNode = attribute;
}
else
{
if (!XmpConstants.XmlLang.Equals("xml:" + attribute.Name.LocalName))
{
hasPropertyAttrs = true;
}
}
break;
}
default:
{
throw new XmpException("Unrecognized attribute of empty property element", XmpErrorCode.BadRdf);
}
}
}
// Create the right kind of child node and visit the attributes again
// to add the fields or qualifiers.
// ! Because of implementation vagaries,
// the xmpParent is the tree root for top level properties.
// ! The schema is found, created if necessary, by addChildNode.
var childNode = AddChildNode(xmp, xmpParent, xmlNode, string.Empty, isTopLevel);
var childIsStruct = false;
if (hasValueAttr || hasResourceAttr)
{
childNode.Value = valueNode != null ? valueNode.Value : string.Empty;
if (!hasValueAttr)
{
// ! Might have both rdf:value and rdf:resource.
childNode.Options.IsUri = true;
}
}
else
{
if (hasPropertyAttrs)
{
childNode.Options.IsStruct = true;
childIsStruct = true;
}
}
foreach(var attribute in xmlNode.Attributes())
{
var prefix = xmlNode.GetPrefixOfNamespace(attribute.Name.Namespace);
if (attribute == valueNode || "xmlns".Equals(prefix) || (prefix == null && "xmlns".Equals(attribute.Name)))
{
continue;
}
// Skip the rdf:value or rdf:resource attribute holding the value.
var attrTerm = GetRdfTermKind(attribute);
switch (attrTerm)
{
case RdfTerm.Id:
case RdfTerm.NodeId:
{
break;
}
case RdfTerm.Resource:
{
// Ignore all rdf:ID and rdf:nodeID attributes.
AddQualifierNode(childNode, "rdf:resource", attribute.Value);
break;
}
case RdfTerm.Other:
{
if (!childIsStruct)
{
AddQualifierNode(childNode, attribute.Name.LocalName, attribute.Value);
}
else
{
if (XmpConstants.XmlLang.Equals("xml:" + attribute.Name.LocalName))
{
AddQualifierNode(childNode, XmpConstants.XmlLang, attribute.Value);
}
else
{
AddChildNode(xmp, childNode, attribute, attribute.Value, false);
}
}
break;
}
default:
{
throw new XmpException("Unrecognized attribute of empty property element", XmpErrorCode.BadRdf);
}
}
}
}
/// <summary>
/// Builds the entity-property-mapping tree represented by the given xml element
/// </summary>
/// <param name="element">The element to build from</param>
/// <returns>The entity-property-mapping tree</returns>
private XmlTreeAnnotation BuildEpmTree(XElement element)
{
var mappedProperty = new XmlTreeAnnotation()
{
IsAttribute = false,
LocalName = element.Name.LocalName,
NamespaceName = element.Name.NamespaceName,
NamespacePrefix = element.GetPrefixOfNamespace(element.Name.Namespace),
PropertyValue = element.Nodes().OfType<XText>().Select(t => t.Value).SingleOrDefault(),
};
foreach (var subElement in element.Elements())
{
mappedProperty.Children.Add(this.BuildEpmTree(subElement));
}
foreach (var attribute in element.Attributes().Where(a => !a.IsNamespaceDeclaration))
{
mappedProperty.Children.Add(this.BuildEpmTree(attribute));
}
return mappedProperty;
}
private void RecurseElements(XElement element, int indent, TextWriter writer)
{
this.elementCount++;
string thisIndent = Space(indent);
string nextIndent = Space(indent + IndentSize);
string ns = element.GetPrefixOfNamespace(element.Name.Namespace);
bool hasChildren = element.HasElements;
if (!String.IsNullOrEmpty(element.Value))
{
hasChildren = true;
}
if (ns == null)
{
ns = string.Empty;
}
else
{
ns = ns + ":";
}
// Opening glyph
if (IsSpaceBeforeElement(element))
{
writer.WriteLine(string.Empty);
}
writer.Write("{0}<{1}{2}", thisIndent, ns, element.Name.LocalName);
WriteAttributes(writer, element, nextIndent);
if (hasChildren)
{
WriteChildren(writer, element, indent, nextIndent);
}
// Write Closing glyphs
if (hasChildren)
{
writer.WriteLine("{0}</{1}{2}>", thisIndent, ns, element.Name.LocalName);
}
else
{
writer.WriteLine(" />");
}
if (IsSpaceAfterElement(element))
{
writer.WriteLine(string.Empty);
}
}
/// <summary>
/// 7.2.16 literalPropertyElt
/// start-element ( URI == propertyElementURIs,
/// attributes == set ( idAttr?, datatypeAttr?) )
/// text()
/// end-element()
/// Add a leaf node with the text value and qualifiers for the attributes.
/// </summary>
/// <param name="xmp">the xmp metadata object that is generated</param>
/// <param name="xmpParent">the parent xmp node</param>
/// <param name="xmlNode">the currently processed XML node</param>
/// <param name="isTopLevel">Flag if the node is a top-level node</param>
/// <exception cref="XmpException">thrown on parsing errors</exception>
private static void Rdf_LiteralPropertyElement(XmpMeta xmp, XmpNode xmpParent, XElement xmlNode, bool isTopLevel)
{
var newChild = AddChildNode(xmp, xmpParent, xmlNode, null, isTopLevel);
foreach (var attribute in xmlNode.Attributes())
{
var prefix = xmlNode.GetPrefixOfNamespace(attribute.Name.Namespace);
if ("xmlns".Equals(prefix) || (prefix == null && "xmlns".Equals(attribute.Name)))
{
continue;
}
var attrNs = attribute.Name.NamespaceName;
var attrLocal = attribute.Name.LocalName;
if (XmpConstants.XmlLang.Equals("xml:" + attribute.Name.LocalName))
{
AddQualifierNode(newChild, XmpConstants.XmlLang, attribute.Value);
}
else
{
if (XmpConstants.NsRdf.Equals(attrNs) && ("ID".Equals(attrLocal) || "datatype".Equals(attrLocal)))
{
continue;
}
// Ignore all rdf:ID and rdf:datatype attributes.
throw new XmpException("Invalid attribute for literal property element", XmpErrorCode.BadRdf);
}
}
var textValue = string.Empty;
foreach(var child in xmlNode.Nodes())
{
if (child.NodeType == System.Xml.XmlNodeType.Text)
{
textValue += ((XText)child).Value;
}
else
{
throw new XmpException("Invalid child of literal property element", XmpErrorCode.BadRdf);
}
}
newChild.Value = textValue;
}
private static XElement AcceptMoveFromRanges(XElement document)
{
string wordProcessingNamespacePrefix = document.GetPrefixOfNamespace(W.w);
// The following lists contain the elements that are between start/end elements.
List<XElement> startElementTagsInMoveFromRange = new List<XElement>();
List<XElement> endElementTagsInMoveFromRange = new List<XElement>();
// Following are the elements that *may* be in a range that has both start and end
// elements.
Dictionary<string, PotentialInRangeElements> potentialDeletedElements =
new Dictionary<string, PotentialInRangeElements>();
foreach (var tag in DescendantAndSelfTags(document))
{
if (tag.Element.Name == W.moveFromRangeStart)
{
string id = tag.Element.Attribute(W.id).Value;
potentialDeletedElements.Add(id, new PotentialInRangeElements());
continue;
}
if (tag.Element.Name == W.moveFromRangeEnd)
{
string id = tag.Element.Attribute(W.id).Value;
if (potentialDeletedElements.ContainsKey(id))
{
startElementTagsInMoveFromRange.AddRange(
potentialDeletedElements[id].PotentialStartElementTagsInRange);
endElementTagsInMoveFromRange.AddRange(
potentialDeletedElements[id].PotentialEndElementTagsInRange);
potentialDeletedElements.Remove(id);
}
continue;
}
if (potentialDeletedElements.Count > 0)
{
if (tag.TagType == TagTypeEnum.Element &&
(tag.Element.Name != W.moveFromRangeStart &&
tag.Element.Name != W.moveFromRangeEnd))
{
foreach (var id in potentialDeletedElements)
id.Value.PotentialStartElementTagsInRange.Add(tag.Element);
continue;
}
if (tag.TagType == TagTypeEnum.EmptyElement &&
(tag.Element.Name != W.moveFromRangeStart &&
tag.Element.Name != W.moveFromRangeEnd))
{
foreach (var id in potentialDeletedElements)
{
id.Value.PotentialStartElementTagsInRange.Add(tag.Element);
id.Value.PotentialEndElementTagsInRange.Add(tag.Element);
}
continue;
}
if (tag.TagType == TagTypeEnum.EndElement &&
(tag.Element.Name != W.moveFromRangeStart &&
tag.Element.Name != W.moveFromRangeEnd))
{
foreach (var id in potentialDeletedElements)
id.Value.PotentialEndElementTagsInRange.Add(tag.Element);
continue;
}
}
}
var moveFromElementsToDelete = startElementTagsInMoveFromRange
.Intersect(endElementTagsInMoveFromRange)
.ToArray();
if (moveFromElementsToDelete.Count() > 0)
return (XElement)AcceptMoveFromRangesTransform(
document, moveFromElementsToDelete);
return document;
}
/// <summary>
/// 7.2.18 parseTypeResourcePropertyElt
/// start-element ( URI == propertyElementURIs,
/// attributes == set ( idAttr?, parseResource ) )
/// propertyEltList
/// end-element()
/// Add a new struct node with a qualifier for the possible rdf:ID attribute.
/// </summary>
/// <remarks>
/// 7.2.18 parseTypeResourcePropertyElt
/// start-element ( URI == propertyElementURIs,
/// attributes == set ( idAttr?, parseResource ) )
/// propertyEltList
/// end-element()
/// Add a new struct node with a qualifier for the possible rdf:ID attribute.
/// Then process the XML child nodes to get the struct fields.
/// </remarks>
/// <param name="xmp">the xmp metadata object that is generated</param>
/// <param name="xmpParent">the parent xmp node</param>
/// <param name="xmlNode">the currently processed XML node</param>
/// <param name="isTopLevel">Flag if the node is a top-level node</param>
/// <exception cref="XmpException">thrown on parsing errors</exception>
private static void Rdf_ParseTypeResourcePropertyElement(XmpMeta xmp, XmpNode xmpParent, XElement xmlNode, bool isTopLevel)
{
var newStruct = AddChildNode(xmp, xmpParent, xmlNode, string.Empty, isTopLevel);
newStruct.Options.IsStruct = true;
foreach (var attribute in xmlNode.Attributes())
{
var prefix = xmlNode.GetPrefixOfNamespace(attribute.Name.Namespace);
if ("xmlns".Equals(prefix) || (prefix == null && "xmlns".Equals(attribute.Name)))
{
continue;
}
var attrLocal = attribute.Name.LocalName;
var attrNs = attribute.Name.NamespaceName;
if (XmpConstants.XmlLang.Equals("xml:" + attribute.Name.LocalName))
{
AddQualifierNode(newStruct, XmpConstants.XmlLang, attribute.Value);
}
else
{
if (XmpConstants.NsRdf.Equals(attrNs) && ("ID".Equals(attrLocal) || "parseType".Equals(attrLocal)))
{
continue;
}
// The caller ensured the value is "Resource".
// Ignore all rdf:ID attributes.
throw new XmpException("Invalid attribute for ParseTypeResource property element", XmpErrorCode.BadRdf);
}
}
Rdf_PropertyElementList(xmp, newStruct, xmlNode, false);
if (newStruct.HasValueChild)
{
FixupQualifiedNode(newStruct);
}
}
/// <summary>
/// Tests XElement.GetPrefixOfNamespace().
/// </summary>
/// <param name="contextValue"></param>
/// <returns></returns>
//[Variation(Desc = "ElementGetPrefixOfNamespace")]
public void ElementGetPrefixOfNamespace()
{
try
{
new XElement("foo").GetPrefixOfNamespace(null);
Validate.ExpectedThrow(typeof(ArgumentNullException));
}
catch (Exception ex)
{
Validate.Catch(ex, typeof(ArgumentNullException));
}
XNamespace ns = XNamespace.Get("http://test");
XElement e = new XElement(ns + "foo");
string prefix = e.GetPrefixOfNamespace(ns);
Validate.IsNull(prefix);
prefix = e.GetPrefixOfNamespace(XNamespace.Xmlns);
Validate.String(prefix, "xmlns");
prefix = e.GetPrefixOfNamespace(XNamespace.Xml);
Validate.String(prefix, "xml");
XElement parent = new XElement("parent", e);
parent.SetAttributeValue("{http://www.w3.org/2000/xmlns/}myns", ns);
prefix = e.GetPrefixOfNamespace(ns);
Validate.String(prefix, "myns");
e = XElement.Parse("<foo:element xmlns:foo='http://xxx'></foo:element>");
prefix = e.GetPrefixOfNamespace("http://xxx");
Validate.String(prefix, "foo");
e = XElement.Parse("<foo:element xmlns:foo='http://foo' xmlns:bar='http://bar'><bar:element /></foo:element>");
prefix = e.GetPrefixOfNamespace("http://foo");
Validate.String(prefix, "foo");
prefix = e.Element(XName.Get("{http://bar}element")).GetPrefixOfNamespace("http://foo");
Validate.String(prefix, "foo");
prefix = e.Element(XName.Get("{http://bar}element")).GetPrefixOfNamespace("http://bar");
Validate.String(prefix, "bar");
}
internal static void CopyExtendedPropertiesToSsdlElement(MetadataItem metadataItem, XContainer xContainer)
{
foreach (var extendedProperty in metadataItem.MetadataProperties.Where(mp => mp.PropertyKind == PropertyKind.Extended))
{
var exPropertyElement = extendedProperty.Value as XElement;
if (exPropertyElement != null)
{
// find the CopyToSSDL attribute - if it exists it can be in any EDMX namespace
var copyToSSDLAttribute = exPropertyElement.Attributes().FirstOrDefault(
attr => attr.Name.LocalName.Equals("CopyToSSDL", StringComparison.Ordinal)
&& SchemaManager.GetEDMXNamespaceNames().Contains(attr.Name.NamespaceName));
if (copyToSSDLAttribute != null)
{
if ((bool?)copyToSSDLAttribute == true)
{
// CopyToSsdl is true, so let's copy this extended property
var exAttributeNamespace = copyToSSDLAttribute.Name.Namespace;
var newExPropertyElement = new XElement(exPropertyElement);
var newCopyToSsdlAttribute = newExPropertyElement.Attribute(exAttributeNamespace + "CopyToSSDL");
newCopyToSsdlAttribute.Remove();
var namespacePrefix = newExPropertyElement.GetPrefixOfNamespace(exAttributeNamespace);
if (namespacePrefix != null)
{
var xmlnsEdmxAttr = newExPropertyElement.Attribute(XNamespace.Xmlns + namespacePrefix);
if (xmlnsEdmxAttr != null)
{
xmlnsEdmxAttr.Remove();
}
}
xContainer.Add(newExPropertyElement);
}
}
}
}
}
private static XElement AcceptDeletedAndMovedFromContentControls(XElement documentRootElement)
{
string wordProcessingNamespacePrefix = documentRootElement.GetPrefixOfNamespace(W.w);
// The following lists contain the elements that are between start/end elements.
List<XElement> startElementTagsInDeleteRange = new List<XElement>();
List<XElement> endElementTagsInDeleteRange = new List<XElement>();
List<XElement> startElementTagsInMoveFromRange = new List<XElement>();
List<XElement> endElementTagsInMoveFromRange = new List<XElement>();
// Following are the elements that *may* be in a range that has both start and end
// elements.
Dictionary<string, PotentialInRangeElements> potentialDeletedElements =
new Dictionary<string, PotentialInRangeElements>();
Dictionary<string, PotentialInRangeElements> potentialMoveFromElements =
new Dictionary<string, PotentialInRangeElements>();
foreach (var tag in DescendantAndSelfTags(documentRootElement))
{
if (tag.Element.Name == W.customXmlDelRangeStart)
{
string id = tag.Element.Attribute(W.id).Value;
potentialDeletedElements.Add(id, new PotentialInRangeElements());
continue;
}
if (tag.Element.Name == W.customXmlDelRangeEnd)
{
string id = tag.Element.Attribute(W.id).Value;
if (potentialDeletedElements.ContainsKey(id))
{
startElementTagsInDeleteRange.AddRange(
potentialDeletedElements[id].PotentialStartElementTagsInRange);
endElementTagsInDeleteRange.AddRange(
potentialDeletedElements[id].PotentialEndElementTagsInRange);
potentialDeletedElements.Remove(id);
}
continue;
}
if (tag.Element.Name == W.customXmlMoveFromRangeStart)
{
string id = tag.Element.Attribute(W.id).Value;
potentialMoveFromElements.Add(id, new PotentialInRangeElements());
continue;
}
if (tag.Element.Name == W.customXmlMoveFromRangeEnd)
{
string id = tag.Element.Attribute(W.id).Value;
if (potentialMoveFromElements.ContainsKey(id))
{
startElementTagsInMoveFromRange.AddRange(
potentialMoveFromElements[id].PotentialStartElementTagsInRange);
endElementTagsInMoveFromRange.AddRange(
potentialMoveFromElements[id].PotentialEndElementTagsInRange);
potentialMoveFromElements.Remove(id);
}
continue;
}
if (tag.Element.Name == W.sdt)
{
if (tag.TagType == TagTypeEnum.Element)
{
foreach (var id in potentialDeletedElements)
id.Value.PotentialStartElementTagsInRange.Add(tag.Element);
foreach (var id in potentialMoveFromElements)
id.Value.PotentialStartElementTagsInRange.Add(tag.Element);
continue;
}
if (tag.TagType == TagTypeEnum.EmptyElement)
{
foreach (var id in potentialDeletedElements)
{
id.Value.PotentialStartElementTagsInRange.Add(tag.Element);
id.Value.PotentialEndElementTagsInRange.Add(tag.Element);
}
foreach (var id in potentialMoveFromElements)
{
id.Value.PotentialStartElementTagsInRange.Add(tag.Element);
id.Value.PotentialEndElementTagsInRange.Add(tag.Element);
}
continue;
}
if (tag.TagType == TagTypeEnum.EndElement)
{
foreach (var id in potentialDeletedElements)
id.Value.PotentialEndElementTagsInRange.Add(tag.Element);
foreach (var id in potentialMoveFromElements)
id.Value.PotentialEndElementTagsInRange.Add(tag.Element);
continue;
}
throw new PowerToolsInvalidDataException("Should not have reached this point.");
}
if (potentialMoveFromElements.Count() > 0 &&
tag.Element.Name != W.moveFromRangeStart &&
tag.Element.Name != W.moveFromRangeEnd &&
tag.Element.Name != W.customXmlMoveFromRangeStart &&
tag.Element.Name != W.customXmlMoveFromRangeEnd)
{
if (tag.TagType == TagTypeEnum.Element)
{
foreach (var id in potentialMoveFromElements)
id.Value.PotentialStartElementTagsInRange.Add(tag.Element);
continue;
}
if (tag.TagType == TagTypeEnum.EmptyElement)
{
foreach (var id in potentialMoveFromElements)
{
id.Value.PotentialStartElementTagsInRange.Add(tag.Element);
id.Value.PotentialEndElementTagsInRange.Add(tag.Element);
}
continue;
}
if (tag.TagType == TagTypeEnum.EndElement)
{
foreach (var id in potentialMoveFromElements)
id.Value.PotentialEndElementTagsInRange.Add(tag.Element);
continue;
}
}
}
var contentControlElementsToCollapse = startElementTagsInDeleteRange
.Intersect(endElementTagsInDeleteRange)
.ToArray();
var elementsToDeleteBecauseMovedFrom = startElementTagsInMoveFromRange
.Intersect(endElementTagsInMoveFromRange)
.ToArray();
if (contentControlElementsToCollapse.Length > 0 ||
elementsToDeleteBecauseMovedFrom.Length > 0)
{
var newDoc = AcceptDeletedAndMovedFromContentControlsTransform(documentRootElement,
contentControlElementsToCollapse, elementsToDeleteBecauseMovedFrom);
return newDoc as XElement;
}
else
return documentRootElement;
}
/// <summary>Adds a child node.</summary>
/// <param name="xmp">the xmp metadata object that is generated</param>
/// <param name="xmpParent">the parent xmp node</param>
/// <param name="xmlNode">the currently processed XML node</param>
/// <param name="value">Node value</param>
/// <param name="isTopLevel">Flag if the node is a top-level node</param>
/// <returns>Returns the newly created child node.</returns>
/// <exception cref="XmpException">thrown on parsing errors</exception>
private static XmpNode AddChildNode(XmpMeta xmp, XmpNode xmpParent, XElement xmlNode, string value, bool isTopLevel)
{
return AddChildNode(xmp, xmpParent, xmlNode.Name, xmlNode.GetPrefixOfNamespace(xmlNode.Name.Namespace), value, isTopLevel);
}
public void ElementGetPrefixOfNamespace()
{
Assert.Throws<ArgumentNullException>(() => new XElement("foo").GetPrefixOfNamespace(null));
XNamespace ns = XNamespace.Get("http://test");
XElement e = new XElement(ns + "foo");
string prefix = e.GetPrefixOfNamespace(ns);
Assert.Null(prefix);
prefix = e.GetPrefixOfNamespace(XNamespace.Xmlns);
Assert.Equal("xmlns", prefix);
prefix = e.GetPrefixOfNamespace(XNamespace.Xml);
Assert.Equal("xml", prefix);
XElement parent = new XElement("parent", e);
parent.SetAttributeValue("{http://www.w3.org/2000/xmlns/}myns", ns);
prefix = e.GetPrefixOfNamespace(ns);
Assert.Equal("myns", prefix);
e = XElement.Parse("<foo:element xmlns:foo='http://xxx'></foo:element>");
prefix = e.GetPrefixOfNamespace("http://xxx");
Assert.Equal("foo", prefix);
e =
XElement.Parse(
"<foo:element xmlns:foo='http://foo' xmlns:bar='http://bar'><bar:element /></foo:element>");
prefix = e.GetPrefixOfNamespace("http://foo");
Assert.Equal("foo", prefix);
prefix = e.Element(XName.Get("{http://bar}element")).GetPrefixOfNamespace("http://foo");
Assert.Equal("foo", prefix);
prefix = e.Element(XName.Get("{http://bar}element")).GetPrefixOfNamespace("http://bar");
Assert.Equal("bar", prefix);
}
public short loadConfig()
{
try {
//creating xml from file
XmlReader reader = XmlReader.Create(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + Path.DirectorySeparatorChar + "Devices.xml");
probe = XElement.Load(reader);
if (probe.GetPrefixOfNamespace(probe.Name.Namespace) == null)
{
prefix = null;
}
else
{
prefix = probe.GetPrefixOfNamespace(probe.Name.Namespace);
}
probe2 = probe;
//probe2.Load(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + Path.DirectorySeparatorChar + "Devices.xml");
XmlNameTable nameTable = reader.NameTable;
//XmlNameTable nameTable = probe2.NameTable;
namespaceManager = new XmlNamespaceManager(nameTable);
if (prefix==null)
{ namespaceManager.AddNamespace(string.Empty, MTConnectNameSpace.mtConnectUriDevices); }
else
{
namespaceManager.AddNamespace(prefix, MTConnectNameSpace.mtConnectUriDevices);
}
namespaceManager.AddNamespace("mts", MTConnectNameSpace.mtConnectUriStreams);
namespaceManager.AddNamespace("mt", MTConnectNameSpace.mtConnectUriDevices);
//namespaceManager.AddNamespace(MTConnectNameSpace.mtConnectPrefix, MTConnectNameSpace.mtConnectUriError);
}
catch (Exception e)
{
throw new AgentException("Loading Devices.xml Failed.", e);
}
//validation of Devices.xml against MTConnectDevices.xsd
/* ApplicationClass appXML = new ApplicationClass();
XMLValidator XMLValidator = appXML.XMLValidator;
StreamReader schemaIn = new StreamReader(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + Path.DirectorySeparatorChar + "MTConnectDevices.xsd");
StringBuilder stringb = new System.Text.StringBuilder();
char[] buf = new char[16384];
int count;
do
{
count = schemaIn.Read(buf, 0, 16384);
stringb.Append(buf, 0, count);
} while (count > 0);
XMLValidator.SchemaFromText = stringb.ToString();
XMLValidator.InputXMLFromText = probe.ToString();
bool IsValid = XMLValidator.IsValidWithExternalSchemaOrDTD();
if(!IsValid)
return ReturnValue.ERROR; //validation failed*/
byte[] byteArray = Encoding.ASCII.GetBytes(probe.ToString());
MemoryStream stream = new MemoryStream(byteArray);
validationSuccess = true;
//XmlReader schemaStream = XmlReader.Create("MTConnectDevices.xsd");
XmlSchemaSet sc = new XmlSchemaSet();
// sc.Add("urn:mtconnect.org:MTConnectDevices:1.1", Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + Path.DirectorySeparatorChar + "MTConnectDevices.xsd");
sc.Add("urn:mtconnect.org:MTConnectDevices:1.1", new XmlTextReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("MTConnectAgentCore.MTConnectDevices.xsd")));
XmlReaderSettings settings = new XmlReaderSettings();
settings.ValidationType = ValidationType.Schema;
settings.Schemas = sc;
settings.ValidationEventHandler += new ValidationEventHandler(ValidationHandler);
XmlReader Xreader = XmlReader.Create(stream, settings);
while (Xreader.Read()) ;
if (!validationSuccess)
return ReturnValue.ERROR;
XElement header = probe.Element(MTConnectNameSpace.mtDevices + "Header");
try
{
this.buffersize = Int32.Parse(header.Attribute("bufferSize").Value);
}
catch (Exception e)
{
throw new AgentException("Devices.xml's Header bufferSize value can not be converted into an integer.", e);
}
this.sender = header.Attribute("sender").Value;
this.version = header.Attribute("version").Value;
this.instanceId = header.Attribute("instanceId").Value;
streams = DataUtil.createStreams(probe, namespaceManager);
datastorage = DataUtil.createDataStorage(probe2, namespaceManager, out sequence, out bufferSizeCounter, out minAtIndex, out realbuffersize, out firstSequence, out lastSequence, buffersize); //clone of probe without its name space
return ReturnValue.SUCCESS;
}
