C++ DOMElement::hasAttribute方法代码示例

bool ViewWindowImp::fromXml(DOMNode* pDocument, unsigned int version)
{
   if (pDocument == NULL)
   {
      return false;
   }

   if (!WindowImp::fromXml(pDocument, version))
   {
      return false;
   }

   DOMElement* pElement = static_cast<DOMElement*>(pDocument);
   if (pElement->hasAttribute(X("viewId")))
   {
      View* pOldView = mpView;
      setView(dynamic_cast<View*>(SessionManagerImp::instance()->getSessionItem(
         A(pElement->getAttribute(X("viewId"))))));
      Service<DesktopServices>()->deleteView(pOldView);
   }
   else
   {
      setView(NULL);
   }

   return true;
}

static void parseSequence(DOMElement *parent, DOMElement *sequence, Class *cl, bool choice = false) {
    //we expect to see a whole bunch of <element>s here
    //if choice is true then this is a choice sequence - every element is optional
    CHECK(parent);
    CHECK(sequence);

    vector<DOMElement*> children = getChildElementsByTagName(sequence, "element");

    //support <sequence> in <choice> by simply recursing
    //simply put this means the <sequence> tags are ignored
    vector<DOMElement*> subSequences = getChildElementsByTagName(sequence, "sequence");

    if(subSequences.size() > 0 && !choice)
        throw runtime_error("Found <sequence> element in another <sequence> element");

    children.insert(children.end(), subSequences.begin(), subSequences.end());
    
    for(size_t x = 0; x < children.size(); x++) {
        DOMElement *child = children[x];
            
        int minOccurs = 1;
        int maxOccurs = 1;

        XercesString typeStr("type");
        XercesString minOccursStr("minOccurs");
        XercesString maxOccursStr("maxOccurs");
        string name = fixIdentifier(XercesString(child->getAttribute(XercesString("name"))));

        if(child->hasAttribute(minOccursStr)) {
            stringstream ss;
            ss << XercesString(child->getAttribute(minOccursStr));
            ss >> minOccurs;
        }

        if(child->hasAttribute(maxOccursStr)) {
            XercesString str(child->getAttribute(maxOccursStr));

            if(str == "unbounded")
                maxOccurs = UNBOUNDED;
            else {
                stringstream ss;
                ss << str;
                ss >> maxOccurs;
            }
        }

void PLMXMLParser::addInstance(char *id, osg::Group *parent)
{

    std::map<char *, Element *, ltstr>::iterator it = instances.find(id);
    if (it != instances.end())
    {

        Element *instance = it->second;

        osg::Group *group = instance->group;
        DOMElement *element = instance->element;

        parent->addChild(group);
        coVRSelectionManager::markAsHelperNode(group);

        osg::MatrixTransform *transformNode = getTransformNode(id, element);
        if (transformNode)
        {
            group->addChild(transformNode);
            group = transformNode;
        }
        else
        {
            if (element->hasAttribute(TAG_name))
                group->setName(XMLString::transcode(element->getAttribute(TAG_name)));
            else
                group->setName(id);
        }

        const XMLCh *partRef = element->getAttribute(TAG_partRef);
        char *partName = XMLString::transcode(partRef);
        if (partName[0] == '#')
            addPart(partName + 1, group);
        else
            addPart(partName, group);
        XMLString::release(&partName);
    }
}

bool DataDescriptorImp::fromXml(DOMNode* pDocument, unsigned int version)
{
   if (pDocument == NULL)
   {
      return false;
   }

   DOMElement* pElement = static_cast<DOMElement*>(pDocument);

   if (mName != A(pElement->getAttribute(X("name"))))
   {
      throw XmlBase::XmlException("Element name does not match this element");
   }

   if (!Service<SessionManager>()->isSessionLoading() && mType != A(pElement->getAttribute(X("type"))))
   {
      throw XmlBase::XmlException("Element type does not match this element");
   }
   mProcessingLocation = StringUtilities::fromXmlString<ProcessingLocation>(
      A(pElement->getAttribute(X("processingLocation"))));

   for (DOMNode* pChild = pDocument->getFirstChild(); pChild != NULL; pChild = pChild->getNextSibling())
   {
      if (XMLString::equals(pChild->getNodeName(), X("classification")))
      {
         if (mClassification.fromXml(pChild, version) == false)
         {
            throw XmlReader::DomParseException("Can't deserialize classification", pDocument);
         }
      }
      else if (XMLString::equals(pChild->getNodeName(), X("metadata")))
      {
         if (mMetadata.fromXml(pChild, version) == false)
         {
            throw XmlReader::DomParseException("Can't deserialize metadata", pDocument);
         }
      }
      else if (XMLString::equals(pChild->getNodeName(), X("FileDescriptor")))
      {
         // create a new FileDescriptor to make sure we have the correct type of FileDescriptor
         delete mpFileDescriptor;
         DOMElement* pChildElement = static_cast<DOMElement*>(pChild);
         string fileDescriptorType = A(pChildElement->getAttribute(X("type")));

         ModelServicesImp* pModel = ModelServicesImp::instance();
         if (pModel != NULL)
         {
            if (pModel->isKindOfFileDescriptor(fileDescriptorType, "RasterFileDescriptor") == true)
            {
               mpFileDescriptor = new RasterFileDescriptorAdapter();
            }
            else if (pModel->isKindOfFileDescriptor(fileDescriptorType, "SignatureFileDescriptor") == true)
            {
               mpFileDescriptor = new SignatureFileDescriptorAdapter();
            }
            else if (pModel->isKindOfFileDescriptor(fileDescriptorType, "FileDescriptor") == true)
            {
               mpFileDescriptor = new FileDescriptorAdapter();
            }
         }

         if (mpFileDescriptor == NULL)
         {
            throw XmlReader::DomParseException("Cannot create file descriptor", pDocument);
         }

         if (mpFileDescriptor->fromXml(pChild, version) == false)
         {
            throw XmlReader::DomParseException("Cannot deserialize file descriptor", pDocument);
         }
      }
   }

   if (pElement->hasAttribute(X("importerName")) == true)
   {
      mImporterName = A(pElement->getAttribute(X("importerName")));
   }
   else
   {
      mImporterName.clear();
   }

   notify(SIGNAL_NAME(Subject, Modified));
   return true;
}