NamedValue.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_BASE_NAMEDVALUE_H
#define ZYPP_BASE_NAMEDVALUE_H
 
#include <stdexcept>
#include <string>
#include <map>
 
namespace zypp
{
 
  template< class Tp, const bool _tWithAlias = true >
  class NamedValue
  {
    typedef std::map< std::string, Tp > NameMap;
    typedef std::map< Tp, std::string > ValueMap;
 
  public:
    bool empty() const
    { return( _nameMap.empty() && _valueMap.empty() ); }
 
  public:
      bool haveValue( const std::string & name_r ) const
      {
        typename NameMap::const_iterator it( _nameMap.find( name_r ) );
        return( it != _nameMap.end() );
      }
 
      bool getValue( const std::string & name_r, Tp & value_r ) const
      {
        typename NameMap::const_iterator it( _nameMap.find( name_r ) );
        if ( it == _nameMap.end() )
          return false;
        value_r = it->second;
        return true;
      }
      const Tp & getValue( const std::string & name_r ) const
      { return _nameMap.at( name_r ); }
 
 
      bool haveName( const std::string & value_r ) const
      {
        typename ValueMap::const_iterator it( _valueMap.find( value_r ) );
        return( it != _valueMap.end() );
      }
 
      bool getName( const Tp & value_r, std::string & name_r ) const
      {
        typename ValueMap::const_iterator it( _valueMap.find( value_r ) );
        if ( it == _valueMap.end() )
          return false;
        value_r = it->second;
        return true;
      }
      const std::string & getName( const Tp & value_r ) const
      { return _valueMap.at( value_r ); }
 
  public:
      class TInserter
      {
      public:
        TInserter( NamedValue & parent_r, const Tp & value_r )
        : _parent( &parent_r )
        , _value( value_r )
        {}
        TInserter & operator|( const std::string & name_r )
        { _parent->insert( _value, name_r ); return *this; }
      private:
        NamedValue * _parent;
        Tp _value;
      };
 
      TInserter operator()( const Tp & value_r )
      { return TInserter( *this, value_r ); }
 
    bool insert( const Tp & value_r, const std::string & name_r )
    {
      typename NameMap::const_iterator nit( _nameMap.find( name_r ) );
      if ( nit != _nameMap.end() )      // duplicate name
        throw std::logic_error( "NamedValue::insert name" );
 
      typename ValueMap::const_iterator tit( _valueMap.find( value_r ) );
      if ( tit != _valueMap.end() )     // duplicate value, i.e. an alias
      {
        if ( !_tWithAlias )
          throw std::logic_error( "NamedValue::insert alias" );
 
        _nameMap[name_r] = value_r;
        return false;
      }
      // here: 1st entry for value_r
      _nameMap[name_r] = value_r;
      _valueMap[value_r] = name_r;
      return true;
    }
 
  private:
    NameMap _nameMap;
    ValueMap _valueMap;
  };
 
} // namespace zypp
#endif // ZYPP_BASE_NAMEDVALUE_H