xmltooling/XMLObjectBuilder.cpp

   1 /*
   2  *  Copyright 2001-2010 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  * XMLObjectBuilder.cpp
  19  *
  20  * Factory interface for XMLObjects
  21  */
  22
  23 #include "internal.h"
  24 #include "logging.h"
  25 #include "ConcreteXMLObjectBuilder.h"
  26 #include "util/NDC.h"
  27 #include "util/XMLHelper.h"
  28
  29 using namespace xmltooling::logging;
  30 using namespace xmltooling;
  31 using namespace std;
  32
  33 using xercesc::DOMDocument;
  34 using xercesc::DOMElement;
  35
  36 map<QName,XMLObjectBuilder*> XMLObjectBuilder::m_map;
  37 XMLObjectBuilder* XMLObjectBuilder::m_default = nullptr;
  38
  39 XMLObjectBuilder::XMLObjectBuilder()
  40 {
  41 }
  42
  43 XMLObjectBuilder::~XMLObjectBuilder()
  44 {
  45 }
  46
  47 XMLObject* XMLObjectBuilder::buildFromQName(const QName& q) const
  48 {
  49     return buildObject(q.getNamespaceURI(),q.getLocalPart(),q.getPrefix());
  50 }
  51
  52 XMLObject* XMLObjectBuilder::buildFromElement(DOMElement* element, bool bindDocument) const
  53 {
  54     auto_ptr<XMLObject> ret(
  55         buildObject(element->getNamespaceURI(),element->getLocalName(),element->getPrefix(),XMLHelper::getXSIType(element))
  56         );
  57     ret->unmarshall(element,bindDocument);
  58     return ret.release();
  59 }
  60
  61 XMLObject* XMLObjectBuilder::buildFromDocument(DOMDocument* doc, bool bindDocument) const
  62 {
  63     return buildFromElement(doc->getDocumentElement(),bindDocument);
  64 }
  65
  66 XMLObject* XMLObjectBuilder::buildOneFromElement(xercesc::DOMElement* element, bool bindDocument)
  67 {
  68     const XMLObjectBuilder* b=getBuilder(element);
  69     return b ? b->buildFromElement(element,bindDocument) : nullptr;
  70 }
  71
  72 const XMLObjectBuilder* XMLObjectBuilder::getBuilder(const QName& key)
  73 {
  74     map<QName,XMLObjectBuilder*>::const_iterator i=m_map.find(key);
  75     return (i==m_map.end()) ? nullptr : i->second;
  76 }
  77
  78 const XMLObjectBuilder* XMLObjectBuilder::getBuilder(const DOMElement* domElement)
  79 {
  80 #ifdef _DEBUG
  81     xmltooling::NDC ndc("getBuilder");
  82 #endif
  83     Category& log=Category::getInstance(XMLTOOLING_LOGCAT".XMLObject.Builder");
  84
  85     auto_ptr<QName> schemaType(XMLHelper::getXSIType(domElement));
  86     const XMLObjectBuilder* xmlObjectBuilder = schemaType.get() ? getBuilder(*(schemaType.get())) : nullptr;
  87     if (xmlObjectBuilder) {
  88         if (log.isDebugEnabled()) {
  89             log.debug("located XMLObjectBuilder for schema type: %s", schemaType->toString().c_str());
  90         }
  91         return xmlObjectBuilder;
  92     }
  93
  94     auto_ptr<QName> elementName(XMLHelper::getNodeQName(domElement));
  95     xmlObjectBuilder = getBuilder(*(elementName.get()));
  96     if (xmlObjectBuilder) {
  97         if (log.isDebugEnabled()) {
  98             log.debug("located XMLObjectBuilder for element name: %s", elementName->toString().c_str());
  99         }
 100         return xmlObjectBuilder;
 101     }
 102
 103     if (log.isDebugEnabled()) {
 104         log.debug("no XMLObjectBuilder registered for element (%s), returning default", elementName->toString().c_str());
 105     }
 106     return m_default;
 107 }
 108
 109 const XMLObjectBuilder* XMLObjectBuilder::getDefaultBuilder()
 110 {
 111     return m_default;
 112 }
 113
 114 const map<QName,XMLObjectBuilder*>& XMLObjectBuilder::getBuilders()
 115 {
 116     return m_map;
 117 }
 118
 119 void XMLObjectBuilder::registerBuilder(const QName& builderKey, XMLObjectBuilder* builder)
 120 {
 121     deregisterBuilder(builderKey);
 122     m_map[builderKey]=builder;
 123 }
 124
 125 void XMLObjectBuilder::registerDefaultBuilder(XMLObjectBuilder* builder)
 126 {
 127     deregisterDefaultBuilder();
 128     m_default=builder;
 129 }
 130
 131 void XMLObjectBuilder::deregisterBuilder(const QName& builderKey)
 132 {
 133     delete getBuilder(builderKey);
 134     m_map.erase(builderKey);
 135 }
 136
 137 void XMLObjectBuilder::deregisterDefaultBuilder()
 138 {
 139     delete m_default;
 140     m_default = nullptr;
 141 }
 142
 143 void XMLObjectBuilder::destroyBuilders()
 144 {
 145     for_each(m_map.begin(),m_map.end(),cleanup_pair<QName,XMLObjectBuilder>());
 146     m_map.clear();
 147     deregisterDefaultBuilder();
 148 }
 149
 150 ConcreteXMLObjectBuilder::ConcreteXMLObjectBuilder()
 151 {
 152 }
 153
 154 ConcreteXMLObjectBuilder::~ConcreteXMLObjectBuilder()
 155 {
 156 }