string_mapped.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
// includes, FEAT
#include <kernel/util/string.hpp>
 
// includes, system
#include <map>
#include <iostream>
 
namespace FEAT
{
  template<typename ValueType_>
  class StringMapped
  {
  private:
    ValueType_& _value;
    const std::map<String, ValueType_>& _value_map;
 
  public:
    explicit StringMapped(ValueType_& value, const std::map<String, ValueType_>& value_map) :
      _value(value),
      _value_map(value_map)
    {
    }
 
    bool lookup(const String& str)
    {
      // try to find
      auto it = _value_map.find(str);
      if(it == _value_map.end())
        return false;
      // okay, assign value
      _value = it->second;
      return true;
    }
 
    friend std::istream& operator>>(std::istream& is, StringMapped& val)
    {
      String str;
      // Try to fetch a string from the stream
      if(!(is >> str).fail())
      {
        // Try to look up the string; if that fails, set the failbit
        if(!val.lookup(str))
        {
          is.setstate(std::ios::failbit);
        }
      }
      return is;
    }
 
    friend std::istream& operator>>(std::istream& is, StringMapped&& val)
    {
      String str;
      // Try to fetch a string from the stream
      if(!(is >> str).fail())
      {
        // Try to look up the string; if that fails, set the failbit
        if(!val.lookup(str))
        {
          is.setstate(std::ios::failbit);
        }
      }
      return is;
    }
 
    friend std::ostream& operator<<(std::ostream& os, const StringMapped& val)
    {
      return (os << (val._value));
    }
 
    friend std::ostream& operator<<(std::ostream& os, StringMapped&& val)
    {
      return (os << (val._value));
    }
  }; // class StringMapped
 
  template<typename ValueType_>
  inline StringMapped<ValueType_> string_mapped(ValueType_& value, const std::map<String, ValueType_>& value_map)
  {
    return StringMapped<ValueType_>(value, value_map);
  }
 
  template<typename ValueType_>
  inline bool string_mapped_lookup(ValueType_& value, const std::map<String, ValueType_>& value_map, const String& str)
  {
    return string_mapped(value, value_map).lookup(str);
  }
} // namespace FEAT