parametertree.hh

Go to the documentation of this file.

/*****************************************************************************
*   This program is part of the msbGrid software                            *
*                                                                           *
*   msbGrid stands for multi-structured block Grid generator                *
*                                                                           *
*   msbGrid is a free software: you can redistribute it and/or modify       *
*   it under the terms of the GNU General Public License as published by    *
*   the Free Software Foundation, either version 2 of the License, or       *
*   (at your option) any later version.                                     *
*                                                                           *
*   msbGrid is distributed in the hope that it will be useful,              *
*   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the           *
*   GNU General Public License for more details.                            *
*                                                                           *
*   See the file COPYING for full copying permissions.                      *
*****************************************************************************/
#include <iostream>
#include <sstream>
#include <algorithm>
#include <vector>
#include <map>

#include <classname.hh>

#ifndef _PARAMETER_TREE_HH_
#define _PARAMETER_TREE_HH_

namespace msbGrid
{
class ParameterTree;
}  /* namespace msbGrid */

class msbGrid :: ParameterTree
{
  template< typename T >
  struct Parser;
public:

  typedef std :: vector< std :: string > KeyVector;

  ParameterTree();

  static ParameterTree &tree()
  {
    static ParameterTree obj_;
    return obj_;
  }

  bool hasKey(const std :: string &key) const;

  bool hasSub(const std :: string &sub) const;

  std :: string &operator[] ( const std :: string & key );

  const std :: string &operator[] ( const std :: string & key ) const;

  void report(std :: ostream &stream = std :: cout, const std :: string &prefix = "") const;

  ParameterTree &sub(const std :: string &sub);

  const ParameterTree &sub(const std :: string &sub) const;

  std :: string get(const std :: string &key, const std :: string &defaultValue) const;

  std :: string get(const std :: string &key, const char *defaultValue) const;

  int get(const std :: string &key, int defaultValue) const;

  double get(const std :: string &key, double defaultValue) const;

  template< typename T >
  T get(const std :: string &key, const T &defaultValue) const
  {
    if ( hasKey(key) ) {
      return get< T >(key);
    } else {
      return defaultValue;
    }
  }

  template< class T >
  T get(const std :: string &key) const
  {
    if ( not hasKey(key) ) {
      std :: cerr << "MSBGRID_THROW : Key '" <<  key << "' not found in parameter file!\nCalling exit(1)\n";
      exit(1);
    }

    return Parser< T > :: parse( ( * this ) [ key ] );

    try {
      return Parser< T > :: parse( ( * this ) [ key ] );
    }

    catch(int x)
    {
      if ( x == 1 ) {
        std :: cerr << "MSBGRID_THROW : Cannot parse value \"" << ( * this ) [ key ] << "\" for key \"" << key << "\" as a " << className< T >() << "\nCalling exit(1)\n";
        exit(1);
      }
    }
  }

  const KeyVector &getValueKeys() const;

  const KeyVector &getSubKeys() const;

protected:
  KeyVector valueKeys;
  KeyVector subKeys;

  std :: map< std :: string, std :: string > values;
  std :: map< std :: string, ParameterTree > subs;
  static std :: string ltrim(const std :: string &s);
  static std :: string rtrim(const std :: string &s);
  static std :: vector< std :: string > split(const std :: string &s);

  // parse into a fixed-size range of iterators
  template< class Iterator >
  static void parseRange(const std :: string &str, Iterator it, const Iterator &end)
  {
    typedef typename std :: iterator_traits< Iterator > :: value_type Value;
    std :: istringstream s(str);
    std :: size_t n = 0;
    for ( ; it != end; ++it, ++n ) {
      s >> * it;
      if ( !s ) {
        std :: cerr << "Cannot parse value \"" << str << "\" as a range of items of type "
                    << className< Value >() << " (" << n << " items were extracted successfully)\nCalling exit(1)\n";
        exit(1);
      }
    }

    Value dummy;
    s >> dummy;
    // now extraction should have failed, and eof should be set
    if ( not s.fail() or not s.eof() ) {
      std :: cerr << "Cannot parse value \"" << str << "\" as a range of " << n << " items of type "
                  << className< Value >() << " (more items than the range can hold)\nCalling exit(1)\n";
      exit(1);
    }
  }
};

msbGrid :: ParameterTree :: ParameterTree()
{}

void msbGrid :: ParameterTree :: report(std :: ostream &stream, const std :: string &prefix) const
{
  typedef std :: map< std :: string, std :: string > :: const_iterator ValueIt;
  ValueIt vit = values.begin();
  ValueIt vend = values.end();

  for ( ; vit != vend; ++vit ) {
    stream << vit->first << " = \"" << vit->second << "\"" << std :: endl;
  }

  typedef std :: map< std :: string, ParameterTree > :: const_iterator SubIt;
  SubIt sit = subs.begin();
  SubIt send = subs.end();
  for ( ; sit != send; ++sit ) {
    stream << "[ " << prefix + sit->first << " ]" << std :: endl;
    ( sit->second ).report(stream, prefix + sit->first + ".");
  }
}

bool msbGrid :: ParameterTree :: hasKey(const std :: string &key) const
{
  std :: string :: size_type dot = key.find(".");

  if ( dot != std :: string :: npos ) {
    std :: string prefix = key.substr(0, dot);
    if ( subs.count(prefix) == 0 ) {
      return false;
    }

    const ParameterTree &s = sub(prefix);
    return s.hasKey( key.substr(dot + 1) );
  } else {
    return ( values.count(key) != 0 );
  }
}

bool msbGrid :: ParameterTree :: hasSub(const std :: string &key) const
{
  std :: string :: size_type dot = key.find(".");

  if ( dot != std :: string :: npos ) {
    std :: string prefix = key.substr(0, dot);
    if ( subs.count(prefix) == 0 ) {
      return false;
    }

    const ParameterTree &s = sub(prefix);
    return s.hasSub( key.substr(dot + 1) );
  } else {
    return ( subs.count(key) != 0 );
  }
}

msbGrid :: ParameterTree &msbGrid :: ParameterTree :: sub(const std :: string &key)
{
  std :: string :: size_type dot = key.find(".");

  if ( dot != std :: string :: npos ) {
    ParameterTree &s = sub( key.substr(0, dot) );
    return s.sub( key.substr(dot + 1) );
  } else {
    if ( subs.count(key) == 0 ) {
      subKeys.push_back( key.substr(0, dot) );
    }

    return subs [ key ];
  }
}

const msbGrid :: ParameterTree &msbGrid :: ParameterTree :: sub(const std :: string &key) const
{
  std :: string :: size_type dot = key.find(".");

  if ( dot != std :: string :: npos ) {
    const ParameterTree &s = sub( key.substr(0, dot) );
    return s.sub( key.substr(dot + 1) );
  } else {
    if ( subs.count(key) == 0 ) {
      std :: cerr << "Key '" << key << "' not found in ParameterTree\nCalling exit(1)\n";
      exit(1);
    }

    return subs.find(key)->second;
  }
}

std :: string &msbGrid :: ParameterTree :: operator[] ( const std :: string & key )
{
  std :: string :: size_type dot = key.find(".");

  if ( dot != std :: string :: npos ) {
    if ( not ( hasSub( key.substr(0, dot) ) ) ) {
      subs [ key.substr(0, dot) ];
      subKeys.push_back( key.substr(0, dot) );
    }

    ParameterTree &s = sub( key.substr(0, dot) );
    return s [ key.substr(dot + 1) ];
  } else {
    if ( not ( hasKey(key) ) ) {
      valueKeys.push_back(key);
    }

    return values [ key ];
  }
}

const std :: string &msbGrid :: ParameterTree :: operator[] ( const std :: string & key ) const
{
  std :: string :: size_type dot = key.find(".");

  if ( dot != std :: string :: npos ) {
    if ( not ( hasSub( key.substr(0, dot) ) ) ) {
      std :: cerr << "Key '" << key << "' not found in ParameterTree\nCalling exit(1)\n";
      exit(1);
    }

    const ParameterTree &s = sub( key.substr(0, dot) );
    return s [ key.substr(dot + 1) ];
  } else {
    if ( not ( hasKey(key) ) ) {
      std :: cerr << "Key '" << key << "' not found in ParameterTree\nCalling exit(1)\n";
      exit(1);
    }

    return values.find(key)->second;
  }
}

std :: string msbGrid :: ParameterTree :: get(const std :: string &key, const std :: string &defaultValue) const
{
  if ( hasKey(key) ) {
    return ( * this ) [ key ];
  } else {
    return defaultValue;
  }
}

std :: string msbGrid :: ParameterTree :: get(const std :: string &key, const char *defaultValue) const
{
  if ( hasKey(key) ) {
    return ( * this ) [ key ];
  } else {
    return defaultValue;
  }
}

int msbGrid :: ParameterTree :: get(const std :: string &key, int defaultValue) const
{
  std :: stringstream stream;
  stream << defaultValue;
  std :: string ret = get( key, stream.str() );

  return atoi( ret.c_str() );
}

double msbGrid :: ParameterTree :: get(const std :: string &key, double defaultValue) const
{
  if ( hasKey(key) ) {
    return atof( ( * this ) [ key ].c_str() );
  } else {
    return defaultValue;
  }
}

std :: string msbGrid :: ParameterTree :: ltrim(const std :: string &s)
{
  std :: size_t firstNonWS = s.find_first_not_of(" \t\n\r");

  if ( firstNonWS != std :: string :: npos ) {
    return s.substr(firstNonWS);
  }

  return std :: string();
}

std :: string msbGrid :: ParameterTree :: rtrim(const std :: string &s)
{
  std :: size_t lastNonWS = s.find_last_not_of(" \t\n\r");

  if ( lastNonWS != std :: string :: npos ) {
    return s.substr(0, lastNonWS + 1);
  }

  return std :: string();
}

std :: vector< std :: string > msbGrid :: ParameterTree :: split(const std :: string &s)
{
  std :: vector< std :: string > substrings;
  std :: size_t front = 0, back = 0, size = 0;

  while ( front != std :: string :: npos ) {
    // find beginning of substring
    front = s.find_first_not_of(" \t\n\r", back);
    back  = s.find_first_of(" \t\n\r", front);
    size  = back - front;
    if ( size > 0 ) {
      substrings.push_back( s.substr(front, size) );
    }
  }

  return substrings;
}

const msbGrid :: ParameterTree :: KeyVector &msbGrid :: ParameterTree :: getValueKeys() const
{
  return valueKeys;
}

const msbGrid :: ParameterTree :: KeyVector &msbGrid :: ParameterTree :: getSubKeys() const
{
  return subKeys;
}

template< typename T >
struct msbGrid :: ParameterTree :: Parser
{
  static T parse(const std :: string &str)
  {
    T val;
    std :: istringstream s(str);
    s >> val;
    if ( !s ) {
      std :: cerr << "Cannot parse value \"" << str << "\" as a " << className< T >() << "\nCalling exit(1)\n";
      exit(1);
    }

    T dummy;
    s >> dummy;

    // now extraction should have failed, and eof should be set
    if ( not s.fail() or not s.eof() ) {
      std :: cerr << "Cannot parse value \"" << str << "\" as a " << className< T >() << "\nCalling exit(1)\n";
      exit(1);
    }

    return val;
  }
};

namespace msbGrid
{
template< typename traits, typename Allocator >
struct ParameterTree :: Parser< std :: basic_string< char, traits, Allocator > >
{
  static std :: basic_string< char, traits, Allocator >
  parse(const std :: string &str)
  {
    std :: string trimmed = ltrim( rtrim(str) );
    return std :: basic_string< char, traits, Allocator >( trimmed.begin(), trimmed.end() );
  }
};

template< >
struct ParameterTree :: Parser< bool >
{
  struct ToLower
  {
    int operator() (int c)
    {
      return std :: tolower(c);
    }
  };

  static bool
  parse(const std :: string &str)
  {
    std :: string ret = str;

    std :: transform( ret.begin(), ret.end(), ret.begin(), ToLower() );

    if ( ret == "yes" || ret == "true" ) {
      return true;
    }

    if ( ret == "no" || ret == "false" ) {
      return false;
    }

    return ( Parser< int > :: parse(ret) != 0 );
  }
};

template< typename T, typename A >
struct ParameterTree :: Parser< std :: vector< T, A > >
{
  static std :: vector< T, A >
  parse(const std :: string &str)
  {
    std :: vector< std :: string > sub = split(str);
    std :: vector< T, A > vec;
    for ( unsigned int i = 0; i < sub.size(); ++i ) {
      T val = ParameterTree :: Parser< T > :: parse(sub [ i ]);
      vec.push_back(val);
    }

    return vec;
  }
};
}

#endif  /* #ifndef _PARAMETER_TREE_HH_ */