sfx2/inc/bitset.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: bitset.hxx,v $
  10  * $Revision: 1.4 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30 #ifndef _SFXBITSET_HXX
  31 #define _SFXBITSET_HXX
  32
  33 #include <tools/solar.h>
  34
  35 class Range;
  36
  37 class BitSet
  38 {
  39 private:
  40     void CopyFrom( const BitSet& rSet );
  41     USHORT nBlocks;
  42     USHORT nCount;
  43     ULONG* pBitmap;
  44 public:
  45     BitSet operator<<( USHORT nOffset ) const;
  46     BitSet operator>>( USHORT nOffset ) const;
  47     static USHORT CountBits( ULONG nBits );
  48     BOOL operator!() const;
  49     BitSet();
  50     BitSet( const BitSet& rOrig );
  51     BitSet( USHORT* pArray, USHORT nSize );
  52     ~BitSet();
  53     BitSet( const Range& rRange );
  54     USHORT Count() const;
  55     BitSet& operator=( const BitSet& rOrig );
  56     BitSet& operator=( USHORT nBit );
  57     BitSet operator|( const BitSet& rSet ) const;
  58     BitSet operator|( USHORT nBit ) const;
  59     BitSet& operator|=( const BitSet& rSet );
  60     BitSet& operator|=( USHORT nBit );
  61     BitSet operator-( const BitSet& rSet ) const;
  62     BitSet operator-( USHORT nId ) const;
  63     BitSet& operator-=( const BitSet& rSet );
  64     BitSet& operator-=( USHORT nBit );
  65     BitSet operator&( const BitSet& rSet ) const;
  66     BitSet& operator&=( const BitSet& rSet );
  67     BitSet operator^( const BitSet& rSet ) const;
  68     BitSet operator^( USHORT nBit ) const;
  69     BitSet& operator^=( const BitSet& rSet );
  70     BitSet& operator^=( USHORT nBit );
  71     BOOL IsRealSubSet( const BitSet& rSet ) const;
  72     BOOL IsSubSet( const BitSet& rSet ) const;
  73     BOOL IsRealSuperSet( const BitSet& rSet ) const;
  74     BOOL Contains( USHORT nBit ) const;
  75     BOOL IsSuperSet( const BitSet& rSet ) const;
  76     BOOL operator==( const BitSet& rSet ) const;
  77     BOOL operator==( USHORT nBit ) const;
  78     BOOL operator!=( const BitSet& rSet ) const;
  79     BOOL operator!=( USHORT nBit ) const;
  80
  81 };
  82 //--------------------------------------------------------------------
  83
  84 // returns TRUE if the set is empty
  85
  86
  87
  88 inline BOOL BitSet::operator!() const
  89 {
  90     return nCount == 0;
  91 }
  92 //--------------------------------------------------------------------
  93
  94 // returns the number of bits in the bitset
  95
  96 inline USHORT BitSet::Count() const
  97 {
  98     return nCount;
  99 }
 100 //--------------------------------------------------------------------
 101
 102 // creates the union of two bitset
 103
 104 inline BitSet BitSet::operator|( const BitSet& rSet ) const
 105 {
 106     return BitSet(*this) |= rSet;
 107 }
 108 //--------------------------------------------------------------------
 109
 110 // creates the union of a bitset with a single bit
 111
 112 inline BitSet BitSet::operator|( USHORT nBit ) const
 113 {
 114     return BitSet(*this) |= nBit;
 115 }
 116 //--------------------------------------------------------------------
 117
 118 // creates the asymetric difference
 119
 120 inline BitSet BitSet::operator-( const BitSet& ) const
 121 {
 122     return BitSet();
 123 }
 124 //--------------------------------------------------------------------
 125
 126 // creates the asymetric difference with a single bit
 127
 128
 129 inline BitSet BitSet::operator-( USHORT ) const
 130 {
 131     return BitSet();
 132 }
 133 //--------------------------------------------------------------------
 134
 135 // removes the bits contained in rSet
 136
 137 inline BitSet& BitSet::operator-=( const BitSet& )
 138 {
 139     return *this;
 140 }
 141 //--------------------------------------------------------------------
 142
 143
 144 // creates the intersection with another bitset
 145
 146 inline BitSet BitSet::operator&( const BitSet& ) const
 147 {
 148     return BitSet();
 149 }
 150 //--------------------------------------------------------------------
 151
 152 // intersects with another bitset
 153
 154 inline BitSet& BitSet::operator&=( const BitSet& )
 155 {
 156     return *this;
 157 }
 158 //--------------------------------------------------------------------
 159
 160 // creates the symetric difference with another bitset
 161
 162 inline BitSet BitSet::operator^( const BitSet& ) const
 163 {
 164     return BitSet();
 165 }
 166 //--------------------------------------------------------------------
 167
 168 // creates the symetric difference with a single bit
 169
 170 inline BitSet BitSet::operator^( USHORT ) const
 171 {
 172     return BitSet();
 173 }
 174 //--------------------------------------------------------------------
 175
 176 // builds the symetric difference with another bitset
 177
 178 inline BitSet& BitSet::operator^=( const BitSet& )
 179 {
 180     return *this;
 181 }
 182 //--------------------------------------------------------------------
 183 #ifdef BITSET_READY
 184 // builds the symetric difference with a single bit
 185
 186 inline BitSet& BitSet::operator^=( USHORT )
 187 {
 188     // crash!!!
 189     return BitSet();
 190 }
 191 #endif
 192 //--------------------------------------------------------------------
 193
 194 // determines if the other bitset is a real superset
 195
 196 inline BOOL BitSet::IsRealSubSet( const BitSet& ) const
 197 {
 198     return FALSE;
 199 }
 200 //--------------------------------------------------------------------
 201
 202 // detsermines if the other bitset is a superset or equal
 203
 204 inline BOOL BitSet::IsSubSet( const BitSet& ) const
 205 {
 206     return FALSE;
 207 }
 208 //--------------------------------------------------------------------
 209
 210 // determines if the other bitset is a real subset
 211
 212 inline BOOL BitSet::IsRealSuperSet( const BitSet& ) const
 213 {
 214     return FALSE;
 215 }
 216
 217 //--------------------------------------------------------------------
 218
 219 // determines if the other bitset is a subset or equal
 220
 221 inline BOOL BitSet::IsSuperSet( const BitSet& ) const
 222 {
 223     return FALSE;
 224 }
 225 //--------------------------------------------------------------------
 226
 227 // determines if the bit is the only one in the bitset
 228
 229 inline BOOL BitSet::operator==( USHORT ) const
 230 {
 231     return FALSE;
 232 }
 233 //--------------------------------------------------------------------
 234
 235 // determines if the bitsets aren't equal
 236
 237 inline BOOL BitSet::operator!=( const BitSet& rSet ) const
 238 {
 239     return !( *this == rSet );
 240 }
 241 //--------------------------------------------------------------------
 242
 243 // determines if the bitset doesn't contain only this bit
 244
 245 inline BOOL BitSet::operator!=( USHORT nBit ) const
 246 {
 247     return !( *this == nBit );
 248 }
 249 //--------------------------------------------------------------------
 250
 251 class IndexBitSet : BitSet
 252 {
 253 public:
 254   USHORT GetFreeIndex();
 255   void ReleaseIndex(USHORT i){*this-=i;}
 256 };
 257
 258
 259 #endif
 260