LArBadChannelParser Class Reference

#include <LArBadChannelParser.h>

Collaboration diagram for LArBadChannelParser:

Public Member Functions
	LArBadChannelParser (const std::string &filename, MsgStream *const log, unsigned int numInts, int numStrings, unsigned int firstWildcard=0)
	A parser object must be initialized with the filename that it is to parse.
virtual	~LArBadChannelParser ()
bool	fileStatusGood () const
	You can use this function to check whether file-reading will succeed.
template<typename T>
std::vector< std::pair< std::vector< int >, std::vector< T > > >	parseFile ()
	Parse the file using the following format for each line: First, exactly numInts integers are required.
template<>
bool	convertStrings (std::vector< std::string > &result, const std::vector< std::string >::const_iterator begin, const std::vector< std::string >::const_iterator end) const

Private Member Functions
	LArBadChannelParser ()
std::vector< int >	getIdFields (const std::vector< std::string > &words)
std::vector< std::string >	parseLine (std::string &line) const
template<typename T>
bool	stringToNumber (T &theNumber, const std::string &theStr) const
template<typename T>
bool	convertStrings (std::vector< T > &result, const std::vector< std::string >::const_iterator begin, const std::vector< std::string >::const_iterator end) const

Private Attributes
std::ifstream	m_fin
unsigned int	m_linenumber
const std::string	m_filename
MsgStream *const	m_log
const unsigned int	m_numInts
const int	m_numStrings
const unsigned int	m_firstWildcard

Detailed Description

Definition at line 11 of file LArBadChannelParser.h.

Constructor & Destructor Documentation

LArBadChannelParser() [1/2]

LArBadChannelParser::LArBadChannelParser	(	const std::string &	filename,
		MsgStream *const	log,
		unsigned int	numInts,
		int	numStrings,
		unsigned int	firstWildcard = 0 )

A parser object must be initialized with the filename that it is to parse.

It must also be given a MsgStream pointer for logging messages.

Definition at line 10 of file LArBadChannelParser.cxx.

    : 
  m_linenumber(0), m_filename(file), m_log(log), 
  m_numInts(numInts), m_numStrings(numStrings), 
  m_firstWildcard(firstWildcard)
{
  m_fin.open(m_filename.c_str());
  if(!m_log)
    std::cerr << "ERROR \t LArBadChannelParser was given a NULL MsgStream pointer!" << std::endl;
}

~LArBadChannelParser()

LArBadChannelParser::~LArBadChannelParser ( )

virtual

Definition at line 23 of file LArBadChannelParser.cxx.

{
  m_fin.close();
}

LArBadChannelParser() [2/2]

LArBadChannelParser::LArBadChannelParser ( )

private

Member Function Documentation

convertStrings() [1/2]

template<>

bool LArBadChannelParser::convertStrings ( std::vector< std::string > & result, const std::vector< std::string >::const_iterator begin, const std::vector< std::string >::const_iterator end ) const

inline

Definition at line 164 of file LArBadChannelParser.h.

{
  result.assign(begin, end);
  return true;
}

convertStrings() [2/2]

template<typename T>

bool LArBadChannelParser::convertStrings ( std::vector< T > & result, const std::vector< std::string >::const_iterator begin, const std::vector< std::string >::const_iterator end ) const

inlineprivate

Definition at line 142 of file LArBadChannelParser.h.

{
  result.clear();
  result.reserve(static_cast<unsigned int>(end - begin));
  for(std::vector<std::string>::const_iterator iter = begin; iter != end; ++iter)
  {
    T element;
    if(stringToNumber<T>(element, *iter))
      result.push_back(element);
    else
    {
      (*m_log) << MSG::WARNING << "LArBadChannelParser REJECTED line " << m_linenumber \
        << " -\t failed to extract status." << endmsg;
      return false;
    }
  }
  return true;
}

fileStatusGood()

bool LArBadChannelParser::fileStatusGood ( ) const

inline

You can use this function to check whether file-reading will succeed.

If false, parseFile() will return an empty vector.

Definition at line 74 of file LArBadChannelParser.h.

{
    return m_fin.good();
}

getIdFields()

std::vector< int > LArBadChannelParser::getIdFields ( const std::vector< std::string > & words )

private

Definition at line 54 of file LArBadChannelParser.cxx.

{
  std::vector<int> result;
  std::string w;
  for(unsigned int i = 0; i < m_numInts; ++i)
  {
    w=words[i]; //Copy to non-const string
 
    //Allow 'B' or 'EMB' for Barrel or 'E' for Endcap in first field
    if (i==0) {  
      std::transform(w.begin(), w.end(), w.begin(), upper);
 
      if (w.compare(0,3,"EMB")==0 || w[0]=='B')
    w=std::string("0"); //Replace for barrel
      else if (w[0]=='E')
    w=std::string("1"); //Replace for endcap
    }
    else if (i==1) {  //Allow 'A' and 'C' do describe side in second field
      if (w=="A" || w=="a")
    w=std::string("1"); //Replace for positive side
      else if (w=="C" || w=="c")
    w=std::string("0"); //Replace for negative side
    }
 
    int idComponent(0);
    bool canBeWildcard(m_firstWildcard > 0 && i + 1 >= m_firstWildcard);
    if(canBeWildcard && w == "*")
      result.push_back(-1);   // -1 signifies wildcard 
    else if(stringToNumber<int>(idComponent, w) && idComponent >= 0)
      result.push_back(idComponent);
    else
    {
      (*m_log) << MSG::WARNING << "LArBadChannelParser REJECTED line " << m_linenumber \
        << " -\t word " << i + 1 << " must be a non-negative integer " \
        << (canBeWildcard ? "or " : "and not " ) \
        << "a wildcard: " << words[i] << endmsg;
      result.clear();
      return result;  // return empty vector on error
    }
  }
  return result;
}

parseFile()

template<typename T>

std::vector< std::pair< std::vector< int >, std::vector< T > > > LArBadChannelParser::parseFile ( )

inline

Parse the file using the following format for each line: First, exactly numInts integers are required.

Then, if numString is negative, at least std::abs(numString) strings are required, otherwise exactly numString strings are required. These strings are converted to a vector<T>. A vector of all successfully parsed lines is returned. The integer part of a line may contain wildcards, starting from position firstWildcard (where counting begins from 1); firstWildcard = 0 means wildcards are not allowed. The wildcard character in the input file is "*", it is replaced by -1 in the parsed output. Comments in the ASCII file are demarcated with the '#' character. Lines that fail to parse are skipped, with diagnostic messages sent to the message stream.

Definition at line 80 of file LArBadChannelParser.h.

{
  typedef std::pair< std::vector<int>, std::vector<T> > LineData;
  std::vector<LineData> result;
 
  if(!fileStatusGood())
  {
    (*m_log) << MSG::ERROR << "LArBadChannelParser - Could not open file: " << m_filename << endmsg;
    return result;    //empty result
  }
 
  while(true)
  {
    std::string line;
    std::getline(m_fin, line);
    if(!fileStatusGood())
      break;    // loop termination at end of file
    ++m_linenumber;
    std::vector<std::string> input = parseLine(line);
 
    if(input.size() < m_numInts + std::abs(m_numStrings)) // if line is too short, skip it
    {
      if(input.size() != 0) // complain only for non-empty lines
        {(*m_log) << MSG::WARNING << "LArBadChannelParser REJECTED line " << m_linenumber \
          << " -\t not enough parameters given: " << input.size() << endmsg;}
      continue;
    }
 
    LineData parsedData;
 
    parsedData.first = getIdFields(input);
    if(parsedData.first.size() == 0)
      continue; // getIdFields failed, with error message. Skip this line.
 
    const std::vector<std::string>::const_iterator start = input.begin() + m_numInts;
    const std::vector<std::string>::const_iterator stop = \
      (m_numStrings < 0) ? static_cast<const std::vector<std::string>::const_iterator>(input.end()) : (start + m_numStrings);
 
    if(stop > start)
    { 
      if(!convertStrings<T>(parsedData.second, start, stop))
        continue; //convertStrings failed with error message. Skip this line.
    }
 
    if(stop < input.end())
      (*m_log) << MSG::WARNING << "LArBadChannelParser IGNORED unexpected input on line " << m_linenumber << "." << endmsg;
 
    result.push_back(std::move(parsedData));
    (*m_log) << MSG::VERBOSE << "LArBadChannelParser ACCEPTED line " << m_linenumber << " -\t " << line << endmsg;
  }
 
  (*m_log) << MSG::DEBUG << "LArBadChannelParser - Parsed " << m_linenumber << " lines in file '" << m_filename << "'." << endmsg;
  return result;
}

parseLine()

std::vector< std::string > LArBadChannelParser::parseLine ( std::string & line ) const

private

Definition at line 28 of file LArBadChannelParser.cxx.

{
  std::string::size_type commentPosition = line.find('#');
  if(commentPosition != std::string::npos)  //if a comment is found
    line.erase(commentPosition);        //trim off the comment
  // notice that the input parameter can be changed as a side-effect
 
  std::vector<std::string> result;
  std::string readWord;
  std::istringstream stringIn(line);    
 
  stringIn >> readWord;
  while(stringIn)
  {
    result.push_back(readWord);
    stringIn >> readWord;
  }
  return result;
}

stringToNumber()

template<typename T>

bool LArBadChannelParser::stringToNumber ( T & theNumber, const std::string & theStr ) const

inlineprivate

Definition at line 173 of file LArBadChannelParser.h.

{
        std::istringstream iss(theString);
        //return !(iss >> std::dec >> theNumber).fail() && (static_cast<int>(theString.size()) ==  iss.tellg());
        return !(iss >> std::dec >> theNumber).fail();
       //the second condition checks for invalid input of the form "123abc"
}

Member Data Documentation

m_filename

const std::string LArBadChannelParser::m_filename

private

Definition at line 64 of file LArBadChannelParser.h.

m_fin

std::ifstream LArBadChannelParser::m_fin

private

Definition at line 62 of file LArBadChannelParser.h.

m_firstWildcard

const unsigned int LArBadChannelParser::m_firstWildcard

private

Definition at line 69 of file LArBadChannelParser.h.

m_linenumber

unsigned int LArBadChannelParser::m_linenumber

private

Definition at line 63 of file LArBadChannelParser.h.

m_log

MsgStream* const LArBadChannelParser::m_log

private

Definition at line 65 of file LArBadChannelParser.h.

m_numInts

const unsigned int LArBadChannelParser::m_numInts

private

Definition at line 67 of file LArBadChannelParser.h.

m_numStrings

const int LArBadChannelParser::m_numStrings

private

Definition at line 68 of file LArBadChannelParser.h.

---

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

• LArBadChannelParser.h
• LArBadChannelParser.cxx