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

Generated on Mon Oct 23 13:23:58 2006 for FastDB by doxygen1.2.18