IdDictParserNS::RegionFactory Class Reference

Inheritance diagram for IdDictParserNS::RegionFactory:

Collaboration diagram for IdDictParserNS::RegionFactory:

Public Member Functions
void	idd_start (IdDictParser &parser, const XMLCoreNode &node)
void	idd_end (IdDictParser &parser, const XMLCoreNode &node)
void	do_start (XMLCoreParser &parser, const XMLCoreNode &node)
void	do_end (XMLCoreParser &parser, const XMLCoreNode &node)
void	start (XMLCoreParser &parser, const XMLCoreNode &node)
void	end (XMLCoreParser &parser, const XMLCoreNode &node)
void	comment (XMLCoreParser &parser, const std::string &comment)
virtual void	do_comment (XMLCoreParser &parser, const std::string &comment)

Static Public Member Functions
static bool	has_attribute (const XMLCoreNode &node, const std::string &name)
static int	get_int (const XMLCoreNode &node, const std::string &name)
static double	get_double (const XMLCoreNode &node, const std::string &name)
static bool	get_boolean (const XMLCoreNode &node, const std::string &name)
static std::string	get_ID (const XMLCoreNode &node, const std::string &name)
static std::string	get_value (const XMLCoreNode &node, const std::string &name)
static std::string	get_token (const XMLCoreNode &node, const std::string &name)
static bool	check_int (const int n, const XMLCoreNode &node, const std::string &name)
static bool	check_double (const int n, const XMLCoreNode &node, const std::string &name)

Protected Attributes
std::string	m_xmlelementname

Detailed Description

Definition at line 80 of file IdDictParser.cxx.

Member Function Documentation

check_double()

bool XMLCoreFactory::check_double ( const int n, const XMLCoreNode & node, const std::string & name )

staticinherited

Definition at line 184 of file XMLCoreParser.cxx.

                                                                                         { 
  std::string checkstring = get_value (node, name); 
  int counter = 0; 
    // 
    // concatenate two times same string to  
    // check the last number of the string 
    // explicitly! 
    // 
  std::string t = checkstring + " " + checkstring; 
  std::istringstream tmpstr (t.c_str()); 
  while (tmpstr.good ()) { 
    double ii{}; 
    counter++; 
    tmpstr >> ii; 
  } 
  if (counter/2 != n) { 
      std::cerr << "XMLCoreFactory::check_double error: (" << counter << ") no " << n  
                << " doubles in \"" << checkstring << "\" for attribute " <<  
          name << ". exit." << std::endl; 
      std::string name1  = get_value (node, "name"); 
      std::string volume = get_value (node, "volume"); 
      if (name1 != "" ) std::cerr << "for name=" << name << std::endl; 
      if (volume != "" ) std::cerr << "for volume=" << volume << std::endl; 
      std::abort();
    } 
  return true; 
} 

check_int()

bool XMLCoreFactory::check_int ( const int n, const XMLCoreNode & node, const std::string & name )

staticinherited

Definition at line 152 of file XMLCoreParser.cxx.

                                                                                      { 
  std::string checkstring = get_value (node, name); 
  int counter = 0; 
    // 
    // concatenate two times same string to  
    // check the last number of the string 
    // explicitly! 
    // 
  std::string t = checkstring + " " + checkstring; 
  std::istringstream tmpstr (t.c_str()); 
  while (tmpstr.good ()) { 
      int ii; 
      counter++; 
      tmpstr >> ii; 
  } 
  if (counter/2 != n) { 
    std::cerr << "XMLCoreFactory::check_int error: no " << n  
              << " ints in \"" << checkstring << "\" for attribute " <<  
        name << ". exit." << std::endl; 
 
    std::string nodename   = get_value (node, "name"); 
    std::string volume = get_value (node, "volume"); 
 
    if (nodename != "" ) std::cerr << "for name=" << nodename << std::endl; 
    if (volume != "" ) std::cerr << "for volume=" << volume << std::endl; 
 
    std::abort();
  } 
  return true; 
} 

comment()

void XMLCoreFactory::comment ( XMLCoreParser & parser, const std::string & comment )

inherited

Definition at line 58 of file XMLCoreParser.cxx.

                                                                        { 
  if (XMLCoreParserDebugger::debug ()){
      std::cout << "XMLCoreFactory::comment>" << std::endl; 
  }
  do_comment (parser,comment); 
} 

do_comment()

void XMLCoreFactory::do_comment ( XMLCoreParser & parser, const std::string & comment )

virtualinherited

Definition at line 80 of file XMLCoreParser.cxx.

                                                                { 
  if (XMLCoreParserDebugger::debug ()){
    std::cout << "XMLCoreFactory::do_comment>" << std::endl; 
  }
} 

do_end()

void IdDictBaseFactory::do_end ( XMLCoreParser & parser, const XMLCoreNode & node )

virtualinherited

Reimplemented from XMLCoreFactory.

Definition at line 157 of file IdDictParser.cxx.

                                                                          {  
  idd_end (static_cast<IdDictParser&>(parser), node);
  parser.down (); 
}  

do_start()

void IdDictBaseFactory::do_start ( XMLCoreParser & parser, const XMLCoreNode & node )

virtualinherited

Reimplemented from XMLCoreFactory.

Definition at line 150 of file IdDictParser.cxx.

                                                       {
  parser.up (); 
  idd_start (static_cast<IdDictParser&>(parser), node);
}  

end()

void XMLCoreFactory::end ( XMLCoreParser & parser, const XMLCoreNode & node )

inherited

Definition at line 50 of file XMLCoreParser.cxx.

                                                                   { 
  if (XMLCoreParserDebugger::debug ()){
      std::cout << "XMLCoreFactory::end>" << std::endl; 
  }
  do_end (parser, node); 
} 

get_boolean()

bool XMLCoreFactory::get_boolean ( const XMLCoreNode & node, const std::string & name )

staticinherited

Definition at line 108 of file XMLCoreParser.cxx.

                                                                           { 
  bool result = false; 
  std::string s = get_token (node, name); 
  if (s == "TRUE") result = true; 
  return (result); 
} 

get_double()

double XMLCoreFactory::get_double ( const XMLCoreNode & node, const std::string & name )

staticinherited

Definition at line 100 of file XMLCoreParser.cxx.

                                                                          { 
  double result = 0; 
  std::string s = get_value (node, name); 
  sscanf (s.c_str (), "%80lg", &result); 
  return (result); 
} 

get_ID()

std::string XMLCoreFactory::get_ID ( const XMLCoreNode & node, const std::string & name )

staticinherited

Definition at line 115 of file XMLCoreParser.cxx.

                                                                                { 
  std::string result = get_value (node, name); 
  return (result); 
} 

get_int()

int XMLCoreFactory::get_int ( const XMLCoreNode & node, const std::string & name )

staticinherited

Definition at line 92 of file XMLCoreParser.cxx.

                                                                       { 
  int result = 0; 
  std::string s = get_value (node, name); 
  sscanf (s.c_str (), "%80d", &result); 
  return (result); 
} 

get_token()

std::string XMLCoreFactory::get_token ( const XMLCoreNode & node, const std::string & name )

staticinherited

Definition at line 135 of file XMLCoreParser.cxx.

                                                                         { 
  std::string result = get_value (node, name); 
    // trim the value 
  while ((result.length () > 0) &&  
         (result.at(0) == ' ')) result.erase (0, 1); 
 
  while ((result.length () > 0) &&  
         (result.at(result.length () - 1) == ' ')) result.erase (result.length () - 1, 1); 
  // Convert to upper case 
  for (std::string::size_type i = 0; i < result.length (); ++i){
    result[i] = std::toupper (result[i]);
  } 
  return (result); 
} 

get_value()

std::string XMLCoreFactory::get_value ( const XMLCoreNode & node, const std::string & name )

staticinherited

Definition at line 121 of file XMLCoreParser.cxx.

                                                                         {
  if (XMLCoreParserDebugger::debug ()){
    std::cout << "XMLCoreFactory::get_value> name=" << name << std::endl; 
  }
  std::string result;
  if (node.has_attrib (name))
    result = node.get_attrib (name);
  if (XMLCoreParserDebugger::debug ()) {
    std::cout << "XMLCoreFactory::get_value>2 value=" << result << std::endl; 
  }
  return (result); 
} 

has_attribute()

bool XMLCoreFactory::has_attribute ( const XMLCoreNode & node, const std::string & name )

staticinherited

Definition at line 87 of file XMLCoreParser.cxx.

                                                                             {
  return node.has_attrib (name);
} 

idd_end()

void RegionFactory::idd_end ( IdDictParser & parser, const XMLCoreNode & node )

virtual

Reimplemented from IdDictParserNS::IdDictBaseFactory.

Definition at line 427 of file IdDictParser.cxx.

                                                                   {  
  if (Debugger::debug ()){ 
    Debugger::tab (parser.level());
    std::cout << "RegionFactory::idd_end>" << std::endl; 
  } 
  if (parser.m_region != 0){ 
    if (parser.m_dictionary != 0) parser.m_dictionary->add_region (parser.m_region.get());
    // Check whether region is empty, i.e. no region entries have
    // been found and added
    if (parser.m_region->n_entries() == 0) {
      parser.m_region->set_is_empty();
    }
 
    if (parser.m_altregions != 0) {
      parser.m_altregions->add_region (std::move(parser.m_region));
    } else if (parser.m_dictionary != 0) {
      parser.m_dictionary->add_dictentry (std::move(parser.m_region));
    } else {
      parser.m_region.reset();
    }
  } 
}  

idd_start()

void RegionFactory::idd_start ( IdDictParser & parser, const XMLCoreNode & node )

virtual

Reimplemented from IdDictParserNS::IdDictBaseFactory.

Definition at line 295 of file IdDictParser.cxx.

                                                                        {
  if (Debugger::debug ()) { 
      Debugger::tab (parser.level());
      std::cout << "RegionFactory::idd_start>" << std::endl; 
  } 
 
  parser.m_region = std::make_unique<IdDictRegion> (get_value (node, "name"),
                                                    get_value (node, "group"),
                                                    get_value (node, "tag"));
 
  // check for next region in absolute eta
  if (has_attribute (node, "next_abs_eta")) { 
      parser.m_region->set_next_abs_eta_name (get_value (node, "next_abs_eta"));
  } 
 
  // Look for regions in the previous sampling
  if (has_attribute (node, "prev_samp")) { 
    std::string names = get_value (node, "prev_samp"); 
    std::string::size_type pos = 0; 
    for (;;) { 
      std::string::size_type next; 
      next = names.find_first_not_of (" ", pos); 
      if (next == std::string::npos) break; 
      pos = next; 
      next = names.find_first_of (" ", pos); 
      std::string name; 
      name = names.substr (pos, next - pos); 
      parser.m_region->add_prev_samp_name (name);
      if (next == std::string::npos) { 
        break; 
      } else {
        pos = next; 
      } 
    } 
  }
  // Look for regions in the next sampling
  if (has_attribute (node, "next_samp")) { 
    std::string names = get_value (node, "next_samp"); 
    std::string::size_type pos = 0; 
    for (;;) { 
        std::string::size_type next; 
 
        next = names.find_first_not_of (" ", pos); 
        if (next == std::string::npos) break; 
        pos = next; 
        next = names.find_first_of (" ", pos); 
 
        std::string name; 
        name = names.substr (pos, next - pos); 
        parser.m_region->add_next_samp_name (name);
 
        if (next == std::string::npos) { 
          break;
        } else {
          pos = next; 
      } 
    } 
  }
  // Look for regions in the prev subdet
  if (has_attribute (node, "prev_subdet")) { 
    std::string names = get_value (node, "prev_subdet"); 
    std::string::size_type pos = 0; 
    for (;;) { 
      std::string::size_type prev; 
      prev = names.find_first_not_of (" ", pos); 
      if (prev == std::string::npos) break; 
      pos = prev; 
      prev = names.find_first_of (" ", pos);
      std::string name; 
      name = names.substr (pos, prev - pos); 
      parser.m_region->add_prev_subdet_name (name);
      if (prev == std::string::npos) { 
        break; 
      } else {
        pos = prev; 
      } 
    } 
  }
  // Look for regions in the next subdet
  if (has_attribute (node, "next_subdet")) { 
    std::string names = get_value (node, "next_subdet"); 
    std::string::size_type pos = 0; 
    for (;;) { 
      std::string::size_type next; 
      next = names.find_first_not_of (" ", pos); 
      if (next == std::string::npos) break; 
      pos = next; 
      next = names.find_first_of (" ", pos); 
      std::string name; 
      name = names.substr (pos, next - pos); 
      parser.m_region->add_next_subdet_name (name);
      if (next == std::string::npos) { 
        break; 
      } else {
        pos = next; 
      } 
    } 
  }
 
  parser.m_region->set_etaphi (get_double (node, "eta0"),
                               get_double (node, "deta"),
                               get_double (node, "phi0"),
                               get_double (node, "dphi"));
 
  if (Debugger::debug ()) { 
    Debugger::tab (parser.level());
    std::cout << "RegionFactory::idd_start> name, group, tag, next eta, prev/next samp, prev/next subdet "
      << parser.m_region->name() << " "
      << parser.m_region->group_name() << " "
      << parser.m_region->tag() << " "
      << parser.m_region->next_abs_eta() << " ";
    for (const std::string& s : parser.m_region->prev_samp_names()) {
      std::cout << s << " ";
    }
    for (const std::string& s : parser.m_region->next_samp_names()) {
      std::cout << s << " ";
    }
    for (const std::string& s : parser.m_region->prev_subdet_names()) {
      std::cout << s << " ";
    }
    for (const std::string& s : parser.m_region->next_subdet_names()) {
      std::cout << s << " ";
    }
    std::cout << parser.m_region->eta0() << " "
      << parser.m_region->deta() << " "
      << parser.m_region->phi0() << " "
      << parser.m_region->dphi() << " "
      << std::endl; 
  } 
}

start()

void XMLCoreFactory::start ( XMLCoreParser & parser, const XMLCoreNode & node )

inherited

Definition at line 42 of file XMLCoreParser.cxx.

                                                                     { 
  if (XMLCoreParserDebugger::debug ()){
      std::cout << "XMLCoreFactory::start> factory=" << this << std::endl; 
    }
  do_start (parser, node); 
} 

Member Data Documentation

m_xmlelementname

std::string XMLCoreFactory::m_xmlelementname

protectedinherited

Definition at line 43 of file XMLCoreParser.h.

---

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

• IdDictParser.cxx