UserData.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_USERDATA_H
#define ZYPP_USERDATA_H
 
#include <iosfwd>
#include <string>
#include <map>
#include <boost/any.hpp>
 
#include <zypp/base/PtrTypes.h>
#include <zypp/ContentType.h>
 
namespace zypp
{
  namespace callback
  {
    class UserData
    {
    public:
      typedef boost::any                        AnyType;
      typedef boost::bad_any_cast               bad_AnyType_cast;
 
      typedef std::map<std::string,AnyType>     DataType;
      typedef DataType::size_type               size_type;
      typedef DataType::key_type                key_type;
      typedef DataType::value_type              value_type;
      typedef DataType::const_iterator          const_iterator;
 
      typedef zypp::ContentType                 ContentType;
 
    public:
      UserData()
      {}
 
      explicit UserData( ContentType type_r )
      : _type( std::move(type_r) )
      {}
      explicit UserData( std::string type_r )
      : UserData( ContentType( std::move(type_r) ) )
      {}
      UserData( std::string type_r, std::string subtype_r )
      : UserData( ContentType( std::move(type_r), std::move(subtype_r) ) )
      {}
 
    public:
      const ContentType & type() const
      { return _type; }
 
      void type( ContentType type_r )
      { _type = std::move(type_r); }
 
    public:
      explicit operator bool() const
      { return !empty(); }
 
      bool empty() const
      { return !_dataP || _dataP->empty(); }
 
      size_type size() const
      { return _dataP ? _dataP->size() : 0;  }
 
      const DataType & data() const
      { return dataRef(); }
 
      bool haskey( const std::string & key_r ) const
      { return _dataP && _dataP->find( key_r ) != _dataP->end(); }
 
      bool hasvalue( const std::string & key_r ) const
      {
        bool ret = false;
        if ( _dataP )
        {
          const_iterator it = _dataP->find( key_r );
          if ( it != _dataP->end() && ! it->second.empty() )
          {
            ret = true;
          }
        }
        return ret;
      }
 
      bool set( const std::string & key_r, AnyType val_r )
      { dataRef()[key_r] = std::move(val_r); return true; }
      bool set( const std::string & key_r, AnyType val_r ) const
      {
        bool ret = false;
        AnyType & val( dataRef()[key_r] );
        if ( val.empty() )
        {
          val = std::move(val_r);
          ret = true;
        }
        return ret;
      }
 
      bool reset( const std::string & key_r )
      { return set( key_r, AnyType() ); }
      bool reset( const std::string & key_r ) const
      { return set( key_r, AnyType() ); }
 
      void erase( const std::string & key_r )
      { if ( _dataP ) _dataP->erase( key_r ); }
 
      const AnyType & getvalue( const std::string & key_r ) const
      {
        if ( _dataP )
        {
          const_iterator it = _dataP->find( key_r );
          if ( it != _dataP->end() )
          {
            return it->second;
          }
        }
        static const AnyType none;
        return none;
      }
 
      template <class Tp>
      const Tp & get( const std::string & key_r ) const
      { return boost::any_cast<const Tp &>( getvalue( key_r ) ); }
 
      template <class Tp>
      Tp get( const std::string & key_r, const Tp & default_r ) const
      { Tp ret( default_r ); get( key_r, ret ); return ret; }
 
      template <class Tp>
      bool get( const std::string & key_r, Tp & ret_r ) const
      {
        bool ret = false;
        if ( _dataP )
        {
          const_iterator it = _dataP->find( key_r );
          if ( it != _dataP->end() )
          {
            auto ptr = boost::any_cast<const Tp>(&it->second);
            if ( ptr )
            {
              ret_r = *ptr;
              ret = true;
            }
          }
        }
        return ret;
      }
 
    private:
      DataType & dataRef() const
      { if ( ! _dataP ) _dataP.reset( new DataType ); return *_dataP; }
 
    private:
      ContentType _type;
      mutable shared_ptr<DataType> _dataP;
    };
 
    inline std::ostream & operator<<( std::ostream & str, const UserData & obj )
    { return str << "UserData(" << obj.type() << ":" << obj.size() << ")";}
 
  } // namespace callback
} // namespace zypp
#endif // ZYPP_USERDATA_H