SetRelationMixin.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_BASE_SETRELATIONMIXIN_H
#define ZYPP_BASE_SETRELATIONMIXIN_H

#include <iosfwd>
#include <string>

#include <zypp-core/base/Easy.h>
#include <zypp-core/base/EnumClass.h>

namespace zypp
{
  struct ESetCompareDef {
    enum Enum {
      uncomparable      = 0,            
      equal             = (1<<0),       
      properSubset      = (1<<1),       
      properSuperset    = (1<<2),       
      disjoint          = (1<<3),       
    };
    static const std::string & asString( Enum val_r ) ZYPP_API;
  };
  using SetCompare = base::EnumClass<ESetCompareDef>;

  inline std::ostream & operator<<( std::ostream & str, const SetCompare::Enum & obj )
  { return str << SetCompare::asString( obj ); }
  inline std::ostream & operator<<( std::ostream & str, const SetCompare & obj )
  { return str << obj.asEnum(); }

  struct ESetRelationDef {
    enum Enum {
      uncomparable      = SetCompare::uncomparable,     
      equal             = SetCompare::equal,            
      properSubset      = SetCompare::properSubset,     
      properSuperset    = SetCompare::properSuperset,   
      disjoint          = SetCompare::disjoint,         
      subset            = properSubset|equal,           
      superset          = properSuperset|equal,         
    };
    static const std::string & asString( Enum val_r ) ZYPP_API;
  };
  using SetRelation = base::EnumClass<ESetRelationDef>;

  inline std::ostream & operator<<( std::ostream & str, const SetRelation::Enum & obj )
  { return str << SetRelation::asString( obj ); }
  inline std::ostream & operator<<( std::ostream & str, const SetRelation & obj )
  { return str << obj.asEnum(); }

  inline bool operator==( const SetRelation::Enum & lhs, const SetCompare::Enum & rhs )
  { return( static_cast<int>(lhs)&static_cast<int>(rhs) || !(static_cast<int>(lhs)|static_cast<int>(rhs)) ); }
  inline bool operator==( const SetRelation::Enum & lhs, const SetCompare & rhs )
  { return( lhs == rhs.asEnum() ); }
  inline bool operator==( const SetRelation & lhs, const SetCompare::Enum & rhs )
  { return( lhs.asEnum() == rhs ); }
  inline bool operator==( const SetRelation & lhs, const SetCompare & rhs )
  { return( lhs.asEnum() == rhs.asEnum() ); }
  inline bool operator==( const SetCompare::Enum & lhs, const SetRelation::Enum & rhs )
  { return( rhs == lhs ); }
  inline bool operator==( const SetCompare::Enum & lhs, const SetRelation & rhs )
  { return( rhs == lhs ); }
  inline bool operator==( const SetCompare & lhs, const SetRelation::Enum & rhs )
  { return( rhs == lhs ); }
  inline bool operator==( const SetCompare & lhs, const SetRelation & rhs )
  { return( rhs == lhs ); }

  inline bool operator!=( const SetRelation::Enum & lhs, const SetCompare::Enum & rhs )
  { return !( lhs == rhs ); }
  inline bool operator!=( const SetRelation::Enum & lhs, const SetCompare & rhs )
  { return !( lhs == rhs ); }
  inline bool operator!=( const SetRelation & lhs, const SetCompare::Enum & rhs )
  { return !( lhs == rhs ); }
  inline bool operator!=( const SetRelation & lhs, const SetCompare & rhs )
  { return !( lhs == rhs ); }
  inline bool operator!=( const SetCompare::Enum & lhs, const SetRelation::Enum & rhs )
  { return !( lhs == rhs ); }
  inline bool operator!=( const SetCompare::Enum & lhs, const SetRelation & rhs )
  { return !( lhs == rhs ); }
  inline bool operator!=( const SetCompare & lhs, const SetRelation::Enum & rhs )
  { return !( lhs == rhs ); }
  inline bool operator!=( const SetCompare & lhs, const SetRelation & rhs )
  { return !( lhs == rhs ); }

  namespace base
  {
    template <class Derived>
    class SetRelationMixin
    {
    public:
      SetCompare compare( const Derived & trg ) const
      { return derived().setRelationMixinCompare( trg ); }
      SetCompare compare( const SetRelationMixin<Derived> & trg ) const
      { return compare( trg.derived() ); }

      bool compare( const Derived & trg, SetCompare cmp ) const
      { return compare( trg ) == cmp; }
      bool compare( const SetRelationMixin<Derived> & trg, SetCompare cmp ) const
      { return compare( trg ) == cmp; }

      bool compare( const Derived & trg, SetRelation rel ) const
      { return compare( trg ) == rel; }
      bool compare( const SetRelationMixin<Derived> & trg, SetRelation rel ) const
      { return compare( trg ) == rel; }

    protected:
      SetRelationMixin() {}
      DEFAULT_COPYABLE( SetRelationMixin );
      DEFAULT_MOVABLE( SetRelationMixin );
      ~SetRelationMixin() {}

    private:
      const Derived & derived() const
      { return *static_cast<const Derived*>( this ); }
    };

    template <class Derived>
    inline SetCompare compare( const SetRelationMixin<Derived> & src, const SetRelationMixin<Derived> & trg )
    { return src.compare( trg ); }

    template <class Derived>
    inline bool compare( const SetRelationMixin<Derived> & src, const SetRelationMixin<Derived> & trg, SetCompare cmp )
    { return src.compare( trg, cmp ); }

    template <class Derived>
    inline bool compare( const SetRelationMixin<Derived> & src, const SetRelationMixin<Derived> & trg, SetRelation rel )
    { return src.compare( trg, rel ); }

    template <class Derived>
    inline bool operator==( const SetRelationMixin<Derived> & src, const SetRelationMixin<Derived> & trg )
    { return src.compare( trg, SetRelation::equal ); }

    template <class Derived>
    inline bool operator!=( const SetRelationMixin<Derived> & src, const SetRelationMixin<Derived> & trg )
    { return !( src == trg ); }

#define SETRELATIONMIXIN_DEFINE_COMPARE_BETWEEN(DERIVED_TYPE,OTHER_TYPE)        \
  inline SetCompare compare( const base::SetRelationMixin<DERIVED_TYPE> & src, OTHER_TYPE trg ) \
  { return src.compare( DERIVED_TYPE(trg) ); }  \
  inline SetCompare compare( OTHER_TYPE src, const base::SetRelationMixin<DERIVED_TYPE> & trg ) \
  { return DERIVED_TYPE(src).compare( trg ); }  \
        \
  inline bool compare( const base::SetRelationMixin<DERIVED_TYPE> & src, OTHER_TYPE trg, SetCompare cmp )       \
  { return src.compare( DERIVED_TYPE(trg), cmp ); }     \
  inline bool compare( OTHER_TYPE src, const base::SetRelationMixin<DERIVED_TYPE> & trg, SetCompare cmp )       \
  { return DERIVED_TYPE(src).compare( trg, cmp ); }     \
        \
  inline bool compare( const base::SetRelationMixin<DERIVED_TYPE> & src, OTHER_TYPE trg, SetRelation rel )      \
  { return src.compare( DERIVED_TYPE(trg), rel ); }     \
  inline bool compare( OTHER_TYPE src, const base::SetRelationMixin<DERIVED_TYPE> & trg, SetRelation rel )      \
  { return DERIVED_TYPE(src).compare( trg, rel ); }     \
        \
  inline bool operator==( const base::SetRelationMixin<DERIVED_TYPE> & src, OTHER_TYPE trg )    \
  { return src.compare( DERIVED_TYPE(trg), SetRelation::equal ); }      \
  inline bool operator==( OTHER_TYPE src, const base::SetRelationMixin<DERIVED_TYPE> & trg )    \
  { return DERIVED_TYPE(src).compare( trg, SetRelation::equal ); }      \
        \
  inline bool operator!=( const base::SetRelationMixin<DERIVED_TYPE> & src, OTHER_TYPE trg )    \
  { return !( src == trg ); }   \
  inline bool operator!=( OTHER_TYPE src, const base::SetRelationMixin<DERIVED_TYPE> & trg )    \
  { return !( src == trg ); }

  } // namespace base
} // namespace zypp
#endif // ZYPP_BASE_SETRELATIONMIXIN_H