| /* |
| * 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 ); |
| } |
| } |
| |