Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/event__parser_8cpp_source.html below:

NCBI C++ ToolKit: src/misc/xmlwrapp/event_parser.cpp Source File

(

xmlChar *target,

xmlChar *

);

xmlChar *public_id,

xmlChar *system_id);

xmlChar * publicId,

xmlChar * systemId,

xmlChar *public_id,

xmlChar *system_id,

xmlChar *notation_name);

xmlChar *external_id,

xmlChar *system_id);

xmlChar *external_id,

xmlChar *system_id);

xmlChar *attribute_name,

xmlChar *default_value,

xmlEnumeration *default_values);

xmlElementContent *content);

{

*

(parser)->event_start_document(); }

{

*

(parser)->event_end_document(); }

{

*

(parser)->event_start_element(

, props); }

{

*

(parser)->event_end_element(

); }

(

*parser,

xmlChar *

,

length)

{

*

(parser)->event_text(

, length); }

(

*parser,

xmlChar *target,

xmlChar *

)

{

*

(parser)->event_pi(target,

); }

{

*

(parser)->event_comment(

); }

(

*parser,

xmlChar *

,

length)

{

*

(parser)->event_cdata(

, length); }

xmlChar *public_id,

xmlChar *system_id)

{

*

(parser)->event_notation_declaration(name,

,

xmlChar *public_id,

xmlChar *system_id,

{

*

(parser)->event_entity_declaration(name,

xmlChar *public_id,

xmlChar *system_id,

xmlChar *notation_name)

{

*

(parser)->event_unparsed_entity_declaration(name,

xmlChar *external_id,

xmlChar *system_id)

{

*

(parser)->event_external_subset_declaration(name,

xmlChar *external_id,

xmlChar *system_id)

{

*

(parser)->event_internal_subset_declaration(name,

xmlChar *element_name,

xmlChar *attribute_name,

xmlChar *default_value,

xmlEnumeration *default_values)

{

*

(parser)->event_attribute_declaration(element_name,

xmlChar *element_name,

xmlElementContent *content)

{

*

(parser)->event_element_declaration(element_name,

{

*

(parser)->event_entity_reference(name); }

(

*parser,

*message, ...) {

va_start(ap, message);

*

(parser)->event_warning(complete_message);

(

*parser,

*message, ...) {

va_start(ap, message);

*

(parser)->event_error(complete_message);

va_start(ap, message);

*

(parser)->event_fatal_error(complete_message);

other.pimpl_ =

;

(

!= &other) {

other.pimpl_ =

;

std::ifstream

(filename);

(filename !=

)

std::unique_ptr<error_messages> msgs;

(stream && (stream.eof() ||

stream.peek() == std::istream::traits_type::eof()))

(

)stream.gcount(),

(!stream && !stream.eof())

std::unique_ptr<error_messages> msgs;

);

);

), 0);

std::unique_ptr<error_messages> msgs;

ret_val =

;

(contents);

_xmlElementContent *content) {

XML_INTERNAL_GENERAL_ENTITY:

type_internal_general_entity;

XML_EXTERNAL_GENERAL_PARSED_ENTITY:

type_external_general_parsed_entity;

XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:

type_external_general_unparsed_entity;

XML_INTERNAL_PARAMETER_ENTITY:

type_internal_parameter_entity;

XML_EXTERNAL_PARAMETER_ENTITY:

type_external_parameter_entity;

XML_INTERNAL_PREDEFINED_ENTITY:

type_internal_predefined_entity;

XML_ATTRIBUTE_CDATA:

type_attribute_cdata;

XML_ATTRIBUTE_ID:

type_attribute_id;

XML_ATTRIBUTE_IDREF:

type_attribute_idref;

XML_ATTRIBUTE_IDREFS:

type_attribute_idrefs;

XML_ATTRIBUTE_ENTITY:

type_attribute_entity;

XML_ATTRIBUTE_ENTITIES:

type_attribute_entities;

XML_ATTRIBUTE_NMTOKEN:

type_attribute_nmtoken;

XML_ATTRIBUTE_NMTOKENS:

type_attribute_nmtokens;

XML_ATTRIBUTE_ENUMERATION:

type_attribute_enumeration;

XML_ATTRIBUTE_NOTATION:

type_attribute_notation;

XML_ATTRIBUTE_NONE:

type_attribute_none;

XML_ATTRIBUTE_REQUIRED:

type_attribute_required;

XML_ATTRIBUTE_IMPLIED:

type_attribute_implied;

XML_ATTRIBUTE_FIXED:

type_attribute_fixed;

XML_ELEMENT_TYPE_EMPTY:

type_empty;

XML_ELEMENT_TYPE_ANY:

type_any;

XML_ELEMENT_TYPE_MIXED:

type_mixed;

XML_ELEMENT_TYPE_ELEMENT:

type_element;

: parser_context_(

),

parser_status_(

),

std::bad_alloc();

xmlChar **attrp;

(attrp = props; attrp && *attrp; attrp += 2) {

attrs[

*

(*attrp)] =

*

(*(attrp+1));

}

(

std::exception &ex) {

}

(

std::exception &ex) {

contents(

*

(

),

std::string::size_type

(length));

}

(

std::exception &ex) {

}

(

std::exception &ex) {

}

(

std::exception &ex) {

s_target =

*

(target);

}

(

std::exception &ex) {

}

(

std::exception &ex) {

contents(

*

(

),

std::string::size_type

(length));

}

(

std::exception &ex) {

xmlChar *public_id,

xmlChar *system_id) {

notation_name( name ?

*

(name) :

);

notation_public_id( public_id ?

*

(public_id) :

);

notation_system_id( system_id ?

*

(system_id) :

);

}

(

std::exception &ex) {

xmlChar *public_id,

xmlChar *system_id,

entity_public_id( public_id ?

*

(public_id) :

);

entity_system_id( system_id ?

*

(system_id) :

);

entity_content( content ?

*

(content) :

);

entity_public_id, entity_system_id,

}

(

std::exception &ex) {

xmlChar *public_id,

xmlChar *system_id,

xmlChar *notation_name) {

entity_public_id( public_id ?

*

(public_id) :

);

entity_system_id( system_id ?

*

(system_id) :

);

entity_notation_name( notation_name ?

*

(notation_name) :

);

entity_public_id, entity_system_id,

entity_notation_name);

}

(

std::exception &ex) {

xmlChar *external_id,

xmlChar *system_id) {

root_element_name( name ?

*

(name) :

);

ext_id( external_id ?

*

(external_id) :

);

sys_id( system_id ?

*

(system_id) :

);

}

(

std::exception &ex) {

xmlChar *external_id,

xmlChar *system_id) {

root_element_name( name ?

*

(name) :

);

ext_id( external_id ?

*

(external_id) :

);

sys_id( system_id ?

*

(system_id) :

);

}

(

std::exception &ex) {

xmlChar *attribute_name,

xmlChar *default_value,

xmlEnumeration *default_values) {

element( element_name ?

*

(element_name) :

);

attr_name( attribute_name ?

*

(attribute_name) :

);

default_val( default_value ?

*

(default_value) :

);

(default_values) {

(default_values->name)

def_vals.push_back(

(

*

(default_values->name)));

default_values = default_values->next;

}

(

std::exception &ex) {

xmlElementContent *content) {

element( element_name ?

*

(element_name) :

);

}

(

std::exception &ex) {

reference_name( name ?

*

(name) :

);

}

(

std::exception &ex) {

xmlError * last_err = xmlGetLastError();

line = last_err->line;

line = xmlLastError.line;

(last_err->file !=

) {

filename = last_err->file;

(xmlLastError.file !=

)

filename = xmlLastError.file;

xmlResetLastError();

}

(

std::exception &ex) {

xmlError * last_err = xmlGetLastError();

line = last_err->line;

line = xmlLastError.line;

(last_err->file !=

) {

filename = last_err->file;

(xmlLastError.file !=

)

filename = xmlLastError.file;

xmlResetLastError();

}

(

std::exception &ex) {

xmlError * last_err = xmlGetLastError();

line = last_err->line;

line = xmlLastError.line;

(last_err->file !=

) {

filename = last_err->file;

(xmlLastError.file !=

)

filename = xmlLastError.file;

xmlResetLastError();

ncbi::TMaskedQueryRegions mask

The xml::error_message class is used to store a single error message which may appear while parsing o...

@ type_fatal_error

fatal error

The xml::error_messages class is used to store all the error message which are collected while parsin...

bool has_fatal_errors(void) const

Check if there are fatal errors in the error messages.

const error_messages_type & get_messages(void) const

Get the error messages.

bool has_warnings(void) const

Check if there are warnings in the error messages.

bool has_errors(void) const

Check if there are errors in the error messages.

The xml::event_parser is used to parse an XML document by calling member functions when certain thing...

entity_type get_entity_type(int)

std::map< std::string, std::string > attrs_type

a type for holding XML node attributes

attribute_default_type get_attribute_default_type(int)

event_parser & operator=(event_parser &&other)

Moving assignment.

attribute_default_type

enum for different default attribute definition

virtual bool unparsed_entity_declaration(const std::string &name, const std::string &public_id, const std::string &system_id, const std::string &notation_name)

Override this memeber function to receive the unparsed entity declaration message.

bool parse_finish(error_messages *messages, warnings_as_errors_type how=type_warnings_not_errors)

Finish parsing chunked data.

virtual bool external_subset_declaration(const std::string &name, const std::string &external_id, const std::string &system_id)

Override this memeber function to receive the external subset declaration message.

attribute_type get_attribute_type(int)

std::vector< std::string > values_type

a type for holding attribute declaration values

bool parse_stream(std::istream &stream, error_messages *messages, warnings_as_errors_type how=type_warnings_not_errors)

Parse what ever data that can be read from the given stream.

virtual bool text(const std::string &contents)=0

Override this member function to receive the text message.

virtual bool attribute_declaration(const std::string &element_name, const std::string &attribute_name, attribute_type attr_type, attribute_default_type default_type, const std::string &default_value, const values_type &default_values)

Override this memeber function to receive the attribute declaration message.

virtual bool start_document()

Override this member function to receive the start_document message.

virtual bool cdata(const std::string &contents)

Override this member function to receive the cdata mesage.

bool is_failure(error_messages *messages, warnings_as_errors_type how) const

virtual bool internal_subset_declaration(const std::string &name, const std::string &external_id, const std::string &system_id)

Override this memeber function to receive the internal subset declaration message.

@ notation_decl_handler

controls the notation declaration handler

@ end_element_handler

controls the end element handler

@ comment_handler

controls the comment handler

@ element_decl_handler

controls the element declaration handler

@ unparsed_entity_decl_handler

controls the unparsed entity declaration handler

@ entity_decl_handler

controls the entity declaration handler

@ internal_subset_handler

controls the internal subset handler

@ external_subset_handler

controls the external subset handler

@ attribute_decl_handler

controls the attribute declaration handler

@ pi_handler

controls the processing instruction handler

@ start_element_handler

controls the start element handler

@ cdata_handler

controls the cdata handler

@ reference_handler

controls the reference handler

@ start_document_handler

controls the start document handler

@ characters_handler

controls the text handler

@ end_document_handler

controls the end document handler

virtual bool element_declaration(const std::string &name, element_content_type type, _xmlElementContent *content)

Override this memeber function to receive the element declaration message.

virtual bool end_element(const std::string &name)=0

Override this member function to receive the end_element message.

virtual bool start_element(const std::string &name, const attrs_type &attrs)=0

Override this member function to receive the start_element message.

int sax_handlers_mask

handlers mask type

virtual bool end_document()

Override this member function to receive the end_document message.

virtual bool warning(const std::string &message)

Override this memeber function to receive parser warnings.

virtual bool entity_reference(const std::string &name)

Override this memeber function to receive the entity reference message.

event_parser(sax_handlers_mask mask=default_set)

xml::event_parser class constructor.

virtual bool entity_declaration(const std::string &name, entity_type type, const std::string &public_id, const std::string &system_id, const std::string &content)

Override this memeber function to receive the entity declaration message.

element_content_type get_element_content_type(int)

entity_type

enum for different types of XML entities

virtual bool notation_declaration(const std::string &name, const std::string &public_id, const std::string &system_id)

Override this memeber function to receive the notation declaration message.

bool parse_chunk(const char *chunk, size_type length, error_messages *messages, warnings_as_errors_type how=type_warnings_not_errors)

Call this function to parse a chunk of xml data.

virtual bool error(const std::string &message)

Override this memeber function to receive parser errors.

virtual bool comment(const std::string &contents)

Override this member function to receive the comment message.

attribute_type

enum for different types of XML attributes

bool parse_file(const char *filename, error_messages *messages, warnings_as_errors_type how=type_warnings_not_errors)

Call this member function to parse the given file.

element_content_type

enum for element content types

virtual ~event_parser(void)

xml::event_parser class destructor.

std::size_t size_type

size type

virtual bool processing_instruction(const std::string &target, const std::string &data)

Override this member function to receive the procesing_instruction message.

This exception class is thrown by xmlwrapp for all runtime XML-related errors along with the xml::par...

static bool get_remove_whitespace(void)

This member function provides the current setting of the XML parser which tells whether it should rem...

static void cb_pi(void *parser, const xmlChar *target, const xmlChar *data)

static void cb_cdata(void *parser, const xmlChar *text, int length)

static void cb_start_element(void *parser, const xmlChar *tag, const xmlChar **props)

static void cb_external_subset_declaration(void *parser, const xmlChar *name, const xmlChar *external_id, const xmlChar *system_id)

static void cb_end_element(void *parser, const xmlChar *tag)

static void cb_entity_declaration(void *parser, const xmlChar *name, int type, const xmlChar *public_id, const xmlChar *system_id, xmlChar *content)

static void cb_unparsed_entity_declaration(void *parser, const xmlChar *name, const xmlChar *public_id, const xmlChar *system_id, const xmlChar *notation_name)

static void cb_attribute_declaration(void *parser, const xmlChar *element_name, const xmlChar *attribute_name, int attr_type, int default_type, const xmlChar *default_value, xmlEnumeration *default_values)

static void cb_element_declaration(void *parser, const xmlChar *element_name, int type, xmlElementContent *content)

static void cb_text(void *parser, const xmlChar *text, int length)

static void cb_end_document(void *parser)

static void cb_internal_subset_declaration(void *parser, const xmlChar *name, const xmlChar *external_id, const xmlChar *system_id)

static void cb_start_document(void *parser)

static void cb_error(void *parser, const char *message,...)

static void cb_fatal_error(void *parser, const char *message,...)

static void cb_ignore(void *, const xmlChar *, int)

static void cb_entity_reference(void *parser, const xmlChar *name)

static void cb_warning(void *parser, const char *message,...)

static void cb_comment(void *parser, const xmlChar *text)

static void cb_notation_declaration(void *parser, const xmlChar *name, const xmlChar *public_id, const xmlChar *system_id)

This file contains the definition of the xml::event_parser class.

static void text(MDB_val *v)

static const std::size_t const_buffer_size

This file contains the definition of the xml::exception class.

This file contains the definition of the xml::node class.

void clear_https_messages(void)

void printf2string(std::string &s, const char *message, va_list ap)

void collect_https_messages(xml::error_messages &append_to)

warnings_as_errors_type

A type for different approaches to process warnings.

@ type_warnings_are_errors

Treat warnings as errors.

int size_t_to_int_conversion(std::size_t value, const std::string &msg)

void event_entity_declaration(const xmlChar *name, int type, const xmlChar *publicId, const xmlChar *systemId, xmlChar *content)

void event_internal_subset_declaration(const xmlChar *name, const xmlChar *external_id, const xmlChar *system_id)

void event_external_subset_declaration(const xmlChar *name, const xmlChar *external_id, const xmlChar *system_id)

void recreate_context(void)

void event_warning(const std::string &message)

epimpl(event_parser &parent, event_parser::sax_handlers_mask mask)

void event_unparsed_entity_declaration(const xmlChar *name, const xmlChar *public_id, const xmlChar *system_id, const xmlChar *notation_name)

void event_fatal_error(const std::string &message)

void event_start_document(void)

void event_end_document(void)

epimpl & operator=(const epimpl &)

void event_attribute_declaration(const xmlChar *element_name, const xmlChar *attribute_name, int attr_type, int default_type, const xmlChar *default_value, xmlEnumeration *default_values)

xmlParserCtxt * parser_context_

void event_end_element(const xmlChar *tag)

void event_text(const xmlChar *text, int length)

void event_element_declaration(const xmlChar *element_name, int type, xmlElementContent *content)

void event_error(const std::string &message)

void create_context(void)

void event_comment(const xmlChar *text)

void event_pi(const xmlChar *target, const xmlChar *data)

void destroy_context(void)

void event_start_element(const xmlChar *tag, const xmlChar **props)

void event_entity_reference(const xmlChar *name)

void event_notation_declaration(const xmlChar *name, const xmlChar *public_id, const xmlChar *system_id)

void event_cdata(const xmlChar *text, int length)

xmlSAXHandler sax_handler_

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4