C++ Attributes::getLength方法代码示例

bool qm::AutoPilotContentHandler::startElement(const WCHAR* pwszNamespaceURI,
											   const WCHAR* pwszLocalName,
											   const WCHAR* pwszQName,
											   const Attributes& attributes)
{
	if (wcscmp(pwszLocalName, L"entry") == 0) {
		if (state_ != STATE_AUTOPILOT)
			return false;
		
		bEnabled_ = true;
		for (int n = 0; n < attributes.getLength(); ++n) {
			const WCHAR* pwszAttrName = attributes.getLocalName(n);
			if (wcscmp(pwszAttrName, L"enabled") == 0)
				bEnabled_ = wcscmp(attributes.getValue(n), L"false") != 0;
			else
				return false;
		}
		
		state_ = STATE_ENTRY;
	}
	else {
		struct {
			const WCHAR* pwszName_;
			State stateBefore_;
			State stateAfter_;
		} states[] = {
			{ L"autoPilot",	STATE_ROOT,			STATE_AUTOPILOT	},
			{ L"course",	STATE_ENTRY,		STATE_COURSE	},
			{ L"interval",	STATE_ENTRY,		STATE_INTERVAL	}
		};
		
		int n = 0;
		for (n = 0; n < countof(states); ++n) {
			if (wcscmp(pwszLocalName, states[n].pwszName_) == 0) {
				if (state_ != states[n].stateBefore_)
					return false;
				if (attributes.getLength() != 0)
					return false;
				state_ = states[n].stateAfter_;
				break;
			}
		}
		if (n == countof(states))
			return false;
	}
	
	return true;
}

 void startElement(const XMLCh* const uri,const XMLCh* const localname,
   const XMLCh* const qname, const Attributes& attributes)
 { 
   //cout << "TestHandler::startElement: " << StrX(qname) << endl;
   char* buf = XMLString::transcode(qname);
   string sbuf(buf);
   if ( sbuf == tag )
   {
     read = true;
   }
   XMLString::release(&buf);
   
   if ( read )
   {
     // copy start element tag with attributes
     cout << "<" << StrX(qname).localForm();
     unsigned int len = attributes.getLength();
     for (unsigned int index = 0; index < len; index++)
     {
       cout << " " << attributes.getQName(index)
            << "=\"" 
            << attributes.getValue(index)
            << "\"";
     }
     cout << ">";
   }
 };

void ILI2Handler::startElement(
    CPL_UNUSED const XMLCh* const uri,
    CPL_UNUSED const XMLCh* const localname,
    const XMLCh* const qname,
    const Attributes& attrs
    ) {
  // start to add the layers, features with the DATASECTION
  char *tmpC = NULL;
  m_nEntityCounter = 0;
  if ((level >= 0) || (cmpStr(ILI2_DATASECTION, tmpC = XMLString::transcode(qname)) == 0)) {
    level++;

    if (level >= 2) {

      // create the dom tree
      DOMElement *elem = (DOMElement*)dom_doc->createElement(qname);
      
      // add all attributes
      unsigned int len = attrs.getLength();
      for (unsigned int index = 0; index < len; index++)
        elem->setAttribute(attrs.getQName(index), attrs.getValue(index));
      dom_elem->appendChild(elem);
      dom_elem = elem;
    }
  }
  XMLString::release(&tmpC);
}

void XMLWriter::declareAttributeNamespaces(const Attributes& attributes)
{
	for (int i = 0; i < attributes.getLength(); i++)
	{
		XMLString namespaceURI = attributes.getURI(i);
		XMLString localName    = attributes.getLocalName(i);
		XMLString qname        = attributes.getQName(i);
		if (!localName.empty())
		{
			XMLString prefix;
			XMLString splitLocalName;
			Name::split(qname, prefix, splitLocalName);
			if (prefix.empty()) prefix = _namespaces.getPrefix(namespaceURI);
			if (prefix.empty() && !namespaceURI.empty() && !_namespaces.isMapped(namespaceURI))
			{
				prefix = newPrefix();
				_namespaces.declarePrefix(prefix, namespaceURI);
			}

			const XMLString& uri = _namespaces.getURI(prefix);
			if ((uri.empty() || uri != namespaceURI) && !namespaceURI.empty())
			{
				_namespaces.declarePrefix(prefix, namespaceURI);
			}
		}
	}
}

void
XMLTreeGenerator::startElement(const XMLCh* const uri, 
									const XMLCh* const localname, 
									const XMLCh* const qname, 
									const Attributes& attrs)
{
	string name = XMLUtil::trim(XMLUtil::WideCharToString(localname ));

	if (name.empty() ) return;

	XMLTree* pTree = NULL;

	if (m_pBuffer == NULL )
	{
		m_pRoot->SetName(name);
		
		pTree = m_pRoot;
	}
	else
	{
		pTree = m_pBuffer->AddChild(name);
	}

	for (unsigned int i = 0; i < attrs.getLength(); i++ ) 
	{
		pTree->AddAttribute(
			XMLUtil::trim(XMLUtil::WideCharToString(attrs.getLocalName(i ) ) ),
			XMLUtil::trim(XMLUtil::WideCharToString(attrs.getValue(i ) ) ));
	}

	m_pBuffer = pTree;
}

void MySAX2Handler::startElement(const   XMLCh* const    uri,
                                 const   XMLCh* const    localname,
                                 const   XMLCh* const    qname,
                                 const   Attributes&     attrs)
{
    char* message = XMLString::transcode(localname);

    if (strcmp(message, "TIME_SLOT") == 0) {
        string label;
        int value;
        for (int i=0; i<attrs.getLength(); i++) {
            char *localname = XMLString::transcode(attrs.getLocalName(i));
            char *atvalue = XMLString::transcode(attrs.getValue(i));
            if (strcmp(localname, "TIME_SLOT_ID") == 0) {
                label = atvalue;
            } else if (strcmp(localname, "TIME_VALUE") == 0) {
                value = atoi(atvalue);
            }
            //cout << localname  << " " << value << endl;
            time_slots[label] = value;

            XMLString::release(&localname);
            XMLString::release(&atvalue);
        }
        cout << label << " " << value << endl;

    } else {
        cout << "I saw element: "<< message << endl;
    }
    XMLString::release(&message);
}

	void startElement(const XMLCh* const uri, const XMLCh* const localname, const XMLCh* const qname, const Attributes& attrs )      {
		theOStream << "<" << qname;
		for ( unsigned int i = 0; i < attrs.getLength(); i++ ) {
			theOStream  <<  " " << attrs.getQName( i ) << "=\"" << attrs.getValue( i ) << "\"";
		}
		theOStream << ">";
	}     

// ---------------------------------------------------------------------------
//  XSerializerHandlers: Implementation of the SAX DocumentHandler interface
// ---------------------------------------------------------------------------
void XSerializerHandlers::startElement(const XMLCh* const uri
                                   , const XMLCh* const localname
                                   , const XMLCh* const qname
                                   , const Attributes& attrs)
{
    fElementCount++;
    fAttrCount += attrs.getLength();
}

// ---------------------------------------------------------------------------
//  SAX2CountHandlers: Implementation of the SAX DocumentHandler interface
// ---------------------------------------------------------------------------
void SAX2CountHandlers::startElement(const XMLCh* const /* uri */
                                   , const XMLCh* const /* localname */
                                   , const XMLCh* const /* qname */
                                   , const Attributes& attrs)
{
    fElementCount++;
    fAttrCount += attrs.getLength();
}

  void GpXmlStateMachine::SetAttributes(GpType* target, const Attributes& attrs)
  {
    XMLSize_t           numAtts = attrs.getLength();
    string              retValue;

    map<string, string> attributes;
    DEBOUT("GpXmlStateMachine::SetAttributes - Type");

    if (numAtts > 0)
    {
      for (XMLSize_t i = 0; i < numAtts; i++)
      {
        string local(XMLString::transcode(attrs.getLocalName(i) ) );
        string value(XMLString::transcode(attrs.getValue(i) ) );
        attributes[local] = value;
        DEBOUT(i);
        DEBOUT(local);
        DEBOUT(value);
      }
      // Checking the member for constness
      if (FindAttribute(attributes, ConstStr, retValue) )
      {
        if (retValue.compare(TrueStr) == 0)
        {
          target->Const(true);
        }
      }
      // Checking the member for staticness
      if (FindAttribute(attributes, StaticStr, retValue) )
      {
        if (retValue.compare(TrueStr) == 0)
        {
          target->Static(true);
        }
      }
      // Checking if the member is a pointer or reference
      if (FindAttribute(attributes, DirecStr, retValue) )
      {
        if (retValue.compare(PtrStr) == 0)
        {
          target->Direc(POINTER);
          DEBOUT("Pointer");
        }
        else
        {
          if (retValue.compare(RefStr) == 0)
          {
            target->Direc(REFERENCE);
            DEBOUT("Reference");
          }
        }
      }
    }
  }

	void startElement(const XMLString& uri, const XMLString& localName, const XMLString& qname, const Attributes& attributes)
	{
		where("startElement");
		std::cout << "uri:       " << uri << std::endl
		          << "localName: " << localName << std::endl
		          << "qname:     " << qname << std::endl;
		std::cout << "Attributes: " << std::endl;
		for (int i = 0; i < attributes.getLength(); ++i)
		{
			std::cout << attributes.getLocalName(i) << "=" << attributes.getValue(i) << std::endl;
		}
	}

void AttributesImpl::setAttributes(const Attributes& attributes)
{
	if (&attributes != this)
	{
		int count = attributes.getLength();
		_attributes.clear();
		_attributes.reserve(count);
		for (int i = 0; i < count; i++)
		{
			addAttribute(attributes.getURI(i), attributes.getLocalName(i), attributes.getQName(i), attributes.getType(i), attributes.getValue(i));
		}
	}
}

// ---------------------------------------------------------------------------
//  SAX2SortAttributesFilter: Overrides of the SAX2XMLFilter interface
// ---------------------------------------------------------------------------
void SAX2SortAttributesFilter::startElement(const   XMLCh* const    uri,
									const   XMLCh* const    localname,
									const   XMLCh* const    qname,
                                    const   Attributes&		attributes)
{
    AttrList sortedList(attributes.getLength());
    for(unsigned int i=0;i<attributes.getLength();i++)
    {
        unsigned int j;
        for(j=0;j<sortedList.getLength();j++)
        {
            if(XMLString::compareString(sortedList.elementAt(j)->qName,attributes.getQName(i))>=0)
                break;
        }
        Attr* pClone=new Attr;
        pClone->qName       = attributes.getQName(i);
        pClone->uri         = attributes.getURI(i);
        pClone->localPart   = attributes.getLocalName(i);
        pClone->value       = attributes.getValue(i);
        pClone->attrType    = attributes.getType(i);
        sortedList.insertElementAt(pClone, j);
    }
    SAX2XMLFilterImpl::startElement(uri, localname, qname, sortedList);
}

void currencyHandler::startElement(const XMLString& uri,
		const XMLString& localName, const XMLString& qname,
		const Attributes& attributes) {
	//		where("startElement");
	std::cout << "start element uri:       " << uri << std::endl
			<< "localName: " << localName << std::endl << "qname:     "
			<< qname << std::endl;

	if (localName.compare("resource") == 0) {
		std::cout << " Quote starting here.." << std::endl;

		inQuote = true;
	} else if (localName.compare("field") == 0) {
		std::cout << " field starting here.." << std::endl;
		//	std::cout<<" field value is "<<attributes.getValue(i)<<std::endl;
	}

	std::cout << "Attributes: " << std::endl;
	for (int i = 0; i < attributes.getLength(); ++i) {

		std::cout << " attributes.getValue(i) : " << attributes.getValue(i)
				<< std::endl;

		if (attributes.getValue(i).compare("symbol") == 0) {
			currentFieldReading = symbolType;

		} else if (attributes.getValue(i).compare("ts") == 0) {
			currentFieldReading = tsType;

		} else if (attributes.getValue(i).compare("utctime") == 0) {
			currentFieldReading = utctimelType;

		} else if (attributes.getValue(i).compare("volume") == 0) {
			currentFieldReading = volumeType;

		} else if (attributes.getValue(i).compare("price") == 0) {
			currentFieldReading = priceType;

		} else if (attributes.getValue(i).compare("name") == 0) {
			currentFieldReading = nameType;

		} else if (attributes.getValue(i).compare("type") == 0) {
			currentFieldReading = typeType;

		}

	}
}

void ThreadParser::SAX2Handler::startElement(const XMLCh *const /*uri*/,
                              const XMLCh *const localname,
                              const XMLCh *const /*qname*/,
                              const Attributes& attributes)
{
    SAX2Instance->addToCheckSum(localname);

    XMLSize_t n = attributes.getLength();
    XMLSize_t i;
    for (i=0; i<n; i++)
    {
        const XMLCh *attNam = attributes.getQName(i);
        SAX2Instance->addToCheckSum(attNam);
        const XMLCh *attVal = attributes.getValue(i);
        SAX2Instance->addToCheckSum(attVal);
    }
}