This class is responsible for parsing input like hi-there xx=yyy a=b c empty= f-oo=Append(bar, sss) ba_z=123 bing='a b c' baz="a b c d='a b' e" and giving you access to the fields, in this case. More...

#include <text-utils.h>

Collaboration diagram for ConfigLine:

[legend]

Public Member Functions
bool	ParseLine (const std::string &line)

bool	GetValue (const std::string &key, std::string *value)

bool	GetValue (const std::string &key, BaseFloat *value)

bool	GetValue (const std::string &key, int32 *value)

bool	GetValue (const std::string &key, std::vector< int32 > *value)

bool	GetValue (const std::string &key, bool *value)

bool	HasUnusedValues () const

std::string	UnusedValues () const
	returns e.g. More...

const std::string &	FirstToken () const

const std::string	WholeLine ()

Private Attributes
std::string	whole_line_

std::string	first_token_

std::map< std::string, std::pair< std::string, bool > >	data_

Detailed Description

This class is responsible for parsing input like hi-there xx=yyy a=b c empty= f-oo=Append(bar, sss) ba_z=123 bing='a b c' baz="a b c d='a b' e" and giving you access to the fields, in this case.

FirstToken() == "hi-there", and key->value pairs:

xx->yyy, a->"b c", empty->"", f-oo->"Append(bar, sss)", ba_z->"123", bing->"a b c", baz->"a b c d='a b' e"

The first token is optional, if the line started with a key-value pair then FirstValue() will be empty.

Note: it can parse value fields with space inside them only if they are free of the '=' character. If values are going to contain the '=' character, you need to quote them with either single or double quotes.

Key values may contain -_a-zA-Z0-9, but must begin with a-zA-Z_.

Definition at line 205 of file text-utils.h.

Member Function Documentation

◆ FirstToken()

const std::string& FirstToken ( ) const

inline

Definition at line 228 of file text-utils.h.

References ConfigLine::first_token_.

Referenced by CompositeComponent::InitFromConfig(), kaldi::nnet3::ModifyNnetIvectorPeriod(), kaldi::nnet3::ReadEditConfig(), Nnet::RemoveRedundantConfigLines(), and kaldi::UnitTestConfigLineParse().

228 { return first_token_; }

kaldi::ConfigLine::first_token_

std::string first_token_

Definition: text-utils.h:237

◆ GetValue() [1/5]

bool GetValue	(	const std::string &	key,
		std::string *	value
	)

Definition at line 427 of file text-utils.cc.

References ConfigLine::data_, and KALDI_ASSERT.

                                                                 {
   KALDI_ASSERT(value != NULL);
   std::map<std::string, std::pair<std::string, bool> >::iterator it = data_.begin();
   for (; it != data_.end(); ++it) {
     if (it->first == key) {
       *value = (it->second).first;
       (it->second).second = true;
       return true;
     }
   }
   return false;
 }

◆ GetValue() [2/5]

bool GetValue	(	const std::string &	key,
		BaseFloat *	value
	)

Definition at line 440 of file text-utils.cc.

References kaldi::ConvertStringToReal(), ConfigLine::data_, and KALDI_ASSERT.

                                                                 {
   KALDI_ASSERT(value != NULL);
   std::map<std::string, std::pair<std::string, bool> >::iterator it = data_.begin();
   for (; it != data_.end(); ++it) {
     if (it->first == key) {
       if (!ConvertStringToReal((it->second).first, value))
         return false;
       (it->second).second = true;
       return true;
     }
   }
   return false;
 }

◆ GetValue() [3/5]

bool GetValue	(	const std::string &	key,
		int32 *	value
	)

Definition at line 454 of file text-utils.cc.

References kaldi::ConvertStringToInteger(), ConfigLine::data_, and KALDI_ASSERT.

                                                             {
   KALDI_ASSERT(value != NULL);
   std::map<std::string, std::pair<std::string, bool> >::iterator it = data_.begin();
   for (; it != data_.end(); ++it) {
     if (it->first == key) {
       if (!ConvertStringToInteger((it->second).first, value))
         return false;
       (it->second).second = true;
       return true;
     }
   }
   return false;
 }

◆ GetValue() [4/5]

bool GetValue	(	const std::string &	key,
		std::vector< int32 > *	value
	)

Definition at line 468 of file text-utils.cc.

References ConfigLine::data_, KALDI_ASSERT, and kaldi::SplitStringToIntegers().

                                                                        {
   KALDI_ASSERT(value != NULL);
   value->clear();
   std::map<std::string, std::pair<std::string, bool> >::iterator it = data_.begin();
   for (; it != data_.end(); ++it) {
     if (it->first == key) {
       if (!SplitStringToIntegers((it->second).first, ":,", true, value)) {
         // KALDI_WARN << "Bad option " << (it->second).first;
         return false;
       }
       (it->second).second = true;
       return true;
     }
   }
   return false;
 }

◆ GetValue() [5/5]

bool GetValue	(	const std::string &	key,
		bool *	value
	)

Definition at line 485 of file text-utils.cc.

References ConfigLine::data_, and KALDI_ASSERT.

                                                            {
   KALDI_ASSERT(value != NULL);
   std::map<std::string, std::pair<std::string, bool> >::iterator it = data_.begin();
   for (; it != data_.end(); ++it) {
     if (it->first == key) {
       if ((it->second).first.size() == 0) return false;
       switch (((it->second).first)[0]) {
         case 'F':
         case 'f':
           *value = false;
           break;
         case 'T':
         case 't':
           *value = true;
           break;
         default:
           return false;
       }
       (it->second).second = true;
       return true;
     }
   }
   return false;
 }

◆ HasUnusedValues()

bool HasUnusedValues ( ) const

Definition at line 510 of file text-utils.cc.

References ConfigLine::data_.

                                        {
   std::map<std::string, std::pair<std::string, bool> >::const_iterator it = data_.begin();
   for (; it != data_.end(); ++it) {
     if (!(it->second).second) return true;
   }
   return false;
 }

◆ ParseLine()

bool ParseLine ( const std::string & line )

Definition at line 343 of file text-utils.cc.

References ConfigLine::data_, ConfigLine::first_token_, kaldi::IsValidName(), KALDI_WARN, and ConfigLine::whole_line_.

Referenced by kaldi::nnet3::GenerateRandomSimpleComponent(), CompositeComponent::InitFromConfig(), kaldi::nnet3::ModifyNnetIvectorPeriod(), and kaldi::UnitTestConfigLineParse().

                                                 {
   data_.clear();
   whole_line_ = line;
   if (line.size() == 0) return false;   // Empty line
   size_t pos = 0, size = line.size();
   while (isspace(line[pos]) && pos < size) pos++;
   if (pos == size)
     return false;  // whitespace-only line
   size_t first_token_start_pos = pos;
   // first get first_token_.
   while (!isspace(line[pos]) && pos < size) {
     if (line[pos] == '=') {
       // If the first block of non-whitespace looks like "foo-bar=...",
       // then we ignore it: there is no initial token, and FirstToken()
       // is empty.
       pos = first_token_start_pos;
       break;
     }
     pos++;
   }
   first_token_ = std::string(line, first_token_start_pos, pos - first_token_start_pos);
   // first_token_ is expected to be either empty or something like
   // "component-node", which actually is a slightly more restrictive set of
   // strings than IsValidName() checks for this is a convenient way to check it.
   if (!first_token_.empty() && !IsValidName(first_token_))
     return false;
 
   while (pos < size) {
     if (isspace(line[pos])) {
       pos++;
       continue;
     }
 
     // OK, at this point we know that we are pointing at nonspace.
     size_t next_equals_sign = line.find_first_of("=", pos);
     if (next_equals_sign == pos || next_equals_sign == std::string::npos) {
       // we're looking for something like 'key=value'.  If there is no equals sign,
       // or it's not preceded by something, it's a parsing failure.
       return false;
     }
     std::string key(line, pos, next_equals_sign - pos);
     if (!IsValidName(key)) return false;
 
     // handle any quotes.  we support key='blah blah' or key="foo bar".
     // no escaping is supported.
     if (line[next_equals_sign+1] == '\'' || line[next_equals_sign+1] == '"') {
       char my_quote = line[next_equals_sign+1];
       size_t next_quote = line.find_first_of(my_quote, next_equals_sign + 2);
       if (next_quote == std::string::npos) {  // no matching quote was found.
         KALDI_WARN << "No matching quote for " << my_quote << " in config line '"
                    << line << "'";
         return false;
       } else {
         std::string value(line, next_equals_sign + 2,
                           next_quote - next_equals_sign - 2);
         data_.insert(std::make_pair(key, std::make_pair(value, false)));
         pos = next_quote + 1;
         continue;
       }
     } else {
       // we want to be able to parse something like "... input=Offset(a, -1) foo=bar":
       // in general, config values with spaces in them, even without quoting.
 
       size_t next_next_equals_sign = line.find_first_of("=", next_equals_sign + 1),
           terminating_space = size;
 
       if (next_next_equals_sign != std::string::npos) {  // found a later equals sign.
         size_t preceding_space = line.find_last_of(" \t", next_next_equals_sign);
         if (preceding_space != std::string::npos &&
             preceding_space > next_equals_sign)
           terminating_space = preceding_space;
       }
       while (isspace(line[terminating_space - 1]) && terminating_space > 0)
         terminating_space--;
 
       std::string value(line, next_equals_sign + 1,
                         terminating_space - (next_equals_sign + 1));
       data_.insert(std::make_pair(key, std::make_pair(value, false)));
       pos = terminating_space;
     }
   }
   return true;
 }

◆ UnusedValues()

std::string UnusedValues ( ) const

returns e.g.

foo=bar xxx=yyy if foo and xxx were not consumed by one of the GetValue() functions.

Definition at line 518 of file text-utils.cc.

References ConfigLine::data_.

                                          {
   std::string unused_str;
   std::map<std::string, std::pair<std::string, bool> >::const_iterator it = data_.begin();
   for (; it != data_.end(); ++it) {
     if (!(it->second).second) {
       if (unused_str == "")
         unused_str = it->first + "=" + (it->second).first;
       else
         unused_str += " " + it->first + "=" + (it->second).first;
     }
   }
   return unused_str;
 }