MINT::ParsedParameterLine Class Reference

#include <ParsedParameterLine.h>

Public Member Functions
	ParsedParameterLine (const std::string &line="")
	ParsedParameterLine (const ParsedParameterLine &other)
virtual	~ParsedParameterLine ()
bool	isValid () const
virtual const std::string &	name () const
const std::vector< std::string > &	parsedStrings () const
virtual void	print (std::ostream &os=std::cout) const
virtual void	stringParsingTest (std::ostream &os=std::cout) const

Static Public Member Functions
static bool	isBlank (char c)
static std::string	removeLeadingBlanks (const std::string &s)
static std::string	removeTrailingBlanks (const std::string &s)
static std::string	removeLeadingAndTrailingBlanks (const std::string &s)
static std::string	removeComment (const std::string &line)
static std::string	removeCommentAndLeadingBlanks (const std::string &line)

Protected Member Functions
virtual bool	makeParsedStrings (const std::string &line)

Static Protected Member Functions
static int	makeParsedStrings (const std::string &line, std::vector< std::string > &fillThisList)

Protected Attributes
std::string	_name
std::vector< std::string >	_parsedStrings

Static Protected Attributes
static const std::string	_commentStart ="//"
static const std::string	_testString =" \"para Name\" 78 70 80 90 100 101 10 11 12\\\\ comment "
static const std::string	_testName ="para Name"

Detailed Description

Definition at line 13 of file ParsedParameterLine.h.

Constructor & Destructor Documentation

ParsedParameterLine() [1/2]

MINT::ParsedParameterLine::ParsedParameterLine ( const std::string &  line = "" )

inline

Definition at line 37 of file ParsedParameterLine.h.

                                               {
    makeParsedStrings(line);
    if(_parsedStrings.empty()){
      _parsedStrings.push_back("");
    }
  }

ParsedParameterLine() [2/2]

MINT::ParsedParameterLine::ParsedParameterLine ( const ParsedParameterLine &  other )

inline

Definition at line 43 of file ParsedParameterLine.h.

    : _name(other._name)
    , _parsedStrings(other._parsedStrings)
    {}

~ParsedParameterLine()

virtual MINT::ParsedParameterLine::~ParsedParameterLine ( )

inlinevirtual

Definition at line 48 of file ParsedParameterLine.h.

{};

Member Function Documentation

isBlank()

bool ParsedParameterLine::isBlank ( char  c )

static

Definition at line 19 of file ParsedParameterLine.cpp.

                                       {
  return c==' ' || c=='\t' || c=='\n';
}

isValid()

bool ParsedParameterLine::isValid

(

)

const

Definition at line 64 of file ParsedParameterLine.cpp.

                                       {
  return (! _parsedStrings.empty()) && isalpha(name()[0]);
}

makeParsedStrings() [1/2]

int ParsedParameterLine::makeParsedStrings ( const std::string &  line, std::vector< std::string > &  fillThisList  )

staticprotected

Definition at line 68 of file ParsedParameterLine.cpp.

                                                          {
  
  string s = removeLeadingBlanks(
              removeTrailingBlanks(
           removeComment(line
                 )));

  if(s.empty()) return 0;

  s.push_back(' '); // makes sure we get last element
  s = " " + s;      // makes things easier when we start with quotes.
  string::const_iterator prev=s.begin();
  bool prevBlank=true;
  bool insideQuotes=false;
  // quotes are treated like blanks
  // but blanks are ignored if we 
  // are inside quotes... makes sense?

  bool ignore=false; 
  // NOT ANYMORE: we ignore things inside sqare brackets []
  //   to be compatible with Mikhail's ASCII file
  //   format.
  
  for(string::const_iterator it=s.begin();
      it != s.end(); it++){
    //if((! insideQuotes) && *it == '[') ignore=true;
    if( ((! insideQuotes) && isBlank(*it)) || *it == '"' || ignore){
      if(! prevBlank){
    string tmp_s(prev, it);
    fillThisList.push_back(tmp_s);
      }
      prevBlank=true;
    }else{
      if(prevBlank) prev=it;
      prevBlank=false;
    }
    //if((!insideQuotes) && *it == ']') ignore=false;
    if(*it == '"') insideQuotes = ! insideQuotes;
  }
  if(insideQuotes){
    cout << "WARNING in ParsedParameterLine::makeParsedStrings \n"
     << " unbalanced quotes in string:\n"
     << line << endl;
  }
  return fillThisList.size();
}

makeParsedStrings() [2/2]

bool ParsedParameterLine::makeParsedStrings ( const std::string &  line )

protectedvirtual

Definition at line 116 of file ParsedParameterLine.cpp.

                                                                {
  makeParsedStrings(line, _parsedStrings);
  return ! _parsedStrings.empty();
}

name()

virtual const std::string& MINT::ParsedParameterLine::name ( ) const

inlinevirtual

Definition at line 52 of file ParsedParameterLine.h.

                                       {
    return _parsedStrings[0];
  }

parsedStrings()

const std::vector<std::string>& MINT::ParsedParameterLine::parsedStrings ( ) const

inline

Definition at line 55 of file ParsedParameterLine.h.

                                                   {
    return _parsedStrings;
  }

print()

void ParsedParameterLine::print ( std::ostream &  os = std::cout ) const

virtual

Definition at line 121 of file ParsedParameterLine.cpp.

                                                {
  for(unsigned int i=0; i<_parsedStrings.size(); i++){
    os << _parsedStrings[i];
    if(i != _parsedStrings.size()-1) os << "; ";
  }
}

removeComment()

string ParsedParameterLine::removeComment ( const std::string &  line )

static

Definition at line 49 of file ParsedParameterLine.cpp.

                                                           {
  if(s_in.empty()) return s_in;
  string s = s_in;
  int commentStart = s.find(_commentStart);
  //cout << " commentStart " << commentStart << endl;
  if(commentStart >= 0 && commentStart < (int) s.size()){
    s.resize(commentStart);
  }
  return s;
}

removeCommentAndLeadingBlanks()

string ParsedParameterLine::removeCommentAndLeadingBlanks ( const std::string &  line )

static

Definition at line 60 of file ParsedParameterLine.cpp.

                                                                           {
  return removeComment(removeLeadingBlanks(s_in));
}

removeLeadingAndTrailingBlanks()

std::string ParsedParameterLine::removeLeadingAndTrailingBlanks ( const std::string &  s )

static

Definition at line 45 of file ParsedParameterLine.cpp.

                                                                            {
  return removeTrailingBlanks(removeLeadingBlanks(s));
}

removeLeadingBlanks()

std::string ParsedParameterLine::removeLeadingBlanks ( const std::string &  s )

static

Definition at line 22 of file ParsedParameterLine.cpp.

                                                                 {
  if(s.empty()) return s;
  std::string::const_iterator firstNonBlank=s.begin();
  for(firstNonBlank=s.begin();
      firstNonBlank != s.end() && (isBlank(*firstNonBlank));
      firstNonBlank++) ;
  //  cout << "firstNonBlank: " << *firstNonBlank << "." << endl;

  string new_s(firstNonBlank, s.end());
  return new_s;
}

removeTrailingBlanks()

std::string ParsedParameterLine::removeTrailingBlanks ( const std::string &  s )

static

Definition at line 33 of file ParsedParameterLine.cpp.

                                                                  {
  if(s.empty()) return s;
  std::string::const_iterator lastNonBlank = s.end();
  for(string::const_iterator it=s.begin();
      it != s.end(); it++){
    if(! isBlank(*it)) lastNonBlank = it;
  }
  if(lastNonBlank != s.end()) lastNonBlank++;

  string new_s(s.begin(), lastNonBlank);
  return new_s;
}

stringParsingTest()

void ParsedParameterLine::stringParsingTest ( std::ostream &  os = std::cout ) const

virtual

Definition at line 128 of file ParsedParameterLine.cpp.

                                                               {
  os << "Testing the String Parsing in ParsedParameterLine:" << endl;
  os << "  test string is (w/o the '>' and '<'):\n"
     << "  >" << _testString << "<" << endl;
  string noBlanks = removeLeadingBlanks(_testString);
  os << "  ... removing leading blanks gives:\n"
     << "  >" << noBlanks << "<" << endl;
  os << "  ... removing trailing  blanks gives:\n"
     << "  >" << removeTrailingBlanks(_testString) << "<" << endl;
  string noComment = removeComment(_testString);
  os << "  ... string without comment:\n" 
     << "  >" << noComment << "<"
     << endl;
  os << "  ... string without comment run through removeComment again:\n" 
     << "  >" << removeComment(noComment) << "<"
     << endl;
  os << " ... removeCommentAndLeadingBlanks\n"
     << "  >" << removeCommentAndLeadingBlanks(_testString) << "<"
     << endl;

  vector<string> valueStringList;
  makeParsedStrings(_testString, valueStringList);
  os << "  made value string list:\n";
  for(unsigned int i=0; i< valueStringList.size(); i++){
    os << "  " << i << ") >" << valueStringList[i] << "< " << endl;
  }
  os << "test done." << endl;

  return;
}

Member Data Documentation

_commentStart

const std::string ParsedParameterLine::_commentStart ="//"

staticprotected

Definition at line 16 of file ParsedParameterLine.h.

_name

std::string MINT::ParsedParameterLine::_name

protected

Definition at line 20 of file ParsedParameterLine.h.

_parsedStrings

std::vector<std::string> MINT::ParsedParameterLine::_parsedStrings

protected

Definition at line 21 of file ParsedParameterLine.h.

_testName

const std::string ParsedParameterLine::_testName ="para Name"

staticprotected

Definition at line 18 of file ParsedParameterLine.h.

_testString

const std::string ParsedParameterLine::_testString =" \"para Name\" 78 70 80 90 100 101 10 11 12\\\\ comment "

staticprotected

Definition at line 17 of file ParsedParameterLine.h.

---

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

• Mint/ParsedParameterLine.h
• src/Mint/NamedParameter/ParsedParameterLine.cpp