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

set.h

00001 //-< SET.H >---------------------------------------------------------*--------*
00002 // FastDB                    Version 1.0         (c) 1999  GARRET    *     ?  *
00003 // (Main Memory Database Management System)                          *   /\|  *
00004 //                                                                   *  /  \  *
00005 //                          Created:     17-Jan-99    K.A. Knizhnik  * / [] \ *
00006 //                          Last update: 25-Jan-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 
00021 template<class T>
00022 class dbSet { 
00023   protected:
00024     typedef db_int8 set_t;
00025     set_t bits;
00026   public:
00027     dbSet(set_t elements = 0) : bits(elements) {}
00028     dbSet(T elem) : bits((set_t)1 << elem) {}
00029     dbSet(dbSet const& s) : bits(s.bits) {}
00030 
00031     dbSet(T from, T till)  {
00032         assert(from <= till);
00033         bits = ((set_t)1 << till << 1) - ((set_t)1 << till);
00034     }
00035 
00036     bool operator == (dbSet const& s) const {
00037         return bits == s.bits; 
00038     }
00039     bool operator != (dbSet const& s) const { 
00040         return bits != s.bits; 
00041     }
00042     bool operator == (T elem) const { 
00043         return bits == ((set_t)1 << elem); 
00044     }
00045     bool operator != (T elem) const { 
00046         return bits != ((set_t)1 << elem); 
00047     }
00048     bool operator <= (dbSet const& s) const { 
00049         return (bits & ~s.bits) == 0; 
00050     }
00051     bool operator >= (dbSet const& s) const { 
00052         return (s.bits & ~bits) == 0; 
00053     }
00054     bool operator < (dbSet const& s) const { 
00055         return (bits & ~s.bits) == 0 && bits != s.bits; 
00056     }
00057     bool operator > (dbSet const& s) const { 
00058         return (s.bits & ~bits) == 0 && bits != s.bits; 
00059     }
00060     dbSet operator + (dbSet const& s) const {
00061         dbSet result(bits | s.bits);
00062         return result;
00063     }
00064     dbSet operator + (T elem) const {
00065         dbSet result(bits | ((set_t)1 << elem));
00066         return result;
00067     }
00068     dbSet operator - (dbSet const& s) const {
00069         dbSet result(bits & ~s.bits);
00070         return result;
00071     }
00072     dbSet operator - (T elem) const {
00073         dbSet result(bits & ~((set_t)1 << elem));
00074         return result;
00075     }
00076     dbSet operator * (dbSet const& s) const {
00077         dbSet result(bits & s.bits);
00078         return result;
00079     }
00080     dbSet operator * (T elem) const {
00081         dbSet result(bits & ((set_t)1 << elem));
00082         return result;
00083     }                      
00084     bool has(T elem) const { 
00085         return (bits & ((set_t)1 << elem)) != 0;
00086     }
00087     bool empty() { 
00088         return bits == 0;
00089     }
00090     dbSet operator += (T elem) { 
00091         bits |= (set_t)1 << elem;
00092         return *this;
00093     }
00094     dbSet operator -= (T elem) { 
00095         bits &= ~((set_t)1 << elem);
00096         return *this;
00097     }
00098     dbSet operator = (dbSet const& s) { 
00099         bits = s.bits;
00100         return *this;
00101     }
00102     dbSet operator = (T elem) { 
00103         bits = (set_t)1 << elem;
00104         return *this;
00105     }
00106 
00107     dbSet operator, (dbSet const& s) {
00108         dbSet result(bits | s.bits);
00109         return result;
00110     }
00111     dbSet operator, (T elem) {
00112         dbSet result(bits | ((set_t)1 << elem));
00113         return result;
00114     }
00115         
00116     dbQueryExpression operator == (char const* field) { 
00117         dbQueryExpression expr;
00118         expr = dbComponent(field,"bits"),"=",bits;
00119         return expr;
00120     }
00121     dbQueryExpression operator != (char const* field) { 
00122         dbQueryExpression expr;
00123         expr = dbComponent(field,"bits"),"!=",bits;
00124         return expr;
00125     }
00126     dbQueryExpression operator <= (char const* field) { 
00127         dbQueryExpression expr;
00128         expr = "(not",dbComponent(field,"bits"),"and",bits,")=0";
00129         return expr;
00130     }
00131     dbQueryExpression operator >= (char const* field) { 
00132         dbQueryExpression expr;
00133         expr = "(not",bits,"and",dbComponent(field,"bits"),")=0";
00134         return expr;
00135     }
00136     dbQueryExpression operator < (char const* field) { 
00137         dbQueryExpression expr;
00138         expr = "(not",dbComponent(field,"bits"),"and",bits,")=0 and",
00139             dbComponent(field,"bits"),"!=",bits;
00140         return expr;
00141     }
00142     dbQueryExpression operator > (char const* field) { 
00143         dbQueryExpression expr;
00144         expr = "(not",bits,"and",dbComponent(field,"bits"),")=0 and",
00145             dbComponent(field,"bits"),"!=",bits;
00146         return expr;
00147     }
00148     dbQueryExpression has(char const* field) {
00149         dbQueryExpression expr;
00150         expr = "(",bits,"and 2^",dbComponent(field),") <> 0";
00151         return expr;
00152     }   
00153 
00154     CLASS_DESCRIPTOR(dbSet, (FIELD(bits), METHOD(empty)));
00155 };
00156 
00157 #endif

Generated on Thu Feb 12 13:04:48 2004 for FastDB by doxygen 1.3.5