12#ifndef ZYPP_BASE_FLAGS_H 
   13#define ZYPP_BASE_FLAGS_H 
   57    template<
typename TEnum>
 
  136    template<
typename Enum>
 
  138                           std::string intro_r = 
"[", std::string sep_r = 
"|", 
const std::string &extro_r = 
"]" )
 
  140      std::string ret( std::move(intro_r) );
 
  144      for ( 
const auto & pair : flaglist_r )
 
  146        if ( flag_r.
testFlag( pair.first ) )
 
  151          if ( sep.empty() && !sep_r.empty() )
 
  152          { sep = std::move(sep_r); }
 
  155      mask = flag_r & ~mask;
 
 
  165    template<
typename TEnum>
 
  169    template<
typename TEnum>
 
  171    { 
return str << Flags<TEnum>(obj); }
 
 
  174#define ZYPP_DECLARE_FLAGS(Name,Enum) typedef zypp::base::Flags<Enum> Name 
  177#define ZYPP_DECLARE_OPERATORS_FOR_FLAGS(Name) \ 
  178inline constexpr bool operator==( Name::Enum lhs, Name rhs )            { return( rhs == lhs ); }       \ 
  179inline constexpr bool operator!=(Name:: Enum lhs, Name rhs )            { return( rhs != lhs ); }       \ 
  180inline constexpr Name operator&( Name::Enum lhs, Name::Enum rhs )       { return Name( lhs ) & rhs; }   \ 
  181inline constexpr Name operator&( Name::Enum lhs, Name rhs )             { return rhs & lhs; }           \ 
  182inline constexpr Name operator|( Name::Enum lhs, Name::Enum rhs )       { return Name( lhs ) | rhs; }   \ 
  183inline constexpr Name operator|( Name::Enum lhs, Name rhs )             { return rhs | lhs; }           \ 
  184inline constexpr Name operator^( Name::Enum lhs, Name::Enum rhs )       { return Name( lhs ) ^ rhs; }   \ 
  185inline constexpr Name operator^( Name::Enum lhs, Name rhs )             { return rhs ^ lhs; }           \ 
  186inline constexpr Name operator~( Name::Enum lhs )                       { return ~Name( lhs ); } 
 
  189#define ZYPP_DECLARE_FLAGS_AND_OPERATORS(Name,Enum) \ 
  190    ZYPP_DECLARE_FLAGS(Name,Enum); \ 
  191    ZYPP_DECLARE_OPERATORS_FOR_FLAGS(Name) 
 
A type-safe way of storing OR-combinations of enum values (like QTs QFlags).
constexpr Flags operator^(Enum rhs) const
constexpr bool isNone() const
static constexpr Flags all()
constexpr Flags(Integral flag_r)
constexpr Flags operator|(Flags rhs) const
TEnum Enum
The underlying enum type.
Flags & setFlag(Enum flag_r, bool newval_r)
static constexpr Integral integral(Enum obj)
constexpr Flags operator~() const
Flags & operator&=(Flags rhs)
constexpr bool testFlag(Enum flag_r) const
Flags & setFlag(Enum flag_r)
Flags & operator^=(Flags rhs)
constexpr Flags operator&(Flags rhs) const
Flags & operator&=(Enum rhs)
constexpr Flags(Enum flag_r)
constexpr Flags operator|(Enum rhs) const
constexpr Flags operator&(Enum rhs) const
constexpr bool testFlag(Flags flag_r) const
Flags & operator^=(Enum rhs)
constexpr bool isAll() const
Flags & operator|=(Flags rhs)
constexpr bool testFlag(Integral flag) const
Flags & unsetFlag(Enum flag_r)
Flags & setFlag(Flags flag_r)
Flags & setFlag(Flags flag_r, bool newval_r)
constexpr bool operator!=(Enum rhs) const
Flags & unsetFlag(Flags flag_r)
std::underlying_type_t< Enum > Integral
The underlying integral type.
constexpr bool operator==(Enum rhs) const
constexpr Flags operator^(Flags rhs) const
std::string stringify(const Flags< Enum > &flag_r, const std::initializer_list< std::pair< Flags< Enum >, std::string > > &flaglist_r={}, std::string intro_r="[", std::string sep_r="|", const std::string &extro_r="]")
Stringify Build a string of OR'ed names of each flag value set in flag_r.
static constexpr Flags none()
Flags & operator|=(Enum rhs)
static constexpr Integral integral(Flags obj)
typename underlying_type< T >::type underlying_type_t
String related utilities and Regular expression matching.
std::ostream & operator<<(std::ostream &str, const Flags< TEnum > &obj)
std::string hexstring(char n, int w=4)
Easy-to use interface to the ZYPP dependency resolver.