/usr/include/arc/message/SOAPEnvelope.h is in nordugrid-arc-dev 5.0.5-1ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 | #ifndef __ARC_SOAPENVELOP_H__
#define __ARC_SOAPENVELOP_H__
#include <string>
#include <arc/XMLNode.h>
namespace Arc {
class SOAPEnvelope;
/// Interface to SOAP Fault message.
/** SOAPFault class provides a convenience interface for accessing elements
of SOAP faults. It also tries to expose single interface for both version
1.0 and 1.2 faults. This class is not intended to 'own' any information
stored. It's purpose is to manipulate information which is kept under
control of XMLNode or SOAPEnvelope classes. If instance does not refer to
valid SOAP Fault structure all manipulation methods will have no effect. */
class SOAPFault {
friend class SOAPEnvelope;
private:
bool ver12; /** true if SOAP version is 1.2 */
XMLNode fault; /** Fault element of SOAP */
XMLNode code; /** Code element of SOAP Fault */
XMLNode reason; /** Reason element of SOAP Fault */
XMLNode node; /** Node element of SOAP Fault */
XMLNode role; /** Role element of SOAP Fault */
XMLNode detail; /** Detail element of SOAP Fault */
public:
/** Fault codes of SOAP specs */
typedef enum {
undefined,
unknown,
VersionMismatch,
MustUnderstand,
Sender, /* Client in SOAP 1.0 */
Receiver, /* Server in SOAP 1.0 */
DataEncodingUnknown
} SOAPFaultCode;
/** Parse Fault elements of SOAP Body or any other XML tree with Fault element */
SOAPFault(XMLNode body);
/** Creates Fault element inside @body SOAP Body node with specified @code and @reason.
Version of Fault element is picked from SOAP Body version. */
SOAPFault(XMLNode body,SOAPFaultCode code,const char* reason);
/** Creates Fault element inside @body SOAP Body node with specified @code and @reason.
SOAP version of Fault element must be specified explicitly. */
SOAPFault(XMLNode body,SOAPFaultCode code,const char* reason,bool ver12);
/** Returns true if instance refers to SOAP Fault */
operator bool(void) { return (bool)fault; };
/** Returns top level Fault element.
This element is not automatically created. */
operator XMLNode(void) { return fault; };
/** Returns Fault Code element */
SOAPFaultCode Code(void);
/** Set Fault Code element */
void Code(SOAPFaultCode code);
/** Returns Fault Subcode element at various levels (0 is for Code) */
std::string Subcode(int level);
/** Set Fault Subcode element at various levels (0 is for Code) to 'subcode' */
void Subcode(int level,const char* subcode);
/** Returns content of Fault Reason element at various levels */
std::string Reason(int num = 0);
/** Set Fault Reason content at various levels to 'reason' */
void Reason(int num,const char* reason);
/** Set Fault Reason element at top level */
void Reason(const char* reason) { Reason(0,reason); };
/** Set Fault Reason element at top level */
void Reason(const std::string &reason) { Reason(0, reason.c_str()); };
/** Returns content of Fault Node element */
std::string Node(void);
/** Set content of Fault Node element to 'node' */
void Node(const char* node);
/** Returns content of Fault Role element */
std::string Role(void);
/** Set content of Fault Role element to 'role' */
void Role(const char* role);
/** Access Fault Detail element. If create is set to true this element is created if not present. */
XMLNode Detail(bool create = false);
/** Convenience method for creating SOAP Fault message.
Returns full SOAP message representing Fault with
specified code and reason. */
static SOAPEnvelope* MakeSOAPFault(SOAPFaultCode code,const std::string& reason = "");
};
/// Extends XMLNode class to support structures of SOAP message.
/** All XMLNode methods are exposed by inheriting from XMLNode and if
used are applied to Body part of SOAP. Direct access to whole SOAP
message/Envelope is not provided in order to protect internal
variables - although full protection is not possible. */
class SOAPEnvelope: public XMLNode {
public:
typedef enum {
Version_1_1,
Version_1_2
} SOAPVersion;
/** Create new SOAP message from textual representation of XML document.
Created XML structure is owned by this instance.
This constructor also sets default namespaces to default prefixes
as specified below. */
SOAPEnvelope(const std::string& xml);
/** Same as previous */
SOAPEnvelope(const char* xml,int len = -1);
/** Create new SOAP message with specified namespaces.
Created XML structure is owned by this instance.
If argument fault is set to true created message is fault. */
SOAPEnvelope(const NS& ns,bool fault = false);
/** Acquire XML document as SOAP message.
Created XML structure is NOT owned by this instance. */
SOAPEnvelope(XMLNode root);
/** Create a copy of another SOAPEnvelope object. */
SOAPEnvelope(const SOAPEnvelope& soap);
~SOAPEnvelope(void);
/** Creates complete copy of SOAP.
Do not use New() method of XMLNode for copying whole SOAP - use this one. */
SOAPEnvelope* New(void);
/** Swaps internals of two SOAPEnvelope instances.
This method is identical to XMLNode::Swap() but also takes into account
all internals of SOAPEnvelope class. */
void Swap(SOAPEnvelope& soap);
/** Swaps SOAP message and generic XML tree.
XMLNode variable gets whole SOAP message and this instance is filled
with content of analyzed XMLNode like in case of SOAPEnvelope(XMLNode)
constructor. Ownerships are swapped too. */
void Swap(Arc::XMLNode& soap);
/** Modify assigned namespaces.
Default namespaces and prefixes are
soap-enc http://schemas.xmlsoap.org/soap/encoding/
soap-env http://schemas.xmlsoap.org/soap/envelope/
xsi http://www.w3.org/2001/XMLSchema-instance
xsd http://www.w3.org/2001/XMLSchema
*/
void Namespaces(const NS& namespaces);
NS Namespaces(void);
// Setialize SOAP message into XML document
void GetXML(std::string& out_xml_str,bool user_friendly = false) const;
/** Get SOAP header as XML node. */
XMLNode Header(void) { return header; };
/** Get SOAP body as XML node.
It is not necessary to use this method because instance of this class
itself represents SOAP Body. */
XMLNode Body(void) { return body; };
/** Returns true if message is Fault. */
bool IsFault(void) { return fault != NULL; };
/** Get Fault part of message. Returns NULL if message is not Fault. */
SOAPFault* Fault(void) { return fault; };
/** Makes this object a copy of another SOAPEnvelope object. */
SOAPEnvelope& operator=(const SOAPEnvelope& soap);
SOAPVersion Version(void) { return ver12?Version_1_2:Version_1_1; };
protected:
XMLNode envelope; /** Envelope element of SOAP and owner of XML tree */
XMLNode header; /** Header element of SOAP */
XMLNode body; /** Body element of SOAP */
private:
bool ver12; /** Is true if SOAP version 1.2 is used */
SOAPFault* fault; /**Fault element of SOAP, NULL if message is not a fault. */
/** Fill instance variables parent XMLNode class.
This method is called from constructors. */
void set(void);
/** Decodes SOAP message encoded according to SOAP Encoding rules.
Currently only internal href/id links are supported. */
void decode(void);
void decode(XMLNode node);
XMLNode findid(XMLNode parent,const std::string& id);
};
} // namespace Arc
#endif /* __ARC_SOAPENVELOP_H__ */
|