xmltooling/XMLObjectBuilder.cpp

   1 /**
   2  * Licensed to the University Corporation for Advanced Internet
   3  * Development, Inc. (UCAID) under one or more contributor license
   4  * agreements. See the NOTICE file distributed with this work for
   5  * additional information regarding copyright ownership.
   6  *
   7  * UCAID licenses this file to you under the Apache License,
   8  * Version 2.0 (the "License"); you may not use this file except
   9  * in compliance with the License. You may obtain a copy of the
  10  * License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing,
  15  * software distributed under the License is distributed on an
  16  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
  17  * either express or implied. See the License for the specific
  18  * language governing permissions and limitations under the License.
  19  */
  20
  21 /**
  22  * XMLObjectBuilder.cpp
  23  *
  24  * Factory interface for XMLObjects
  25  */
  26
  27 #include "internal.h"
  28 #include "logging.h"
  29 #include "ConcreteXMLObjectBuilder.h"
  30 #include "util/NDC.h"
  31 #include "util/XMLHelper.h"
  32
  33 using namespace xmltooling::logging;
  34 using namespace xmltooling;
  35 using namespace std;
  36
  37 using xercesc::DOMDocument;
  38 using xercesc::DOMElement;
  39
  40 map<QName,XMLObjectBuilder*> XMLObjectBuilder::m_map;
  41 XMLObjectBuilder* XMLObjectBuilder::m_default = nullptr;
  42
  43 XMLObjectBuilder::XMLObjectBuilder()
  44 {
  45 }
  46
  47 XMLObjectBuilder::~XMLObjectBuilder()
  48 {
  49 }
  50
  51 XMLObject* XMLObjectBuilder::buildFromQName(const QName& q) const
  52 {
  53     return buildObject(q.getNamespaceURI(),q.getLocalPart(),q.getPrefix());
  54 }
  55
  56 XMLObject* XMLObjectBuilder::buildFromElement(DOMElement* element, bool bindDocument) const
  57 {
  58     auto_ptr<QName> schemaType(XMLHelper::getXSIType(element));
  59     auto_ptr<XMLObject> ret(
  60         buildObject(element->getNamespaceURI(),element->getLocalName(),element->getPrefix(),schemaType.get())
  61         );
  62     ret->unmarshall(element,bindDocument);
  63     return ret.release();
  64 }
  65
  66 XMLObject* XMLObjectBuilder::buildFromDocument(DOMDocument* doc, bool bindDocument) const
  67 {
  68     return buildFromElement(doc->getDocumentElement(),bindDocument);
  69 }
  70
  71 XMLObject* XMLObjectBuilder::buildOneFromElement(xercesc::DOMElement* element, bool bindDocument)
  72 {
  73     const XMLObjectBuilder* b=getBuilder(element);
  74     return b ? b->buildFromElement(element,bindDocument) : nullptr;
  75 }
  76
  77 const XMLObjectBuilder* XMLObjectBuilder::getBuilder(const QName& key)
  78 {
  79     map<QName,XMLObjectBuilder*>::const_iterator i=m_map.find(key);
  80     return (i==m_map.end()) ? nullptr : i->second;
  81 }
  82
  83 const XMLObjectBuilder* XMLObjectBuilder::getBuilder(const DOMElement* domElement)
  84 {
  85 #ifdef _DEBUG
  86     xmltooling::NDC ndc("getBuilder");
  87 #endif
  88     Category& log=Category::getInstance(XMLTOOLING_LOGCAT".XMLObject.Builder");
  89
  90     auto_ptr<QName> schemaType(XMLHelper::getXSIType(domElement));
  91     const XMLObjectBuilder* xmlObjectBuilder = schemaType.get() ? getBuilder(*(schemaType.get())) : nullptr;
  92     if (xmlObjectBuilder) {
  93         if (log.isDebugEnabled()) {
  94             log.debug("located XMLObjectBuilder for schema type: %s", schemaType->toString().c_str());
  95         }
  96         return xmlObjectBuilder;
  97     }
  98
  99     auto_ptr<QName> elementName(XMLHelper::getNodeQName(domElement));
 100     xmlObjectBuilder = getBuilder(*(elementName.get()));
 101     if (xmlObjectBuilder) {
 102         if (log.isDebugEnabled()) {
 103             log.debug("located XMLObjectBuilder for element name: %s", elementName->toString().c_str());
 104         }
 105         return xmlObjectBuilder;
 106     }
 107
 108     if (log.isDebugEnabled()) {
 109         log.debug("no XMLObjectBuilder registered for element (%s), returning default", elementName->toString().c_str());
 110     }
 111     return m_default;
 112 }
 113
 114 const XMLObjectBuilder* XMLObjectBuilder::getDefaultBuilder()
 115 {
 116     return m_default;
 117 }
 118
 119 const map<QName,XMLObjectBuilder*>& XMLObjectBuilder::getBuilders()
 120 {
 121     return m_map;
 122 }
 123
 124 void XMLObjectBuilder::registerBuilder(const QName& builderKey, XMLObjectBuilder* builder)
 125 {
 126     deregisterBuilder(builderKey);
 127     m_map[builderKey]=builder;
 128 }
 129
 130 void XMLObjectBuilder::registerDefaultBuilder(XMLObjectBuilder* builder)
 131 {
 132     deregisterDefaultBuilder();
 133     m_default=builder;
 134 }
 135
 136 void XMLObjectBuilder::deregisterBuilder(const QName& builderKey)
 137 {
 138     delete getBuilder(builderKey);
 139     m_map.erase(builderKey);
 140 }
 141
 142 void XMLObjectBuilder::deregisterDefaultBuilder()
 143 {
 144     delete m_default;
 145     m_default = nullptr;
 146 }
 147
 148 void XMLObjectBuilder::destroyBuilders()
 149 {
 150     for_each(m_map.begin(),m_map.end(),cleanup_pair<QName,XMLObjectBuilder>());
 151     m_map.clear();
 152     deregisterDefaultBuilder();
 153 }
 154
 155 ConcreteXMLObjectBuilder::ConcreteXMLObjectBuilder()
 156 {
 157 }
 158
 159 ConcreteXMLObjectBuilder::~ConcreteXMLObjectBuilder()
 160 {
 161 }