Dep.cc

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#include <map>
#include <iostream>
 
#include <zypp/base/Exception.h>
#include <zypp/base/Gettext.h>
#include <zypp/base/String.h>
 
#include <zypp/Dep.h>

namespace zypp
{ 
 
  namespace
  {
    inline Dep::for_use_in_switch parse( const std::string & strval_r )
    {
      const std::map<std::string,Dep::for_use_in_switch> _table = {
        { "provides",           Dep::PROVIDES_e          },
        { "prerequires",        Dep::PREREQUIRES_e    },
        { "requires",           Dep::REQUIRES_e          },
        { "conflicts",          Dep::CONFLICTS_e        },
        { "obsoletes",          Dep::OBSOLETES_e        },
        { "recommends",         Dep::RECOMMENDS_e      },
        { "suggests",           Dep::SUGGESTS_e          },
        { "enhances",           Dep::ENHANCES_e          },
        { "supplements",        Dep::SUPPLEMENTS_e    }
      };
 
      auto it = _table.find( str::toLower( strval_r ) );
      if ( it == _table.end() )
      {
        ZYPP_THROW( Exception("Dep parse: illegal string value '"+strval_r+"'") );
      }
      return it->second;
    }
  }

 
  const Dep Dep::PROVIDES   ( Dep::PROVIDES_e );
  const Dep Dep::PREREQUIRES( Dep::PREREQUIRES_e );
  const Dep Dep::REQUIRES   ( Dep::REQUIRES_e );
  const Dep Dep::CONFLICTS  ( Dep::CONFLICTS_e );
  const Dep Dep::OBSOLETES  ( Dep::OBSOLETES_e );
  const Dep Dep::RECOMMENDS ( Dep::RECOMMENDS_e );
  const Dep Dep::SUGGESTS   ( Dep::SUGGESTS_e );
  const Dep Dep::ENHANCES   ( Dep::ENHANCES_e );
  const Dep Dep::SUPPLEMENTS( Dep::SUPPLEMENTS_e );

  //
  //    METHOD NAME : Dep::Dep
  //    METHOD TYPE : Ctor
  //
  Dep::Dep( const std::string & strval_r )
  : _type( parse( strval_r ) )
  {}

  //
  //    METHOD NAME : Dep::asString
  //    METHOD TYPE : const std::string &
  //
  const std::string & Dep::asString() const
  {
    static const std::map<for_use_in_switch,std::string> _table = {
      { PROVIDES_e,   "provides"      },
      { PREREQUIRES_e,     "prerequires"   },
      { REQUIRES_e,   "requires"      },
      { CONFLICTS_e, "conflicts"     },
      { OBSOLETES_e, "obsoletes"     },
      { RECOMMENDS_e,       "recommends"    },
      { SUGGESTS_e,   "suggests"      },
      { ENHANCES_e,   "enhances"      },
      { SUPPLEMENTS_e,     "supplements"   }
    };
    return _table.at(_type);
  }
 
  std::string Dep::asUserString() const
  {
    switch ( inSwitch() )
    {
      case PROVIDES_e:                return _("Provides");          break;
      case PREREQUIRES_e:  return _("Prerequires");       break;
      case REQUIRES_e:                return _("Requires");          break;
      case CONFLICTS_e:              return _("Conflicts");         break;
      case OBSOLETES_e:              return _("Obsoletes");         break;
      case RECOMMENDS_e:    return _("Recommends");                break;
      case SUGGESTS_e:                return _("Suggests");          break;
      case ENHANCES_e:                return _("Enhances");          break;
      case SUPPLEMENTS_e:  return _("Supplements");       break;
    }
    return "<missing translation>";
  }

} // namespace zypp