Main Page | Class Hierarchy | Class List | File List | Class Members

set.h

00001 //-< SET.H >---------------------------------------------------------*--------*
00002 // GigaBASE                  Version 1.0         (c) 1999  GARRET    *     ?  *
00003 // (Post Relational Database Management System)                      *   /\|  *
00004 //                                                                   *  /  \  *
00005 //                          Created:     17-Jan-99    K.A. Knizhnik  * / [] \ *
00006 //                          Last update: 25-Feb-99    K.A. Knizhnik  * GARRET *
00007 //-------------------------------------------------------------------*--------*
00008 // Small set implementation. Number of elements in the set should
00009 // not be greater than 64. Template class is used to allow static
00010 // type checking for different sets.
00011 //-------------------------------------------------------------------*--------*
00012 
00013 #ifndef __SET_H__
00014 #define __SET_H__
00015 
00016 BEGIN_GIGABASE_NAMESPACE
00017 
00024 template<class T>
00025 class dbSet {
00026   protected:
00027     typedef db_int8 set_t;
00028     set_t bits;
00029   public:
00030     dbSet(set_t elements = 0) : bits(elements) {}
00031     dbSet(T elem) : bits((set_t)1 << elem) {}
00032     dbSet(dbSet<T> const& s) : bits(s.bits) {}
00033 
00034     dbSet(T from, T till)  {
00035         assert(from <= till);
00036         bits = ((set_t)1 << till << 1) - ((set_t)1 << till);
00037     }
00038 
00039     bool operator == (dbSet<T> const& s) const {
00040         return bits == s.bits;
00041     }
00042     bool operator != (dbSet<T> const& s) const {
00043         return bits != s.bits;
00044     }
00045     bool operator == (T elem) const {
00046         return bits == ((set_t)1 << elem);
00047     }
00048     bool operator != (T elem) const {
00049         return bits != ((set_t)1 << elem);
00050     }
00051     bool operator <= (dbSet<T> const& s) const {
00052         return (bits & ~s.bits) == 0;
00053     }
00054     bool operator >= (dbSet<T> const& s) const {
00055         return (s.bits & ~bits) == 0;
00056     }
00057     bool operator < (dbSet<T> const& s) const {
00058         return (bits & ~s.bits) == 0 && bits != s.bits;
00059     }
00060     bool operator > (dbSet<T> const& s) const {
00061         return (s.bits & ~bits) == 0 && bits != s.bits;
00062     }
00063     dbSet<T> operator + (dbSet<T> const& s) const {
00064         dbSet<T> result(bits | s.bits);
00065         return result;
00066     }
00067     dbSet<T> operator + (T elem) const {
00068         dbSet<T> result(bits | ((set_t)1 << elem));
00069         return result;
00070     }
00071     dbSet<T> operator - (dbSet<T> const& s) const {
00072         dbSet<T> result(bits & ~s.bits);
00073         return result;
00074     }
00075     dbSet<T> operator - (T elem) const {
00076         dbSet<T> result(bits & ~((set_t)1 << elem));
00077         return result;
00078     }
00079     dbSet<T> operator * (dbSet<T> const& s) const {
00080         dbSet<T> result(bits & s.bits);
00081         return result;
00082     }
00083     dbSet<T> operator * (T elem) const {
00084         dbSet<T> result(bits & ((set_t)1 << elem));
00085         return result;
00086     }
00087     bool has(T elem) const {
00088         return (bits & ((set_t)1 << elem)) != 0;
00089     }
00090     bool empty() {
00091         return bits == 0;
00092     }
00093     dbSet<T> operator += (T elem) {
00094         bits |= (set_t)1 << elem;
00095         return *this;
00096     }
00097     dbSet<T> operator -= (T elem) {
00098         bits &= ~((set_t)1 << elem);
00099         return *this;
00100     }
00101     dbSet<T> operator = (dbSet<T> const& s) {
00102         bits = s.bits;
00103         return *this;
00104     }
00105     dbSet<T> operator = (T elem) {
00106         bits = (set_t)1 << elem;
00107         return *this;
00108     }
00109 
00113     dbSet<T> operator, (dbSet<T> const& s) {
00114         dbSet<T> result(bits | s.bits);
00115         return result;
00116     }
00120     dbSet<T> operator, (T elem) {
00121         dbSet<T> result(bits | ((set_t)1 << elem));
00122         return result;
00123     }
00124 
00130     dbQueryExpression operator == (char const* field) {
00131         dbQueryExpression expr;
00132         expr = dbComponent(field,"bits"),"=",bits;
00133         return expr;
00134     }
00140     dbQueryExpression operator != (char const* field) {
00141         dbQueryExpression expr;
00142         expr = dbComponent(field,"bits"),"!=",bits;
00143         return expr;
00144     }
00150     dbQueryExpression operator <= (char const* field) {
00151         dbQueryExpression expr;
00152         expr = "(not",dbComponent(field,"bits"),"and",bits,")=0";
00153         return expr;
00154     }
00160     dbQueryExpression operator >= (char const* field) {
00161         dbQueryExpression expr;
00162         expr = "(not",bits,"and",dbComponent(field,"bits"),")=0";
00163         return expr;
00164     }
00170     dbQueryExpression operator < (char const* field) {
00171         dbQueryExpression expr;
00172         expr = "(not",dbComponent(field,"bits"),"and",bits,")=0 and",
00173             dbComponent(field,"bits"),"!=",bits;
00174         return expr;
00175     }
00181     dbQueryExpression operator > (char const* field) {
00182         dbQueryExpression expr;
00183         expr = "(not",bits,"and",dbComponent(field,"bits"),")=0 and",
00184             dbComponent(field,"bits"),"!=",bits;
00185         return expr;
00186     }
00192     dbQueryExpression has(char const* field) {
00193         dbQueryExpression expr;
00194         expr = "(",bits,"and 2^",dbComponent(field),") <> 0";
00195         return expr;
00196     }
00197 
00198     CLASS_DESCRIPTOR(dbSet<T>, (FIELD(bits), METHOD(empty)));
00199 };
00200 
00201 END_GIGABASE_NAMESPACE
00202 
00203 #endif

Generated on Thu Feb 12 18:46:27 2004 for GigaBASE by doxygen 1.3.5