internal void AddRange(XMLList list)
{
foreach (XML xml in list.m_Nodes)
{
Add(xml);
}
}
private object Copy()
{
XMLList list = new XMLList(lib);
foreach (XML xml in m_Nodes)
{
list.Add((XML)xml.Copy());
}
return(list);
}
internal XMLList GetPropertyList(XMLName xmlName)
{
XMLList list = new XMLList(lib);
foreach (XML xml in m_Nodes)
{
list.AddRange(xml.GetPropertyList(xmlName));
}
return(list);
}
private XMLList Child(long index)
{
XMLList list = new XMLList(lib);
foreach (XML xml in this)
{
list.AddRange(xml.Child(index));
}
return(list);
}
/// <summary>
/// XMLList.prototype.processingInstructions ( [ name ] )
///
/// The processingInstructions method calls the processingInstructions
/// method of each XML object in this XMLList object passing the optional
/// parameter name (or "*" if it is omitted) and returns an XMList
/// containing the results in order.
///
/// See ECMA
/// </summary>
private XMLList ProcessingInstructions(XMLName name)
{
XMLList list = new XMLList(lib);
foreach (XML xml in this)
{
list.AddRange(xml.ProcessingInstructions(name));
}
return(list);
}
private XMLList Descendants(XMLName xmlName)
{
XMLList list = new XMLList(lib);
foreach (XML xml in this)
{
list.AddRange(xml.Descendants(xmlName));
}
return(list);
}
/// <summary>
/// XMLList.prototype.child ( propertyName )
///
/// The child method calls the child() method of each XML object in
/// this XMLList object and returns an XMLList containing the results
/// in order.
///
/// See ECMA 13.5.4.4
/// </summary>
private XMLList Child(XMLName xmlName)
{
XMLList list = new XMLList(lib);
foreach (XML xml in this)
{
list.AddRange(xml.Child(xmlName));
}
return(list);
}
private XMLList Attributes()
{
XMLList list = new XMLList(lib);
foreach (XML xml in this)
{
list.AddRange(xml.Attributes());
}
return(list);
}
private XMLList Children()
{
XMLList list = new XMLList(lib);
foreach (XML xml in m_Nodes)
{
list.AddRange(xml.Children());
}
return(list);
}
protected internal override object GetXMLProperty(XMLName name)
{
if (isPrototype)
{
return(base.Get(name.localName, this));
}
XMLList list = new XMLList(lib);
foreach (XML xml in m_Nodes)
{
list.AddRange((XMLList)xml.GetXMLProperty(name));
}
return(list);
}
public XMLList(XMLLib lib, object inputObject)
: this(lib)
{
string frag;
if (inputObject == null || inputObject is Undefined)
{
frag = "";
}
else if (inputObject is XML)
{
XML xml = (XML)inputObject;
Add(xml);
}
else if (inputObject is XMLList)
{
XMLList xmll = (XMLList)inputObject;
AddRange(xmll);
}
else
{
frag = ScriptConvert.ToString(inputObject).Trim();
if (!frag.StartsWith("<>"))
{
frag = "<>" + frag + "</>";
}
frag = "<fragment>" + frag.Substring(2);
if (!frag.EndsWith("</>"))
{
throw ScriptRuntime.TypeError("XML with anonymous tag missing end anonymous tag");
}
frag = frag.Substring(0, frag.Length - 3) + "</fragment>";
XML orgXML = XML.CreateFromJS(lib, frag);
// Now orphan the children and add them to our XMLList.
XMLList children = (XMLList)orgXML.Children();
AddRange(children);
}
}
private XMLList Attributes ()
{
XMLList list = new XMLList (lib);
foreach (XML xml in this)
list.AddRange (xml.Attributes ());
return list;
}
public override object ExecIdCall(IdFunctionObject f, Context cx, IScriptable scope, IScriptable thisObj, object [] args)
{
if (!f.HasTag(XMLOBJECT_TAG))
{
return(base.ExecIdCall(f, cx, scope, thisObj, args));
}
int id = f.MethodId;
if (id == Id_constructor)
{
return(JsConstructor(cx, thisObj == null, args));
}
// All XML.prototype methods require thisObj to be XML
if (!(thisObj is XMLList))
{
throw IncompatibleCallError(f);
}
XMLList realThis = (XMLList)thisObj;
XMLName xmlName;
switch (id)
{
case Id_attribute:
xmlName = XMLName.Parse(lib, cx, GetArgSafe(args, 0));
return(realThis.Attribute(xmlName));
case Id_attributes:
return(realThis.Attributes());
case Id_child:
xmlName = XMLName.Parse(lib, cx, GetArgSafe(args, 0));
if (xmlName == null)
{
long index = ScriptRuntime.lastUint32Result(cx);
return(realThis.Child(index));
}
else
{
return(realThis.Child(xmlName));
}
case Id_children:
return(realThis.Children());
case Id_contains:
return(realThis.Contains(GetArgSafe(args, 0)));
case Id_copy:
return(realThis.Copy());
case Id_descendants: {
xmlName = (args.Length == 0)
? XMLName.FormStar() : XMLName.Parse(lib, cx, GetArgSafe(args, 0));
return(realThis.Descendants(xmlName));
}
case Id_hasOwnProperty:
xmlName = XMLName.Parse(lib, cx, GetArgSafe(args, 0));
return(realThis.HasOwnProperty(xmlName));
case Id_hasComplexContent:
return(realThis.HasComplexContent());
case Id_hasSimpleContent:
return(realThis.HasSimpleContent());
case Id_length:
return(realThis.Length());
case Id_normalize:
realThis.Normalize();
return(Undefined.Value);
case Id_parent:
return(realThis.Parent());
case Id_processingInstructions:
xmlName = (args.Length > 0) ? XMLName.Parse(lib, cx, args [0]) : XMLName.FormStar();
return(realThis.ProcessingInstructions(xmlName));
case Id_propertyIsEnumerable: {
return(realThis.PropertyIsEnumerable(GetArgSafe(args, 0)));
}
case Id_text:
return(realThis.Text());
case Id_toString:
return(realThis.ToString());
case Id_toXMLString:
return(realThis.ToXMLString());
case Id_valueOf:
return(realThis);
case Id_addNamespace:
return(realThis.DelegateTo("addNamespace").AddNamespace(GetArgSafe(args, 0)));
case Id_appendChild:
return(realThis.DelegateTo("appendChild").AppendChild(GetArgSafe(args, 0)));
case Id_childIndex:
return(realThis.DelegateTo("childIndex").ChildIndex());
case Id_inScopeNamespaces:
return(realThis.DelegateTo("inScopeNamespaces").InScopeNamespaces());
case Id_insertChildAfter:
return(realThis.DelegateTo("insertChildAfter").InsertChildAfter(GetArgSafe(args, 0), GetArgSafe(args, 1)));
case Id_insertChildBefore:
return(realThis.DelegateTo("insertChildBefore").InsertChildBefore(GetArgSafe(args, 0), GetArgSafe(args, 1)));
case Id_localName:
return(realThis.DelegateTo("localName").LocalName());
case Id_name:
return(realThis.DelegateTo("name").Name());
case Id_namespace:
return(realThis.DelegateTo("namespace").Namespace(GetArgSafe(args, 0)));
case Id_namespaceDeclarations:
return(realThis.DelegateTo("namespaceDeclarations").NamespaceDeclarations());
case Id_nodeKind:
return(realThis.DelegateTo("nodeKind").NodeKind());
case Id_prependChild:
return(realThis.DelegateTo("prependChild").PrependChild(GetArgSafe(args, 0)));
case Id_removeNamespace:
return(realThis.DelegateTo("removeNamespace").RemoveNamespace(GetArgSafe(args, 0)));
case Id_replace:
return(realThis.DelegateTo("replace").Replace(GetArgSafe(args, 0), GetArgSafe(args, 1)));
case Id_setChildren:
return(realThis.DelegateTo("setChildren").SetChildren(GetArgSafe(args, 0)));
case Id_setLocalName:
realThis.DelegateTo("setLocalName").SetLocalName(GetArgSafe(args, 0));
return(Undefined.Value);
case Id_setName:
realThis.DelegateTo("setName").SetName(GetArgSafe(args, 0));
return(Undefined.Value);
case Id_setNamespace:
realThis.DelegateTo("setNamespace").SetNamespace(GetArgSafe(args, 0));
return(Undefined.Value);
}
throw new System.ArgumentException(System.Convert.ToString(id));
}
private XMLList Descendants (XMLName xmlName)
{
XMLList list = new XMLList (lib);
foreach (XML xml in this)
list.AddRange (xml.Descendants (xmlName));
return list;
}
/// <summary>
/// XML.prototype.child ( propertyName )
///
/// The child method returns the list of children in this
/// XML object matching the given propertyName. If propertyName is a numeric
/// index, the child method returns a list containing the child at the
/// ordinal position identified by propertyName.
///
/// See ECMA 13.4.4.6
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
internal XMLList Child(long index)
{
XMLList list = new XMLList (lib);
if (index > 0 || index < UnderlyingNode.ChildNodes.Count)
list.Add (new XML (lib, UnderlyingNode.ChildNodes [(int)index]));
return list;
}
private XMLList Child (long index)
{
XMLList list = new XMLList (lib);
foreach (XML xml in this)
list.AddRange (xml.Child (index));
return list;
}
/// <summary>
/// XML.prototype.processingInstructions ( [ name ] )
///
/// When the processingInstructions method is called with one
/// parameter name, it returns an XMLList containing all the
/// children of this XML object that are processing-instructions
/// with the given name. When the processingInstructions method
/// is called with no parameters, it returns an XMLList containing
/// all the children of this XML object that are processing-instructions
/// regardless of their name.
///
/// See ECMA 13.4.4.28
/// </summary>
/// <returns></returns>
internal XMLList ProcessingInstructions(XMLName xmlName)
{
XMLList list = new XMLList (lib);
foreach (XmlNode child in UnderlyingNode.ChildNodes) {
if (child is XmlProcessingInstruction) {
if (xmlName == null || xmlName.Matches (child))
list.Add (new XML (lib, child));
}
}
return list;
}
/// <summary>
/// XMLList.prototype.processingInstructions ( [ name ] )
///
/// The processingInstructions method calls the processingInstructions
/// method of each XML object in this XMLList object passing the optional
/// parameter name (or "*" if it is omitted) and returns an XMList
/// containing the results in order.
///
/// See ECMA
/// </summary>
private XMLList ProcessingInstructions (XMLName name)
{
XMLList list = new XMLList (lib);
foreach (XML xml in this) {
list.AddRange (xml.ProcessingInstructions (name));
}
return list;
}
internal XMLList GetPropertyList (XMLName xmlName)
{
XMLList list = new XMLList (lib);
foreach (XML xml in m_Nodes) {
list.AddRange (xml.GetPropertyList (xmlName));
}
return list;
}
private object Copy ()
{
XMLList list = new XMLList (lib);
foreach (XML xml in m_Nodes) {
list.Add ((XML)xml.Copy ());
}
return list;
}
/// <summary>
/// XML.prototype.elements ( [ name ] )
///
/// When the elements method is called with one parameter name,
/// it returns an XMLList containing all the children of this
/// XML object that are XML elements with the given name. When
/// the elements method is called with no parameters, it returns
/// an XMLList containing all the children of this XML object that
/// are XML elements regardless of their name.
///
/// See ECMA 13.4.4.13
/// </summary>
private XMLList Elements(XMLName xmlName)
{
if (xmlName == null)
return Children ();
XMLList list = new XMLList (lib);
MatchChildren (list, xmlName, UnderlyingNode, false);
return list;
}
internal void MatchAttributes(XMLList list, XMLName xmlName, XmlNode parent, bool recursive)
{
if (parent is XmlDocument)
parent = ((XmlDocument)parent).DocumentElement;
if (!(parent is XmlElement))
return;
foreach (XmlAttribute attr in parent.Attributes) {
if (xmlName == null || xmlName.Matches (attr))
list.Add (new XML (lib, attr));
}
if (recursive) {
foreach (XmlNode node in parent.ChildNodes)
MatchAttributes (list, xmlName, node, recursive);
}
}
/// <summary>
/// XML.prototype.attribute ( attributeName )
///
/// The attribute method returns an XMLList
/// containing zero or one XML attributes associated with
/// this XML object that have the given attributeName.
///
/// See ECMA 13.4.4.4
/// </summary>
/// <param name="xmlName"></param>
/// <returns></returns>
internal XMLList Attribute(XMLName xmlName)
{
XMLList list = new XMLList (lib);
MatchAttributes (list, xmlName, UnderlyingNode, false);
return list;
}
/// <summary>
/// XML.prototype.comments ( )
///
/// The comments method returns an XMLList containing the properties of this
/// XML object that represent XML comments.
///
/// See ECMA 13.4.4.9
/// </summary>
private XMLList Comments()
{
XMLList list = new XMLList (lib);
foreach (XmlNode child in UnderlyingNode.ChildNodes) {
if (child is XmlComment)
list.Add (new XML (lib, child));
}
return list;
}
/// <summary>
/// XMLList.prototype.child ( propertyName )
///
/// The child method calls the child() method of each XML object in
/// this XMLList object and returns an XMLList containing the results
/// in order.
///
/// See ECMA 13.5.4.4
/// </summary>
private XMLList Child (XMLName xmlName)
{
XMLList list = new XMLList (lib);
foreach (XML xml in this)
list.AddRange (xml.Child (xmlName));
return list;
}
public void MatchChildren(XMLList list, XMLName xmlName, XmlNode parent, bool recursive)
{
foreach (XmlNode child in parent.ChildNodes) {
if (xmlName.Matches (child))
list.Add (new XML (lib, child));
if (recursive)
MatchChildren (list, xmlName, child, recursive);
}
}
/// <summary>
/// XML.prototype.children ( )
///
/// The children method returns an XMLList containing all the
/// properties of this XML object in order.
///
/// See ECMA 13.4.4.8
/// </summary>
internal XMLList Children()
{
XMLList list = new XMLList (lib);
foreach (XmlNode node in UnderlyingNode.ChildNodes)
list.Add (new XML (lib, node));
return list;
}
/// <summary>
/// XML.prototype.attributes ( )
///
/// The attributes method returns an XMLList containing the XML attributes of this object.
///
/// See ECMA 13.4.4.5
/// </summary>
/// <returns></returns>
internal XMLList Attributes()
{
XMLList list = new XMLList (lib);
MatchAttributes (list, null, UnderlyingNode, false);
return list;
}
private XMLList Children ()
{
XMLList list = new XMLList (lib);
foreach (XML xml in m_Nodes) {
list.AddRange (xml.Children ());
}
return list;
}
/// <summary>
/// XML.prototype.child ( propertyName )
///
/// The child method returns the list of children in this
/// XML object matching the given propertyName. If propertyName is a numeric
/// index, the child method returns a list containing the child at the
/// ordinal position identified by propertyName.
///
/// See ECMA 13.4.4.6
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
internal XMLList Child(XMLName xmlName)
{
XMLList list = new XMLList (lib);
MatchChildren (list, xmlName, UnderlyingNode, false);
return list;
}
protected internal override object GetXMLProperty (XMLName name)
{
if (isPrototype) {
return base.Get (name.localName, this);
}
XMLList list = new XMLList (lib);
foreach (XML xml in m_Nodes) {
list.AddRange ((XMLList)xml.GetXMLProperty (name));
}
return list;
}
/// <summary>
/// XML.prototype.descendants ( [ name ] )
///
/// The descendants method returns all the XML valued descendants
/// (children, grandchildren, great-grandchildren, etc.) of this XML
/// object with the given name. If the name parameter is omitted,
/// it returns all descendants of this XML object.
///
/// See ECMA 13.4.4.12
/// </summary>
/// <param name="xmlName"></param>
/// <returns></returns>
internal XMLList Descendants(XMLName xmlName)
{
XMLList list = new XMLList (lib);
if (xmlName.IsAttributeName) {
MatchAttributes (list, xmlName, UnderlyingNode, true);
}
else {
MatchChildren (list, xmlName, UnderlyingNode, true);
}
return list;
}
internal void AddRange (XMLList list)
{
foreach (XML xml in list.m_Nodes)
Add (xml);
}