- Add base::Flags (like qt's QFlags) a type-safe way of storing

  OR-combinations of enum values.

diff --git a/devel/devel.ma/NewPool.cc b/devel/devel.ma/NewPool.cc
index 335a046..2d2f8d1 100644 (file)
--- a/devel/devel.ma/NewPool.cc
+++ b/devel/devel.ma/NewPool.cc
@@ -11,6 +11,7 @@
 #include <zypp/base/IOStream.h>
 #include <zypp/base/InputStream.h>
 #include <zypp/base/ProvideNumericId.h>
+#include <zypp/base/Flags.h>
 #include <zypp/AutoDispose.h>
 
 #include "zypp/ResPoolProxy.h"
@@ -421,6 +422,24 @@ void testCMP( const L & lhs, const R & rhs )
 
 namespace zypp
 {
+
+  class XRpmDb
+  {
+    public:
+      enum DbStateInfoBits {
+        DbSI_NO_INIT   = 0x0000,
+        DbSI_HAVE_V4   = 0x0001,
+        DbSI_MADE_V4   = 0x0002,
+        DbSI_MODIFIED_V4       = 0x0004,
+        DbSI_HAVE_V3   = 0x0008,
+        DbSI_HAVE_V3TOV4       = 0x0010,
+        DbSI_MADE_V3TOV4       = 0x0020
+      };
+
+      ZYPP_DECLARE_FLAGS(DbStateInfo,DbStateInfoBits);
+  };
+  ZYPP_DECLARE_OPERATORS_FOR_FLAGS(XRpmDb::DbStateInfo);
+
 }
 
 /******************************************************************
@@ -434,6 +453,20 @@ try {
   ++argv;
   zypp::base::LogControl::instance().logToStdErr();
   INT << "===[START]==========================================" << endl;
+
+  enum Other { OTHERVAL = 13 };
+
+  XRpmDb::DbStateInfo s;
+  s = XRpmDb::DbSI_MODIFIED_V4|XRpmDb::DbSI_HAVE_V4;
+  DBG << s << endl;
+  DBG << s.testFlag( XRpmDb::DbSI_MODIFIED_V4 ) << endl;
+  DBG << s.testFlag( XRpmDb::DbSI_MADE_V3TOV4 ) << endl;
+
+  ///////////////////////////////////////////////////////////////////
+  INT << "===[END]============================================" << endl << endl;
+  zypp::base::LogControl::instance().logNothing();
+  return 0;
+
   ZConfig::instance();
 
   ResPool   pool( ResPool::instance() );

diff --git a/package/libzypp.changes b/package/libzypp.changes
index f14bafd..ade8eec 100644 (file)
--- a/package/libzypp.changes
+++ b/package/libzypp.changes
@@ -1,4 +1,11 @@
 -------------------------------------------------------------------
+Mon Aug 11 16:28:07 CEST 2008 - ma@suse.de
+
+- Add base::Flags (like qt's QFlags) a type-safe way of storing 
+  OR-combinations of enum values.
+- revision 10811
+
+-------------------------------------------------------------------
 Fri Aug  8 17:01:00 CEST 2008 - ma@suse.de
 
 - Add static ui::Selectable::get methods as convenient ctor

diff --git a/zypp/CMakeLists.txt b/zypp/CMakeLists.txt
index e8c69a9..de04fa1 100644 (file)
--- a/zypp/CMakeLists.txt
+++ b/zypp/CMakeLists.txt
@@ -209,6 +209,7 @@ SET( zypp_base_HEADERS
   base/UserRequestException.h
   base/ExternalDataSource.h
   base/Fd.h
+  base/Flags.h
   base/Function.h
   base/Functional.h
   base/Gettext.h

diff --git a/zypp/base/Flags.h b/zypp/base/Flags.h
new file mode 100644 (file)
index 0000000..e414cfb
--- /dev/null
+++ b/zypp/base/Flags.h
@@ -0,0 +1,117 @@
+/*---------------------------------------------------------------------\
+|                          ____ _   __ __ ___                          |
+|                         |__  / \ / / . \ . \                         |
+|                           / / \ V /|  _/  _/                         |
+|                          / /__ | | | | | |                           |
+|                         /_____||_| |_| |_|                           |
+|                                                                      |
+\---------------------------------------------------------------------*/
+/** \file      zypp/base/Flags.h
+ *
+*/
+#ifndef ZYPP_BASE_FLAGS_H
+#define ZYPP_BASE_FLAGS_H
+///////////////////////////////////////////////////////////////////
+namespace zypp
+{ /////////////////////////////////////////////////////////////////
+  ///////////////////////////////////////////////////////////////////
+  namespace base
+  { /////////////////////////////////////////////////////////////////
+
+    ///////////////////////////////////////////////////////////////////
+    //
+    // CLASS NAME : Flags<Enum>
+    //
+    /** A type-safe way of storing OR-combinations of enum values (like QTs QFlags).
+     * \see <a href="http://doc.trolltech.com/4.1/qflags.html">QFlags Class Reference</a>
+     * \code
+     *  class RpmDb
+     *  {
+     *    public:
+     *      enum DbStateInfoBits {
+     *        DbSI_NO_INIT     = 0x0000,
+     *        DbSI_HAVE_V4     = 0x0001,
+     *        DbSI_MADE_V4     = 0x0002,
+     *        DbSI_MODIFIED_V4 = 0x0004,
+     *        DbSI_HAVE_V3     = 0x0008,
+     *        DbSI_HAVE_V3TOV4 = 0x0010,
+     *        DbSI_MADE_V3TOV4 = 0x0020
+     *      };
+     *
+     *      ZYPP_DECLARE_FLAGS(DbStateInfo,DbStateInfoBits);
+     *  };
+     *  ZYPP_DECLARE_OPERATORS_FOR_FLAGS(RpmDb::DbStateInfo);
+     *
+     *  ...
+     *  enum Other { OTHERVAL = 13 };
+     *  {
+     *    XRpmDb::DbStateInfo s;
+     *    s = XRpmDb::DbSI_MODIFIED_V4|XRpmDb::DbSI_HAVE_V4;
+     *    // s |= OTHERVAL; // As desired: it does not compile
+     *  }
+     * \endcode
+     */
+    template<typename Enum>
+    class Flags
+    {
+      public:
+        typedef Enum enum_type;
+
+      public:
+        Flags()                               : _val( 0 ) {}
+        Flags( Enum rhs )                     : _val( rhs ) {}
+        explicit Flags( unsigned rhs )        : _val( rhs ) {}
+
+        Flags & operator&=( unsigned rhs )    { _val &= rhs;      return *this; }
+        Flags & operator&=( Flags rhs )       { _val &= rhs._val; return *this; }
+        Flags & operator&=( Enum rhs )        { _val &= rhs;      return *this; }
+
+        Flags & operator|=( Flags rhs )       { _val |= rhs._val; return *this; }
+        Flags & operator|=( Enum rhs )        { _val |= rhs;      return *this; }
+
+        Flags & operator^=( Flags rhs )       { _val ^= rhs._val; return *this; }
+        Flags & operator^=( Enum rhs )        { _val ^= rhs;      return *this; }
+
+      public:
+        operator unsigned() const             { return _val; }
+
+        Flags operator&( unsigned rhs ) const { return Flags( *this ) &= rhs; }
+        Flags operator&( Flags rhs ) const    { return Flags( *this ) &= rhs; }
+        Flags operator&( Enum rhs ) const     { return Flags( *this ) &= rhs; }
+
+        Flags operator|( Flags rhs ) const    { return Flags( *this ) |= rhs; }
+        Flags operator|( Enum rhs ) const     { return Flags( *this ) |= rhs; }
+
+        Flags operator^( Flags rhs ) const    { return Flags( *this ) ^= rhs; }
+        Flags operator^( Enum rhs ) const     { return Flags( *this ) ^= rhs; }
+
+        Flags operator~() const               { return ~_val; }
+
+      public:
+        bool testFlag( Enum val_r ) const     { return _val & val_r; }
+
+      private:
+        unsigned _val;
+    };
+    ///////////////////////////////////////////////////////////////////
+
+    /** \relates Flags */
+#define ZYPP_DECLARE_FLAGS(Name,Enum) typedef zypp::base::Flags<Enum> Name
+
+    /** \relates Flags */
+#define ZYPP_DECLARE_OPERATORS_FOR_FLAGS(Name) \
+inline Name operator|( Name::enum_type lhs, Name::enum_type rhs )    { return Name( lhs ) |= rhs; } \
+inline Name operator|( Name::enum_type lhs, Name rhs )               { return rhs |= lhs; }
+
+    /** \relates Flags */
+#define ZYPP_DECLARE_FLAGS_AND_OPERATORS(Name,Enum) \
+    ZYPP_DECLARE_FLAGS(Name,Enum); \
+    ZYPP_DECLARE_OPERATORS_FOR_FLAGS(Name)
+
+    /////////////////////////////////////////////////////////////////
+  } // namespace base
+  ///////////////////////////////////////////////////////////////////
+  /////////////////////////////////////////////////////////////////
+} // namespace zypp
+///////////////////////////////////////////////////////////////////
+#endif // ZYPP_BASE_FLAGS_H