ExpatCoreParser Class Reference

#include <ExpatCoreParser.h>

Collaboration diagram for ExpatCoreParser:

Public Types
typedef std::map< std::string, std::string >	ExternalEntityMap

Static Public Member Functions
static std::unique_ptr< XMLCoreNode >	parse (const std::string &file_name)
static std::unique_ptr< XMLCoreNode >	parse_string (const std::string &text)
static void	register_external_entity (const std::string &name, const std::string &file_name)
static void	register_text_entity (const std::string &name, const std::string &text)

Private Types
typedef std::lock_guard< std::mutex >	lock_t

Private Member Functions
	ExpatCoreParser (const std::string &prefix)
void	configure_parser (XML_Parser p)
XMLCoreNode *	add_node (std::unique_ptr< XMLCoreNode > node)
void	do_start (const char *el, const char **attr)
void	do_end (const char *el)
void	do_char_data (const XML_Char *s, int len)
void	do_default_handler (const XML_Char *s, int len)
void	do_comment (const XML_Char *s)
int	generic_parse (XML_Parser p, const std::string &file_name)
int	generic_text_parse (XML_Parser p, const std::string &text)
int	stream_parse (XML_Parser p, std::istream &is, const std::string &source_name={})
int	do_external_entity (XML_Parser parser, const XML_Char *context, const XML_Char *systemId)
std::unique_ptr< XMLCoreNode >	get_document ()
std::string	find_external_entity (const std::string &name)
std::string	find_text_entity (const std::string &name)
std::string	find_entity (const std::string &name, const ExternalEntityMap &mapChoice)
void	clean ()

Static Private Member Functions
static void	start (void *, const char *el, const char **attr)
static void	end (void *, const char *el)
static void	char_data (void *, const XML_Char *s, int len)
static void	default_handler (void *, const XML_Char *s, int len)
static void	comment (void *, const XML_Char *s)
static int	external_entity (XML_Parser parser, const XML_Char *context, const XML_Char *, const XML_Char *systemId, const XML_Char *)

Private Attributes
std::unique_ptr< XMLCoreNode >	m_top
XMLCoreNode *	m_last {}
std::string	m_prefix

Static Private Attributes
static std::mutex	s_mutex
static ExternalEntityMap s_entities	ATLAS_THREAD_SAFE
static ExternalEntityMap s_text_entities	ATLAS_THREAD_SAFE

Detailed Description

Definition at line 19 of file ExpatCoreParser.h.

Member Typedef Documentation

ExternalEntityMap

typedef std::map<std::string, std::string> ExpatCoreParser::ExternalEntityMap

Definition at line 23 of file ExpatCoreParser.h.

lock_t

typedef std::lock_guard<std::mutex> ExpatCoreParser::lock_t

private

Definition at line 62 of file ExpatCoreParser.h.

Constructor & Destructor Documentation

ExpatCoreParser()

ExpatCoreParser::ExpatCoreParser ( const std::string & prefix )

private

Definition at line 94 of file ExpatCoreParser.cxx.

  : m_top (nullptr),
    m_last (nullptr),
    m_prefix (prefix){
}

Member Function Documentation

add_node()

XMLCoreNode * ExpatCoreParser::add_node ( std::unique_ptr< XMLCoreNode > node )

private

Definition at line 111 of file ExpatCoreParser.cxx.

                                                         {
  if (!m_top){
    m_top = std::make_unique<XMLCoreNode> (XMLCoreNode::DOCUMENT_NODE);
    m_last = m_top.get();
  }
 
  return m_last->add_child (std::move(node));
}

char_data()

void ExpatCoreParser::char_data ( void * user_data, const XML_Char * s, int len )

staticprivate

Definition at line 45 of file ExpatCoreParser.cxx.

                                                                      {
  auto& me = *static_cast<ExpatCoreParser*> (user_data);
  me.do_char_data (s, len);
}

clean()

void ExpatCoreParser::clean ( )

private

comment()

void ExpatCoreParser::comment ( void * user_data, const XML_Char * s )

staticprivate

Definition at line 57 of file ExpatCoreParser.cxx.

                                                           {
  auto& me = *static_cast<ExpatCoreParser*> (user_data);
  me.do_comment (s);
}

configure_parser()

void ExpatCoreParser::configure_parser ( XML_Parser p )

private

Definition at line 101 of file ExpatCoreParser.cxx.

                                              {
  XML_SetParamEntityParsing(p, XML_PARAM_ENTITY_PARSING_ALWAYS);
  XML_SetElementHandler(p, start, end);
  XML_SetCharacterDataHandler(p, char_data);
  XML_SetExternalEntityRefHandler(p, external_entity);
  XML_SetCommentHandler(p, comment);
  XML_SetUserData(p, this);
}

default_handler()

void ExpatCoreParser::default_handler ( void * user_data, const XML_Char * s, int len )

staticprivate

Definition at line 51 of file ExpatCoreParser.cxx.

                                                                            {
  auto& me = *static_cast<ExpatCoreParser*> (user_data);
  me.do_default_handler (s, len);
}

do_char_data()

void ExpatCoreParser::do_char_data ( const XML_Char * s, int len )

private

Definition at line 143 of file ExpatCoreParser.cxx.

                                                        {
  std::string text = rtrim(s, len);
  if (text.empty()) return;
  if (debug_enabled()) {
    std::cout << label()<<"> [" << text << "]\n";
  }
  add_node (std::make_unique<XMLCoreNode>(XMLCoreNode::TEXT_NODE, "", text));
}

do_comment()

void ExpatCoreParser::do_comment ( const XML_Char * s )

private

Definition at line 162 of file ExpatCoreParser.cxx.

                                             {
  auto node = std::make_unique<XMLCoreNode> (XMLCoreNode::COMMENT_NODE, "", s);
  if (debug_enabled()) {
    std::cout << label()<<"> s=" << s << " top=" << m_top.get() << " last=" << m_last << " node=" << node << "\n"; 
  }
  add_node (std::move(node));
}

do_default_handler()

void ExpatCoreParser::do_default_handler ( const XML_Char * s, int len )

private

Definition at line 153 of file ExpatCoreParser.cxx.

                                                              {
  std::string text = rtrim(s, len);
  if (text.empty()) return;
  if (debug_enabled()) {
      std::cout << label()<<"> [" << text << "]\n";
  }
}

do_end()

void ExpatCoreParser::do_end ( const char * el )

private

Definition at line 135 of file ExpatCoreParser.cxx.

                                      {
  if (debug_enabled()){
    std::cout <<label()<<"> el=" << el << "\n"; 
  }
  m_last = m_last->get_parent();
}

do_external_entity()

int ExpatCoreParser::do_external_entity ( XML_Parser parser, const XML_Char * context, const XML_Char * systemId )

private

Definition at line 235 of file ExpatCoreParser.cxx.

                                                                                                       {
  const std::string context_str = context ? context : "none";
  if (context != nullptr) {
    const std::string replacement = find_text_entity(context_str);
    if (!replacement.empty()) {
      if (debug_enabled()) {
        std::cout << label() << ">  context=[" << context_str
                  << "] replacement=[" << replacement << "]\n";
      }
      XMLParserPtr p{XML_ExternalEntityParserCreate(parser, context, nullptr)};
      if (!p)  return errorValue;
      return generic_text_parse(p.get(), replacement);
    }
  }
  std::string replacement = find_external_entity(context_str);
  if (replacement == "NULL") {
    return ok;
  }
  std::string originalSystemId = systemId ? systemId : "";
  std::string effectiveSystemId = originalSystemId;
  if (!replacement.empty()) {
    effectiveSystemId = replacement;
  }
  if (debug_enabled()) {
    std::cout << label() << ">  context=[" << context_str
              << "]  systemId=[" << originalSystemId
              << "] replacement=[" << replacement << "]\n";
  }
  XMLParserPtr p{XML_ExternalEntityParserCreate(parser, context, nullptr)};
  if (!p) return errorValue;
  return generic_parse(p.get(), effectiveSystemId);
}

do_start()

void ExpatCoreParser::do_start ( const char * el, const char ** attr )

private

Definition at line 121 of file ExpatCoreParser.cxx.

                                                           {
  auto node = std::make_unique<XMLCoreNode> (XMLCoreNode::ELEMENT_NODE, el);
  if (debug_enabled()) {
    std::cout << label()<< "> el=" << el << " top=" << m_top.get() << " last=" << m_last << " node=" << node << "\n"; 
  }
  for (int i = 0; attr[i]; i += 2) {
    const char* name = attr[i];
    const char* value = attr[i+1];
    node->set_attrib (name, value);
  }
  m_last = add_node (std::move(node));
}

end()

void ExpatCoreParser::end ( void * user_data, const char * el )

staticprivate

Definition at line 39 of file ExpatCoreParser.cxx.

                                                    {
  auto& me = *static_cast<ExpatCoreParser*> (user_data);
  me.do_end (el);
}

external_entity()

int ExpatCoreParser::external_entity ( XML_Parser parser, const XML_Char * context, const XML_Char * , const XML_Char * systemId, const XML_Char *  )

staticprivate

Definition at line 63 of file ExpatCoreParser.cxx.

                                                                  {
  void* user_data = XML_GetUserData (parser);
  auto& me = *static_cast<ExpatCoreParser*> (user_data);
  return (me.do_external_entity (parser, context, systemId));
}

find_entity()

std::string ExpatCoreParser::find_entity ( const std::string & name, const ExternalEntityMap & mapChoice )

private

Definition at line 269 of file ExpatCoreParser.cxx.

                                                                                      { 
  //lock is held here, doesn't need to be held by caller
  lock_t lock (s_mutex);
  ExternalEntityMap::const_iterator it = mapChoice.find(name); 
  return (it == mapChoice.end()) ? emptyString : it->second;
}

find_external_entity()

std::string ExpatCoreParser::find_external_entity ( const std::string & name )

private

Definition at line 276 of file ExpatCoreParser.cxx.

                                                           {
  //coverity[MISSING_LOCK:FALSE] 
  return find_entity(name, s_entities);
} 

find_text_entity()

std::string ExpatCoreParser::find_text_entity ( const std::string & name )

private

Definition at line 282 of file ExpatCoreParser.cxx.

                                                       {
  //coverity[MISSING_LOCK:FALSE]
  return find_entity(name, s_text_entities);
} 

generic_parse()

int ExpatCoreParser::generic_parse ( XML_Parser p, const std::string & file_name )

private

Definition at line 210 of file ExpatCoreParser.cxx.

                                                                      {
  const std::string& path = xmlFileName(file_name, m_prefix);
  if (path.empty()) return errorValue;
  if (debug_enabled()) {
    std::cout << label() << "> file_name=" << file_name
              << " prefix=" << m_prefix << "\n";
  }
  std::ifstream fs{path, std::ios::binary};
  if (!fs) {
    std::cout << "Could not open file " << path << "\n";
    return errorValue;
  }
  return stream_parse(p, fs, file_name);
}

generic_text_parse()

int ExpatCoreParser::generic_text_parse ( XML_Parser p, const std::string & text )

private

Definition at line 226 of file ExpatCoreParser.cxx.

                                                                      {
  if (debug_enabled()) {
    std::cout << label() << ">\n";
  }
  std::istringstream is(text);
  return stream_parse(p, is, {});
}

get_document()

std::unique_ptr< XMLCoreNode > ExpatCoreParser::get_document ( )

private

Definition at line 90 of file ExpatCoreParser.cxx.

                              {
  return std::move(m_top);
}

parse()

std::unique_ptr< XMLCoreNode > ExpatCoreParser::parse ( const std::string & file_name )

static

Definition at line 288 of file ExpatCoreParser.cxx.

                                                 {
  const std::filesystem::path path{file_name};
  ExpatCoreParser me{path.parent_path().string()};
  auto p = make_parser();
  int result = me.generic_parse (p.get(), path.filename().string());
  if (result == errorValue) return nullptr;
  return me.get_document ();
}

parse_string()

std::unique_ptr< XMLCoreNode > ExpatCoreParser::parse_string ( const std::string & text )

static

Definition at line 299 of file ExpatCoreParser.cxx.

                                                   {
  ExpatCoreParser me ("");
  auto p = make_parser();
  int result = me.generic_text_parse (p.get(), text);
  if (result == errorValue) return nullptr;
  return me.get_document ();
}

register_external_entity()

void ExpatCoreParser::register_external_entity ( const std::string & name, const std::string & file_name )

static

Definition at line 71 of file ExpatCoreParser.cxx.

                                                                                            {
  if (debug_enabled()){
    std::cout << label()<<"> name=" << name << " file_name=" << file_name << "\n"; 
  }
  lock_t lock (s_mutex);
  s_entities[name] = file_name; 
} 

register_text_entity()

void ExpatCoreParser::register_text_entity ( const std::string & name, const std::string & text )

static

Definition at line 80 of file ExpatCoreParser.cxx.

                                                                                   {
  if (debug_enabled()) {
    std::cout << label()<<"> name=" << name<< "\n"; 
  }
  lock_t lock (s_mutex);
  s_text_entities[name] = text; 
} 

start()

void ExpatCoreParser::start ( void * user_data, const char * el, const char ** attr )

staticprivate

Definition at line 33 of file ExpatCoreParser.cxx.

                                                                         {
  auto& me = *static_cast<ExpatCoreParser*> (user_data);
  me.do_start (el, attr);
}

stream_parse()

int ExpatCoreParser::stream_parse ( XML_Parser p, std::istream & is, const std::string & source_name = {} )

private

Definition at line 171 of file ExpatCoreParser.cxx.

                                                                                        {
  int result = ok;
  configure_parser(p);
  if (debug_enabled()) {
    std::cout << label() << "> starting\n";
  }
  std::array<char, BUFFSIZE> buff{};
  for (;;) {
    is.read(buff.data(), buff.size());
    const auto nbytes = is.gcount();
    const bool done = is.eof();
    if (is.bad()) {
      std::cout << "Read error";
      if (!source_name.empty()) {
        std::cout << " in " << source_name;
      }
      std::cout << "\n";
      result = errorValue;
      break;
    }
    if (XML_Parse(p, buff.data(), static_cast<int>(nbytes), done) == XML_STATUS_ERROR) {
      std::cout << "ExpatCoreParser::Parse error at line "
                << XML_GetCurrentLineNumber(p);
      if (!source_name.empty()) {
        std::cout << " of " << source_name;
      }
      std::cout << ":\n" << XML_ErrorString(XML_GetErrorCode(p)) << "\n";
      result = errorValue;
      break;
    }
    if (done) {
      break;
    }
  }
  return result;
}

Member Data Documentation

ATLAS_THREAD_SAFE [1/2]

ExternalEntityMap s_text_entities ExpatCoreParser::ATLAS_THREAD_SAFE

staticprivate

Definition at line 64 of file ExpatCoreParser.h.

ATLAS_THREAD_SAFE [2/2]

ExternalEntityMap s_entities ExpatCoreParser::ATLAS_THREAD_SAFE

staticprivate

Definition at line 63 of file ExpatCoreParser.h.

m_last

XMLCoreNode* ExpatCoreParser::m_last {}

private

Definition at line 59 of file ExpatCoreParser.h.

{};

m_prefix

std::string ExpatCoreParser::m_prefix

private

Definition at line 60 of file ExpatCoreParser.h.

m_top

std::unique_ptr<XMLCoreNode> ExpatCoreParser::m_top

private

Definition at line 58 of file ExpatCoreParser.h.

s_mutex

std::mutex ExpatCoreParser::s_mutex

staticprivate

Definition at line 61 of file ExpatCoreParser.h.

---

The documentation for this class was generated from the following files:

• ExpatCoreParser.h
• ExpatCoreParser.cxx