wsman-xml.i xml structure accessors for openwsman swig bindings Document-class: XmlNs Xml namespace /
%rename(XmlNs) __WsXmlNs; %nodefault __WsXmlNs; /* part of WsXmlAttr
struct __WsXmlNs {}; /* without empty struct, the %rename isn't executed. */ typedef struct __WsXmlNs* WsXmlNsH;
/*
XmlDoc Implementation advice DONT do a %newobject on functions returning WsXmlDoc. Swig will free the WsXmlDocH immediately after wrapping ! /
%rename(XmlDoc) _WsXmlDoc; %nodefault _WsXmlDoc; struct _WsXmlDoc {}; typedef struct _WsXmlDoc* WsXmlDocH;
/*
Document-class: XmlDoc XmlDoc holds an XML document and thus represents the root of an XML tree. XmlDoc is optimized for SOAP type documents, giving accessors to the SOAP envelope, header and body. Instances of the other XML related classes like XmlAttr and XmlNode can only be created with an associated XmlDoc instance. Main properties of the XML document are name of the root element encoding (defaults to _UTF-8_) /
%extend _WsXmlDoc {
/* Create XmlDoc with node name optionally pass namespace as 2nd arg (defaults to NULL) / _WsXmlDoc(const char *name, const char *ns = NULL) { return ws_xml_create_doc(ns, name); } /* destructor */ ~_WsXmlDoc() { ws_xml_destroy_doc( $self ); } %typemap(newfree) char * "free($1);";
if defined(SWIGRUBY)
%alias string "to_xml";
endif if defined(SWIGPYTHON)
%rename("__str__") string();
endif if defined(SWIGJAVA)
%rename("toString") string();
endif
%newobject string; /* generic (indented) string representation of the XmlDoc UTF-8 encoded. see encode for setting the encoding. alias: to_xml call-seq: doc.string -> String doc.to_xml -> String / char *string() { int size; char *buf; /* force utf-8 encoding since e.g. winrm sends utf-16 */ ws_xml_dump_memory_node_tree_enc( ws_xml_get_doc_root($self), &buf, &size, "UTF-8" ); return buf; }
if defined(SWIGRUBY)
%alias encode "to_s";
endif
%newobject encode; /* encode document as string with specific encoding (non-indented representation) encoding defaults to 'utf-8' alias: to_s call-seq: doc.encode -> String doc.encode("UTF-16") -> String doc.to_s -> string / char *encode(const char *encoding = "utf-8") { int size; char *buf; ws_xml_dump_memory_enc( $self, &buf, &size, encoding ); return buf; } /* dump document to file call-seq: doc.dump(IO) -> nil / void dump_file(FILE *fp) { ws_xml_dump_doc( fp, $self ); } /* get root node of doc call-seq: doc.root -> XmlNode / WsXmlNodeH root() { return ws_xml_get_doc_root( $self ); } /* get soap envelope node call-seq: doc.envelope -> XmlNode / WsXmlNodeH envelope() { return ws_xml_get_soap_envelope( $self ); } /* get soap header node call-seq: doc.header -> XmlNode / WsXmlNodeH header() { return ws_xml_get_soap_header( $self ); } /* get soap body node call-seq: doc.body -> XmlNode / WsXmlNodeH body() { return ws_xml_get_soap_body( $self ); } /* get soap element node by name returns nil if no element with the name can be found call-seq: doc.element(String) -> XmlNode / WsXmlNodeH element(const char *name) { return ws_xml_get_soap_element( $self, name ); } %newobject context; /* get enumeration context as string return nil if context not present or empty call-seq: doc.context -> String / const char *context() { char *c = wsmc_get_enum_context( $self ); if (c) { if (*c) return c; u_free(c); } return NULL; } /* Generate fault document based on given status This creates a new XmlDoc instance representing a fault call-seq: doc.generate_fault(Openwsman::Status) -> XmlDoc / WsXmlDocH generate_fault(WsmanStatus *s) { return wsman_generate_fault( $self, s->fault_code, s->fault_detail_code, s->fault_msg); }
if defined(SWIGRUBY)
%rename("fault?") is_fault(); %typemap(out) int is_fault "$result = ($1 != 0) ? Qtrue : Qfalse;";
endif if defined(SWIGJAVA)
%rename("isFault") is_fault(); %typemap(jstype) int is_fault "boolean" %typemap(javaout) int is_fault { return ( $jnicall != 0 ) ? true : false; }
endif
/* Check if document represents a fault call-seq: doc.fault?(XmlDoc) -> Boolean / int is_fault() { return wsmc_check_for_fault( $self ); } %newobject fault; /* retrieve fault data call-seq: doc.fault(XmlDoc) -> Openwsman::Fault doc.fault(XmlDoc) -> nil # if XmlDoc is not a fault / WsManFault *fault() { WsManFault *f = NULL; if (wsmc_check_for_fault($self)) { f = (WsManFault *)calloc(1, sizeof(WsManFault)); wsmc_get_fault_data($self, f); } return f; } /* Generate response envelope document, optionally relating to a specific action. This creates a new XmlDoc instance representing a response. call-seq: doc.create_response_envelope(String action) -> XmlDoc / WsXmlDocH create_response_envelope(const char *action = NULL) { return wsman_create_response_envelope($self, action); }
if defined(SWIGRUBY)
%rename("end_of_sequence?") is_end_of_sequence(); %typemap(out) int is_end_of_sequence "$result = ($1 != 0) ? Qtrue : Qfalse;";
endif
/* Check if document represents an end of sequence (last enumeration item) call-seq: doc.is_end_of_sequence() -> Boolean / int is_end_of_sequence() { return NULL != ws_xml_find_in_tree( ws_xml_get_soap_body( $self ), XML_NS_ENUMERATION, WSENUM_END_OF_SEQUENCE, 1 ); }
}
/*
Document-class: XmlNode XmlNode is a node inside the XML document tree. A node has a name a namespace (optional) attributes text (optional) a parent a document (root) children (empty for tail nodes) /
%rename(XmlNode) __WsXmlNode; %nodefault __WsXmlNode; struct __WsXmlNode {}; /* without empty struct, the %rename isn't executed. */ typedef struct __WsXmlNode* WsXmlNodeH;
%extend __WsXmlNode {
~__WsXmlNode() { ws_xml_unlink_node($self); }
if defined(SWIGRUBY)
%alias text "to_s"; %alias string "to_xml";
endif if defined(SWIGPYTHON)
%rename("__str__") text();
endif if defined(SWIGJAVA)
%rename("toString") text(); %rename("toXML") string();
endif
%newobject string; /* dump node as XML string alias: to_xml call-seq: node.string(XmlNode) -> String / char *string() { int size; char *buf; ws_xml_dump_memory_node_tree( $self, &buf, &size ); return buf; } /* dump node to file call-seq: node.dump_file(IO) -> nil / void dump_file(FILE *fp) { ws_xml_dump_node_tree( fp, $self ); }
if defined(SWIGRUBY)
%alias equal "=="; %typemap(out) int equal "$result = ($1 != 0) ? Qtrue : Qfalse;";
endif if defined(SWIGPERL)
int __eq__( WsXmlNodeH n )
else
int equal( WsXmlNodeH n )
endif
/* Test for identity (same object) call-seq: XmlNode == XmlNode -> Boolean / { return $self == n; } /* get text (without xml tags) of node alias: to_s call-seq: node.text(XmlNode) -> String / char *text() { return ws_xml_get_node_text( $self ); }
if defined(SWIGRUBY)
%rename( "text=" ) set_text( const char *text );
endif
/* Set text of node call-seq: node.text = String / void set_text( const char *text ) { ws_xml_set_node_text( $self, text ); } /* get XmlDoc to which node belongs call-seq: node.doc -> XmlDoc / WsXmlDocH doc() { return ws_xml_get_node_doc( $self ); } /* get parent for node call-seq: node.parent -> XmlNode / WsXmlNodeH parent() { return ws_xml_get_node_parent( $self ); }
if defined(SWIGRUBY)
%alias child "first";
endif
/* get first child of node call-seq: node.child -> XmlNode / WsXmlNodeH child() { return xml_parser_get_first_child($self); } /* get name for node call-seq: node.name -> String / char *name() { return ws_xml_get_node_local_name( $self ); }
if defined(SWIGRUBY)
%rename("name=") set_name( const char *name);
endif
/* set name of node call-seq: node.name = String / void set_name( const char *name ) { ws_xml_set_node_name( $self, ws_xml_get_node_name_ns( $self ), name ); } /* get namespace for node call-seq: node.ns -> String / char *ns() { return ws_xml_get_node_name_ns( $self ); }
if defined(SWIGRUBY)
%rename("ns=") set_ns( const char *nsuri );
endif
/* set namespace of node call-seq: node.ns = String / void set_ns( const char *ns ) { ws_xml_set_ns( $self, ns, ws_xml_get_node_name_ns_prefix($self) ); } /* get prefix of nodes namespace call-seq: node.prefix -> String / const char *prefix() { return ws_xml_get_node_name_ns_prefix($self); }
if defined(SWIGRUBY)
%rename("lang=") set_lang(const char *lang);
endif
/* set language call-seq: node.lang = String / void set_lang(const char *lang) { ws_xml_set_node_lang($self, lang); } /* find node within tree a NULL passed as 'ns' (namespace) is treated as wildcard call-seq: node.find("namespace", "name") -> String # recursive node.find("namespace", "name", 0) -> String # non-recursive / WsXmlNodeH find( const char *ns, const char *name, int recursive = 1) { return ws_xml_find_in_tree( $self, ns, name, recursive ); } /* iterate over siblings finds next sibling with same namespace and name See also XmlNode#each XmlNode#each iterates over children, XmlNode#next over siblings Example: <Foo> <Bar>... <Bar>... <Bar>... <Bar>... <Other>... <Other>... </Foo> node = root.Foo # points to <Foo> node bar = node.Bar while bar do bar = bar.next end will give you four iterations (all <Bar> nodes) child = node.Bar while child do child = child.next(1) end will give you six iterations (all children of <Foo>) The latter example is equal to node.each do |child| ... end / WsXmlNodeH next(int all = 0) { WsXmlNodeH next_node = xml_parser_get_next_child($self); if (next_node && !all) { const char *ns_uri = ws_xml_get_node_name_ns($self); const char *name = ws_xml_get_node_local_name($self); if (ws_xml_is_node_qname(next_node, ns_uri, name) == 0) { next_node = NULL; } } return next_node; } /* count node children if name given, count children with this name if name + ns given, count children with this namespace and name / int size(const char *name = NULL, const char *ns = NULL) { return ws_xml_get_child_count_by_qname($self, ns, name); } /* add child (namespace, name, text) to node / WsXmlNodeH add( const char *ns, const char *name, const char *text = NULL ) { return ws_xml_add_child( $self, ns, name, text ); } /* add child (namespace, name, text) before(!) node / WsXmlNodeH add_before( const char *ns, const char *name, const char *text = NULL ) { return ws_xml_add_prev_sibling( $self, ns, name, text ); }
if defined(SWIGRUBY)
%alias add "<<";
endif
/* add node as child / WsXmlNodeH add(WsXmlNodeH node) { ws_xml_duplicate_tree( $self, node ); return $self; }
if defined(SWIGRUBY)
/* iterate over children See also XmlNode#next XmlNode#each iterates over children, XmlNode#next over siblings can be limited to children with specific name (and specific namespace) for array-like constructs, e.g <Parent> <Child>.. <Child>.. <Child>.. <OtherChild>.. <OtherChild>.. <OtherChild>.. doc.Parent.each do |child| ... iterates over all 6 children ... end use XmlNode#next as in node = doc.OtherChild while node do ... do something with node ... node = node.next end call-seq: node.each { |XmlNode| ... } node.each("name") { |XmlNode| ... } node.each("name", "namespace") { |XmlNode| ... } / void each(const char *name = NULL, const char *ns = NULL) { int i = 0; WsXmlNodeH node = $self; int count = ws_xml_get_child_count_by_qname( node, ns, name ); while ( i < count ) { rb_yield( SWIG_NewPointerObj((void*) ws_xml_get_child(node, i, ns, name), SWIGTYPE_p___WsXmlNode, 0)); ++i; } }
endif
if defined(SWIGPYTHON)
/* iterate over children / %pythoncode %{ def __iter__(self): r = range(0,self.size()) while r: yield self.get(r.pop(0)) %}
endif
if defined(SWIGRUBY)
%alias get "[]";
endif
/* get child by index call-seq: node.get(42) -> XmlNode node.get(42, "name") -> XmlNode node.get(42, "name", "namespace") -> XmlNode / WsXmlNodeH get(int i, const char *name = NULL, const char *ns = NULL) { if (i < 0 || i >= ws_xml_get_child_count_by_qname($self,ns,name)) return NULL; return ws_xml_get_child($self, i, ns, name); } /* get first child by name (and namespace) call-seq: node.get("name") -> XmlNode node.get("name", "namespace") -> XmlNode / WsXmlNodeH get(const char *name, const char *ns = NULL) { return ws_xml_get_child($self, 0, ns, name); }
if defined(SWIGRUBY)
/* get node attribute by index or name call-seq: node.attr(1) -> XmlAttr node.attr("name") -> XmlAttr node.attr("name", "namespace") -> XmlAttr / WsXmlAttrH attr(VALUE index = Qnil, VALUE namespace = Qnil) { if (NIL_P(index)) { /* nil */ return ws_xml_get_node_attr( $self, 0 ); } else if (FIXNUM_P(index)) { /* numeric */ return ws_xml_get_node_attr( $self, FIX2INT(index) ); } else { /* convert to string */ const char *ns = NULL; const char *name = as_string(index); if (!NIL_P(namespace)) { ns = as_string(namespace); } return ws_xml_find_node_attr( $self, ns, name ); } }
else
/* get node attribute */ WsXmlAttrH attr(int index = 0) { return ws_xml_get_node_attr( $self, index ); }
endif
/* count node attribute call-seq: node.attr_count -> Integer / int attr_count() { return ws_xml_get_node_attr_count( $self ); } /* find node attribute by name call-seq: node.attr_find("namespace", "name") -> XmlAttr / WsXmlAttrH attr_find( const char *ns, const char *name ) { return ws_xml_find_node_attr( $self, ns, name ); } /* add attribute to node call-seq: node.attr_add("namespace", "name", "value") -> XmlAttr / WsXmlAttrH attr_add( const char *ns, const char *name, const char *value ) { return ws_xml_add_node_attr( $self, ns, name, value ); } /* get end point reference call-seq: node.epr("namespace", "epr_node_name", Integer embedded) -> EndPointReference / epr_t *epr( const char *ns, const char *epr_node_name, int embedded) { return epr_deserialize($self, ns, epr_node_name, embedded); }
if defined(SWIGRUBY)
/* enumerate attributes call-seq: node.each_attr { |XmlAttr| ... } / void each_attr() { int i = 0; while ( i < ws_xml_get_node_attr_count( $self ) ) { rb_yield( SWIG_NewPointerObj((void*) ws_xml_get_node_attr($self, i), SWIGTYPE_p___WsXmlAttr, 0)); ++i; } }
endif }
/*
Document-class: XmlAttr An XmlAttr is a key/value pair representing an attribute of a node. An attribute has a name (the key) a namespace (optional) a value There is no standalone constructor available for XmlAttr, use XmlNode.add_attr() to create a new attribute. /
%rename(XmlAttr) __WsXmlAttr; %nodefault __WsXmlAttr; /* part of WsXmlNode */ struct __WsXmlAttr {}; /* without empty struct, the %rename isn't executed. */ typedef struct __WsXmlAttr* WsXmlAttrH;
%extend __WsXmlAttr { if defined(SWIGRUBY)
%alias value "to_s";
endif
/* get name for attr call-seq: attr.name -> String / char *name() { return ws_xml_get_attr_name( $self ); } /* get namespace for attr call-seq: attr.ns -> String / char *ns() { return ws_xml_get_attr_ns( $self ); } /* get value for attr call-seq: attr.value -> String / char *value() { return ws_xml_get_attr_value( $self ); } /* remove note attribute call-seq: attr.remove -> nil / void remove() { ws_xml_remove_node_attr( $self ); }
}