libzypp  14.48.5
Flags.h
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #ifndef ZYPP_BASE_FLAGS_H
13 #define ZYPP_BASE_FLAGS_H
14 
15 #include "zypp/base/String.h"
16 
18 namespace zypp
19 {
20  namespace base
22  {
23 
25  //
26  // CLASS NAME : Flags<Enum>
27  //
57  template<typename _Enum>
58  class Flags
59  {
60  public:
61  typedef _Enum Enum;
62  typedef typename std::underlying_type<Enum>::type Integral;
63 
64  public:
65  constexpr Flags() : _val( 0 ) {}
66  constexpr Flags( Enum flag_r ) : _val( flag_r ) {}
67  explicit constexpr Flags( Integral flag_r ) : _val( flag_r ) {}
68 
69  Flags & operator&=( Flags rhs ) { _val &= rhs._val; return *this; }
70  Flags & operator&=( Enum rhs ) { _val &= rhs; return *this; }
71 
72  Flags & operator|=( Flags rhs ) { _val |= rhs._val; return *this; }
73  Flags & operator|=( Enum rhs ) { _val |= rhs; return *this; }
74 
75  Flags & operator^=( Flags rhs ) { _val ^= rhs._val; return *this; }
76  Flags & operator^=( Enum rhs ) { _val ^= rhs; return *this; }
77 
78  public:
79  constexpr operator Integral() const { return _val; }
80 
81  constexpr Flags operator&( Flags rhs ) const { return Flags( _val & rhs._val ); }
82  constexpr Flags operator&( Enum rhs ) const { return Flags( _val & rhs ); }
83 
84  constexpr Flags operator|( Flags rhs ) const { return Flags( _val | rhs._val ); }
85  constexpr Flags operator|( Enum rhs ) const { return Flags( _val | rhs ); }
86 
87  constexpr Flags operator^( Flags rhs ) const { return Flags( _val ^ rhs._val ); }
88  constexpr Flags operator^( Enum rhs ) const { return Flags( _val ^ rhs ); }
89 
90  constexpr Flags operator~() const { return Flags( ~_val ); }
91 
92  public:
93  Flags & setFlag( Flags flag_r, bool newval_r ) { return( newval_r ? setFlag(flag_r) : unsetFlag(flag_r) ); }
94  Flags & setFlag( Enum flag_r, bool newval_r ) { return( newval_r ? setFlag(flag_r) : unsetFlag(flag_r) ); }
95 
96  Flags & setFlag( Flags flag_r ) { _val |= flag_r; return *this; }
97  Flags & setFlag( Enum flag_r ) { _val |= flag_r; return *this; }
98 
99  Flags & unsetFlag( Flags flag_r ) { _val &= ~flag_r; return *this; }
100  Flags & unsetFlag( Enum flag_r ) { _val &= ~flag_r; return *this; }
101 
102  bool testFlag( Flags flag_r ) const { return ( _val & flag_r ) == flag_r; }
103  bool testFlag( Enum flag_r ) const { return ( _val & flag_r ) == flag_r; }
104 
105  private:
107  };
109 
110  template<typename Enum>
111  inline std::ostream & operator<<( std::ostream & str, const Flags<Enum> & obj )
112  { return str << str::hexstring(obj); }
113 
115 #define ZYPP_DECLARE_FLAGS(Name,Enum) typedef zypp::base::Flags<Enum> Name
116 
118 #define ZYPP_DECLARE_OPERATORS_FOR_FLAGS(Name) \
119 inline constexpr Name operator&( Name::Enum lhs, Name::Enum rhs ) { return Name( lhs ) & rhs; } \
120 inline constexpr Name operator&( Name::Enum lhs, Name rhs ) { return rhs & lhs; } \
121 inline constexpr Name operator|( Name::Enum lhs, Name::Enum rhs ) { return Name( lhs ) | rhs; } \
122 inline constexpr Name operator|( Name::Enum lhs, Name rhs ) { return rhs | lhs; } \
123 inline constexpr Name operator^( Name::Enum lhs, Name::Enum rhs ) { return Name( lhs ) ^ rhs; } \
124 inline constexpr Name operator^( Name::Enum lhs, Name rhs ) { return rhs ^ lhs; } \
125 inline constexpr Name operator~( Name::Enum lhs ) { return ~Name( lhs ); }
126 
128 #define ZYPP_DECLARE_FLAGS_AND_OPERATORS(Name,Enum) \
129  ZYPP_DECLARE_FLAGS(Name,Enum); \
130  ZYPP_DECLARE_OPERATORS_FOR_FLAGS(Name)
131 
133  } // namespace base
136 } // namespace zypp
138 #endif // ZYPP_BASE_FLAGS_H
Flags & operator^=(Enum rhs)
Definition: Flags.h:76
constexpr Flags operator&(Enum rhs) const
Definition: Flags.h:82
constexpr Flags operator&(Flags rhs) const
Definition: Flags.h:81
constexpr Flags(Enum flag_r)
Definition: Flags.h:66
Flags & operator|=(Flags rhs)
Definition: Flags.h:72
bool testFlag(Flags flag_r) const
Definition: Flags.h:102
constexpr Flags(Integral flag_r)
Definition: Flags.h:67
constexpr Flags operator^(Enum rhs) const
Definition: Flags.h:88
Flags & operator&=(Flags rhs)
Definition: Flags.h:69
A type-safe way of storing OR-combinations of enum values (like QTs QFlags).
Definition: Flags.h:58
Flags & operator|=(Enum rhs)
Definition: Flags.h:73
constexpr Flags operator^(Flags rhs) const
Definition: Flags.h:87
constexpr Flags operator~() const
Definition: Flags.h:90
bool testFlag(Enum flag_r) const
Definition: Flags.h:103
constexpr Flags()
Definition: Flags.h:65
_Enum Enum
The underlying enum type.
Definition: Flags.h:61
constexpr Flags operator|(Enum rhs) const
Definition: Flags.h:85
Flags & operator^=(Flags rhs)
Definition: Flags.h:75
constexpr Flags operator|(Flags rhs) const
Definition: Flags.h:84
Flags & setFlag(Flags flag_r, bool newval_r)
Definition: Flags.h:93
std::underlying_type< Enum >::type Integral
The underlying integral type.
Definition: Flags.h:62
Flags & setFlag(Enum flag_r, bool newval_r)
Definition: Flags.h:94
Flags & setFlag(Enum flag_r)
Definition: Flags.h:97
Flags & setFlag(Flags flag_r)
Definition: Flags.h:96
std::string hexstring(char n, int w=4)
Definition: String.h:346
Flags & unsetFlag(Flags flag_r)
Definition: Flags.h:99
Flags & operator&=(Enum rhs)
Definition: Flags.h:70
Integral _val
Definition: Flags.h:106
Flags & unsetFlag(Enum flag_r)
Definition: Flags.h:100