xmltooling/AbstractXMLObject.h

   1 /*
   2 *  Copyright 2001-2007 Internet2
   3  *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /**
  18  * @file xmltooling/AbstractXMLObject.h
  19  *
  20  * An abstract implementation of XMLObject.
  21  */
  22
  23 #ifndef __xmltooling_abstractxmlobj_h__
  24 #define __xmltooling_abstractxmlobj_h__
  25
  26 #include <xmltooling/logging.h>
  27 #include <xmltooling/XMLObject.h>
  28 #include <xmltooling/util/DateTime.h>
  29
  30 #if defined (_MSC_VER)
  31     #pragma warning( push )
  32     #pragma warning( disable : 4250 4251 )
  33 #endif
  34
  35 namespace xmltooling {
  36
  37     /**
  38      * An abstract implementation of XMLObject.
  39      * This is the primary concrete base class, and supplies basic namespace,
  40      * type, and parent handling. Most implementation classes should not
  41      * directly inherit from this class, but rather from the various mixins
  42      * that supply the rest of the XMLObject interface, as required.
  43      */
  44     class XMLTOOL_API AbstractXMLObject : public virtual XMLObject
  45     {
  46     public:
  47         virtual ~AbstractXMLObject() {
  48             delete m_typeQname;
  49             xercesc::XMLString::release(&m_schemaLocation);
  50             xercesc::XMLString::release(&m_noNamespaceSchemaLocation);
  51         }
  52
  53         void detach();
  54
  55         const QName& getElementQName() const {
  56             return m_elementQname;
  57         }
  58
  59         const std::set<Namespace>& getNamespaces() const {
  60             return m_namespaces;
  61         }
  62
  63         void addNamespace(const Namespace& ns) const {
  64             std::set<Namespace>::iterator i = m_namespaces.find(ns);
  65             if (i == m_namespaces.end())
  66                 m_namespaces.insert(ns);
  67             else if (ns.alwaysDeclare())
  68                 const_cast<Namespace&>(*i).setAlwaysDeclare(true);
  69         }
  70
  71         void removeNamespace(const Namespace& ns) {
  72             m_namespaces.erase(ns);
  73         }
  74
  75         const QName* getSchemaType() const {
  76             return m_typeQname;
  77         }
  78
  79         const XMLCh* getXMLID() const {
  80             return NULL;
  81         }
  82
  83         bool hasParent() const {
  84             return m_parent != NULL;
  85         }
  86
  87         XMLObject* getParent() const {
  88             return m_parent;
  89         }
  90
  91         void setParent(XMLObject* parent) {
  92             m_parent = parent;
  93         }
  94
  95      protected:
  96         /**
  97          * Constructor
  98          *
  99          * @param nsURI         the namespace of the element
 100          * @param localName     the local name of the XML element this Object represents
 101          * @param prefix        the namespace prefix to use
 102          * @param schemaType    the xsi:type to use
 103          */
 104         AbstractXMLObject(
 105             const XMLCh* nsURI=NULL, const XMLCh* localName=NULL, const XMLCh* prefix=NULL, const QName* schemaType=NULL
 106             );
 107
 108         /** Copy constructor. */
 109         AbstractXMLObject(const AbstractXMLObject& src);
 110
 111         /**
 112          * A helper function for derived classes, for assignment of strings.
 113          *
 114          * This 'normalizes' newString, and then if it is different from oldString,
 115          * it invalidates the DOM, frees the old string, and returns the new.
 116          * If not different, it frees the new string and just returns the old value.
 117          *
 118          * @param oldValue - the current value
 119          * @param newValue - the new value
 120          *
 121          * @return the value that should be assigned
 122          */
 123         XMLCh* prepareForAssignment(XMLCh* oldValue, const XMLCh* newValue);
 124
 125         /**
 126          * A helper function for derived classes, for assignment of date/time data.
 127          *
 128          * It invalidates the DOM, frees the old object, and returns the new.
 129          *
 130          * @param oldValue - the current value
 131          * @param newValue - the new value
 132          *
 133          * @return the value that should be assigned
 134          */
 135         DateTime* prepareForAssignment(DateTime* oldValue, const DateTime* newValue);
 136
 137         /**
 138          * A helper function for derived classes, for assignment of date/time data.
 139          *
 140          * It invalidates the DOM, frees the old object, and returns the new.
 141          *
 142          * @param oldValue - the current value
 143          * @param newValue - the epoch to assign as the new value
 144          *
 145          * @return the value that should be assigned
 146          */
 147         DateTime* prepareForAssignment(DateTime* oldValue, time_t newValue);
 148
 149         /**
 150          * A helper function for derived classes, for assignment of date/time data.
 151          *
 152          * It invalidates the DOM, frees the old object, and returns the new.
 153          *
 154          * @param oldValue - the current value
 155          * @param newValue - the new value in string form
 156          *
 157          * @return the value that should be assigned
 158          */
 159         DateTime* prepareForAssignment(DateTime* oldValue, const XMLCh* newValue);
 160
 161         /**
 162          * A helper function for derived classes, for assignment of QName data.
 163          *
 164          * It invalidates the DOM, frees the old object, and returns the new.
 165          *
 166          * @param oldValue - the current value
 167          * @param newValue - the new value
 168          *
 169          * @return the value that should be assigned
 170          */
 171         QName* prepareForAssignment(QName* oldValue, const QName* newValue);
 172
 173         /**
 174          * A helper function for derived classes, for assignment of (singleton) XML objects.
 175          *
 176          * It is indifferent to whether either the old or the new version of the value is null.
 177          * This method will do a safe compare of the objects and will also invalidate the DOM if appropriate.
 178          * Note that since the new value (even if NULL) is always returned, it may be more efficient
 179          * to discard the return value and just assign independently if a dynamic cast would be involved.
 180          *
 181          * @param oldValue - current value
 182          * @param newValue - proposed new value
 183          * @return the new value
 184          *
 185          * @throws XMLObjectException if the new child already has a parent.
 186          */
 187         XMLObject* prepareForAssignment(XMLObject* oldValue, XMLObject* newValue);
 188
 189         /**
 190          * Set of namespaces associated with the object.
 191          */
 192         mutable std::set<Namespace> m_namespaces;
 193
 194         /**
 195          * Logging object.
 196          */
 197         logging::Category& m_log;
 198
 199         /**
 200          * Stores off xsi:schemaLocation attribute.
 201          */
 202         XMLCh* m_schemaLocation;
 203
 204         /**
 205          * Stores off xsi:noNamespaceSchemaLocation attribute.
 206          */
 207         XMLCh* m_noNamespaceSchemaLocation;
 208
 209     private:
 210         XMLObject* m_parent;
 211         QName m_elementQname;
 212         QName* m_typeQname;
 213     };
 214
 215 };
 216
 217 #if defined (_MSC_VER)
 218     #pragma warning( pop )
 219 #endif
 220
 221 #endif /* __xmltooling_abstractxmlobj_h__ */