自学教程：C++ xmlTextReaderConstValue函数代码示例

int XMIResource::loadPoint(xmlTextReaderPtr reader, const model::BaseObject& o){    assert(o.kind() == LINK);    std::vector<double> points;    controller.getObjectProperty(o.id(), o.kind(), CONTROL_POINTS, points);    // iterate on attributes    for (int rc = xmlTextReaderMoveToFirstAttribute(reader); rc > 0; rc = xmlTextReaderMoveToNextAttribute(reader))    {        auto found = std::find(constXcosNames.begin(), constXcosNames.end(), xmlTextReaderConstName(reader));        enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found));        switch (current)        {            case e_x:                points.push_back(to_double(xmlTextReaderConstValue(reader)));                break;            case e_y:                points.push_back(to_double(xmlTextReaderConstValue(reader)));                break;            default:                // ignore other parameters                // TODO: Does other metamodels might be managed there ?                break;        }    }    controller.setObjectProperty(o.id(), o.kind(), CONTROL_POINTS, points);    return 1;}

/** * processNode: * @reader: the xmlReader * * Dump information about the current node */static voidprocessNode(xmlTextReaderPtr reader) {    const xmlChar *name, *value;    int nodetype;     static char spaces[33]="                                ";    name = xmlTextReaderConstName(reader);    if (name == NULL)	name = BAD_CAST "--";     value = xmlTextReaderConstValue(reader);     nodetype = xmlTextReaderNodeType(reader);    if (nodetype!=14 && nodetype!=15)	// Skip all text bodies and "/" entities.    {#ifdef DETAILS    printf("%s%d %d %s %d %d",     	    (spaces + (32-2*xmlTextReaderDepth(reader))),	    xmlTextReaderDepth(reader),	    nodetype,	    name,	    xmlTextReaderIsEmptyElement(reader),	    xmlTextReaderHasValue(reader));#else    printf("%s%s", (spaces + (32-2*xmlTextReaderDepth(reader))), name);#endif    if (value == NULL)	printf("/n");    else {        if (xmlStrlen(value) > 40)            printf(" %.40s.../n", value);        else	    printf(" %s/n", value);    }    }    if (nodetype==1)	// Element - possibly has attributes    {	while (xmlTextReaderMoveToNextAttribute(reader))	    printf("%s    Attrib: %s=/"%s/"/n", 		(spaces + (32-2*xmlTextReaderDepth(reader))),		xmlTextReaderConstName(reader), 		xmlTextReaderConstValue(reader));    }}

static void parse_dev_class(xmlTextReaderPtr reader){	char *value;	value = (char *)xmlTextReaderConstValue(reader);	print_dev_class(atoi(value));}

static char *ReaderValue( xml_reader_t *p_reader ){    const xmlChar *psz_value =        xmlTextReaderConstValue( p_reader->p_sys->p_reader );    return psz_value ? strdup( (const char *)psz_value ) : NULL;}

 string XMLConversion::GetContent() {   xmlTextReaderRead(_reader);   const xmlChar* pvalue = xmlTextReaderConstValue(_reader);   string value((const char*)pvalue);   return Trim(value); }

/** * processNode: * @reader: the xmlReader * * Dump information about the current node */static voidprocessNode(xmlTextReaderPtr reader) {    const xmlChar *name, *value;    name = xmlTextReaderConstName(reader);    if (name == NULL)	name = BAD_CAST "--";    value = xmlTextReaderConstValue(reader);    printf("Depth: %d; Type: %d; Name: %s; %d|%d", 	    xmlTextReaderDepth(reader),	    xmlTextReaderNodeType(reader),	    name,	    xmlTextReaderIsEmptyElement(reader),	    xmlTextReaderHasValue(reader));    if (value == NULL)	printf("/n");    else {        if (xmlStrlen(value) > 40)            printf("|-> %.40s.../n", value);        else	    printf(" %s/n", value);    }}

int myProcessNode(xmlTextReaderPtr reader,int *lastdepth, int *readnext ,int *mode,char** savehere,int *i){    const xmlChar *name, *value;    name = xmlTextReaderConstName(reader);    if (name == NULL)        name = BAD_CAST "--";    value = xmlTextReaderConstValue(reader);    if(*readnext == 1 && *lastdepth == xmlTextReaderDepth(reader)-1)    {        if(*i <6)        {            sprintf(savehere[*i],"%s",value);            *i=*i + 1;        }        else            return 1;    }    else if(0==strncmp(name,"title",5) && *mode>0)    {        *readnext = 1;        *lastdepth = xmlTextReaderDepth(reader);        if(*mode==1)            *mode=0;//now look for items    }    else if(0==strncmp(name,"item",4)||0==strncmp(name,"entry",5))    {   //find some news feeds        *mode=2;    }    else        *readnext = 0;    return 0;}

void XmlParser::_readMember() {    std::string type;    std::string ref;    std::string role;    // Read attributes    if (xmlTextReaderHasAttributes(_reader) == XmlStatus::TRUE) {        while (xmlTextReaderMoveToNextAttribute(_reader)) {            std::string k = (char*) xmlTextReaderConstName(_reader);            std::string v = (char*) xmlTextReaderConstValue(_reader);            if (k == "type") {                type = v;            } else if (k == "ref") {                ref = v;            } else if (k == "role") {                role = v;            }        }    }    if (_prevMemberParentElementId == _parentElementId) {        _dbBuilder.addMember(_parentElementId, ref, type, role, false);    } else {        _dbBuilder.addMember(_parentElementId, ref, type, role, true);        _prevMemberParentElementId = _parentElementId;    }}

    bool XMLReader::processNode()    {      if (m_reader == NULL)      {        std::cout << "error" << std::endl ;      }      if (xmlTextReaderRead(m_reader) != 1)      {        return false ;      }      m_attributes.clear() ;      if (xmlTextReaderHasAttributes(m_reader) == 1)      {        int count = xmlTextReaderAttributeCount(m_reader) ;        for (int i = 0 ; i < count ; i++)        {          xmlTextReaderMoveToAttributeNo(m_reader, i) ;          m_attributes.insert(                              std::pair<std::string, std::string>(                                                                  (char*) xmlTextReaderConstLocalName(                                                                                                      m_reader),                                                                  (char*) xmlTextReaderConstValue(                                                                                                  m_reader))) ;        }        xmlTextReaderMoveToElement(m_reader) ;      }      //      std::cout << print() << std::endl ;      return true ;    }

//-----------------------------------------void LegacyParser::processAttributeDefaultNode(xmlTextReaderPtr reader) {//-----------------------------------------    int ret = xmlTextReaderRead(reader);    if( ret == 1 ) {        /* should be the text node */        const xmlChar* name = xmlTextReaderConstName(reader);        if ( xmlStrEqual(name, xmlCharStrdup("#text")) == 1 ) {            int hasVal = xmlTextReaderHasValue(reader);            if(hasVal == 1) {                const xmlChar *value = xmlTextReaderConstValue(reader);                if(value != NULL) {                    if( _last_node_type == ATTR_NODE ) {                        _gexf->getData().setNodeAttributeDefault(_last_id, Conv::xmlCharToStr(value));                    }                    else if( _last_node_type == ATTR_EDGE ) {                        _gexf->getData().setEdgeAttributeDefault(_last_id, Conv::xmlCharToStr(value));                    }                }            }            else if(hasVal  == -1) {                throw FileReaderException("An error occured in xmlTextReaderHasValue() for Default node.");            }        }    }}

int XMIResource::loadBase64(xmlTextReaderPtr reader, enum object_properties_t property, const model::BaseObject& o){    // iterate on attributes    for (int rc = xmlTextReaderMoveToFirstAttribute(reader); rc > 0; rc = xmlTextReaderMoveToNextAttribute(reader))    {        auto found = std::find(constXcosNames.begin(), constXcosNames.end(), xmlTextReaderConstName(reader));        enum xcosNames current = static_cast<enum xcosNames>(std::distance(constXcosNames.begin(), found));        switch (current)        {            case e_base64:            {                const xmlChar* base64 = xmlTextReaderConstValue(reader);                std::vector<double> v = base64::decode<std::vector<double> >(to_string(base64));                controller.setObjectProperty(o.id(), o.kind(), property, v);                break;            }            default:                // ignore other parameters                // TODO: Does other metamodels might be managed there ?                break;        }    }    return 1;}

/** * Gets the title from the parser. Returns true if success, false if EOF */bool getTitle (xmlTextReaderPtr xmlReader, int *moreWiki, GString* articleTitle) {			// loops until it finds the title tag or EOF	// one tree at a time, skips sub trees    while (1 == *moreWiki) {				// loops until xmlReader is back down to level 2		// one node at a time		while (1 == *moreWiki && 2 > xmlTextReaderDepth (xmlReader)) {			*moreWiki = xmlTextReaderRead (xmlReader);		}		// loops until it finds the title tag, end of subtree or EOF		// one tree at a time, skips sub trees		while (1 == *moreWiki && 2 <= xmlTextReaderDepth (xmlReader)) {			if (xmlStrEqual(xmlTextReaderConstName(xmlReader), (const unsigned char *) "title")) {				*moreWiki = xmlTextReaderRead(xmlReader);				articleTitle = g_string_assign(articleTitle, (gchar *) xmlTextReaderConstValue(xmlReader));				return (1 == *moreWiki);			}			*moreWiki = xmlTextReaderNext(xmlReader);		}	}	// this should only happen at the end of the document	return (1 == *moreWiki);}

/* * call-seq: *    reader.value -> text * * Provide the text value of the node if present. */static VALUE rxml_reader_value(VALUE self){  xmlTextReaderPtr xReader = rxml_text_reader_get(self);  const xmlChar *result = xmlTextReaderConstValue(xReader);  const xmlChar *xencoding = xmlTextReaderConstEncoding(xReader);  return (result == NULL ? Qnil : rxml_new_cstr(result, xencoding));}

static char *ReaderValue( xml_reader_t *p_reader ){    const xmlChar *psz_value =        xmlTextReaderConstValue( p_reader->p_sys->p_reader );    if( psz_value ) return strdup( (const char *)psz_value );    else return 0;}

static void parse_bdaddr(xmlTextReaderPtr reader){	const char *value;	value = (char *)xmlTextReaderConstValue(reader);	if (value != NULL) {		printf(" %s/n", value);	}	addr = strtoba(value);}

static void parse_text_node(xmlTextReaderPtr reader){	const xmlChar *value;	value = xmlTextReaderConstValue(reader);	if (value != NULL) {		printf(" %s/n", value);	}}

const char *oscap_element_string_get(xmlTextReaderPtr reader){	if (xmlTextReaderNodeType(reader) == XML_READER_TYPE_ELEMENT ||			xmlTextReaderNodeType(reader) == XML_READER_TYPE_ATTRIBUTE)		xmlTextReaderRead(reader);	if (xmlTextReaderHasValue(reader))		return (const char *)xmlTextReaderConstValue(reader);	return NULL;}

G_CONST_RETURN gchar *xml_reader_get_value (XmlReader *reader){  g_return_val_if_fail (XML_IS_READER (reader), NULL);  g_return_val_if_fail (reader->xml != NULL, NULL);  return XML_TO_CHAR (xmlTextReaderConstValue (reader->xml));}

 std::string XmlReader::get_value() const {     auto str = reinterpret_cast<const char*>(xmlTextReaderConstValue(reader.get()));     if (str)         return std::string(str);     else          return std::string(); }

static void parse_timestamp(xmlTextReaderPtr reader){	char *value;	time_t timestamp;	value = (char *)xmlTextReaderConstValue(reader);	timestamp = strtol(value, NULL, 10);	printf(" %s", ctime(&timestamp));}

/* TODO */static void parse_hid_descriptor(xmlTextReaderPtr reader){	const xmlChar *value;	value = xmlTextReaderConstValue(reader);	if (value != NULL) {		printf("/n/t/t/t %s", value);	}	printf("/n");}

int XMIResource::loadStringArray(xmlTextReaderPtr reader, enum object_properties_t property, const model::BaseObject& o){    std::vector<std::string> v;    controller.getObjectProperty(o.id(), o.kind(), property, v);    v.push_back(to_string(xmlTextReaderConstValue(reader)));    controller.setObjectProperty(o.id(), o.kind(), property, v);    return 1;}

/* * call-seq: *   value * * Get the text value of the node if present. Returns a utf-8 encoded string. */static VALUE value(VALUE self){  xmlTextReaderPtr reader;  const char *value;  Data_Get_Struct(self, xmlTextReader, reader);  value = (const char *)xmlTextReaderConstValue(reader);  if(value == NULL) return Qnil;  return NOKOGIRI_STR_NEW2(value);}

/* TODO */static void parse_gatt_attribute(xmlTextReaderPtr reader){	char *value;	char *attr;	value = (char *)xmlTextReaderConstValue(reader);	while ((attr = strsep(&value, " ")) != NULL) {		printf("/n/t/t/t %s", attr);	}	printf("/n");}

/* * call-seq: *   value * * Get the text value of the node if present */static VALUE value(VALUE self){  xmlTextReaderPtr reader;  Data_Get_Struct(self, xmlTextReader, reader);  const char * value = (const char *)xmlTextReaderConstValue(reader);  if(value == NULL) return Qnil;  VALUE MAYBE_UNUSED(enc) = rb_iv_get(self, "@encoding");  return NOKOGIRI_STR_NEW2(value,      RTEST(enc) ? StringValuePtr(enc) : NULL);}

/** * Parses the XML tree until it finds an article body, and sets the article body to what is found in the XML */void getArticleBody (xmlTextReaderPtr xmlReader, int *moreWiki, GString* articleBody) {		*moreWiki = xmlTextReaderRead(xmlReader); // at level 2, need to drop to 3		// loops until it finds the text tag or EOF	// one tree at a time, skips sub trees	do {*moreWiki = xmlTextReaderNext(xmlReader);}	while (1 == *moreWiki && !(xmlStrEqual(xmlTextReaderConstName(xmlReader), (const unsigned char *) "text")));	*moreWiki = xmlTextReaderRead(xmlReader);	articleBody = g_string_assign(articleBody, (gchar *) xmlTextReaderConstValue(xmlReader));}