/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* * $Id: CMStateSet.hpp 568078 2007-08-21 11:43:25Z amassari $ */ // DESCRIPTION: // // This class is a specialized bitset class for the content model code of // the validator. It assumes that its never called with two objects of // different bit counts, and that bit sets smaller than 64 bits are far // and away the most common. So it can be a lot more optimized than a general // purpose utility bitset class // #if !defined(CMSTATESET_HPP) #define CMSTATESET_HPP #include #include #include #include #include XERCES_CPP_NAMESPACE_BEGIN class CMStateSet : public XMemory { public : // ----------------------------------------------------------------------- // Constructors and Destructor // ----------------------------------------------------------------------- CMStateSet( const unsigned int bitCount , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager) : fBitCount(bitCount) , fByteArray(0) , fMemoryManager(manager) { // // See if we need to allocate the byte array or whether we can live // within the 64 bit high performance scheme. // if (fBitCount > 64) { fByteCount = fBitCount / 8; if (fBitCount % 8) fByteCount++; fByteArray = (XMLByte*) fMemoryManager->allocate(fByteCount*sizeof(XMLByte)); //new XMLByte[fByteCount]; } // Init all the bits to zero zeroBits(); } /* * This method with the 'for' statement (commented out) cannot be made inline * because the antiquated CC (CFront) compiler under HPUX 10.20 does not allow * the 'for' statement inside any inline method. Unfortunately, * we have to support it. So instead, we use memcpy(). */ CMStateSet(const CMStateSet& toCopy) : XMemory(toCopy) , fBitCount(toCopy.fBitCount) , fByteArray(0) , fMemoryManager(toCopy.fMemoryManager) { // // See if we need to allocate the byte array or whether we can live // within the 64 bit high performance scheme. // if (fBitCount > 64) { fByteCount = fBitCount / 8; if (fBitCount % 8) fByteCount++; fByteArray = (XMLByte*) fMemoryManager->allocate(fByteCount*sizeof(XMLByte)); //new XMLByte[fByteCount]; memcpy((void *) fByteArray, (const void *) toCopy.fByteArray, fByteCount * sizeof(XMLByte)); // for (unsigned int index = 0; index < fByteCount; index++) // fByteArray[index] = toCopy.fByteArray[index]; } else { fBits1 = toCopy.fBits1; fBits2 = toCopy.fBits2; } } ~CMStateSet() { if (fByteArray) fMemoryManager->deallocate(fByteArray); //delete [] fByteArray; } // ----------------------------------------------------------------------- // Set manipulation methods // ----------------------------------------------------------------------- void operator&=(const CMStateSet& setToAnd) { if (fBitCount < 65) { fBits1 &= setToAnd.fBits1; fBits2 &= setToAnd.fBits2; } else { for (unsigned int index = 0; index < fByteCount; index++) fByteArray[index] &= setToAnd.fByteArray[index]; } } void operator|=(const CMStateSet& setToOr) { if (fBitCount < 65) { fBits1 |= setToOr.fBits1; fBits2 |= setToOr.fBits2; } else { for (unsigned int index = 0; index < fByteCount; index++) fByteArray[index] |= setToOr.fByteArray[index]; } } bool operator==(const CMStateSet& setToCompare) const { if (fBitCount != setToCompare.fBitCount) return false; if (fBitCount < 65) { return ((fBits1 == setToCompare.fBits1) && (fBits2 == setToCompare.fBits2)); } for (unsigned int index = 0; index < fByteCount; index++) { if (fByteArray[index] != setToCompare.fByteArray[index]) return false; } return true; } CMStateSet& operator=(const CMStateSet& srcSet) { if (this == &srcSet) return *this; // They have to be the same size if (fBitCount != srcSet.fBitCount) ThrowXMLwithMemMgr(RuntimeException, XMLExcepts::Bitset_NotEqualSize, fMemoryManager); if (fBitCount < 65) { fBits1 = srcSet.fBits1; fBits2 = srcSet.fBits2; } else { for (unsigned int index = 0; index < fByteCount; index++) fByteArray[index] = srcSet.fByteArray[index]; } return *this; } bool getBit(const unsigned int bitToGet) const { if (bitToGet >= fBitCount) ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Bitset_BadIndex, fMemoryManager); if (fBitCount < 65) { unsigned int mask = (0x1UL << (bitToGet % 32)); if (bitToGet < 32) return ((fBits1 & mask) != 0); else return ((fBits2 & mask) != 0); } // Create the mask and byte values const XMLByte mask1 = XMLByte(0x1 << (bitToGet % 8)); const unsigned int byteOfs = bitToGet >> 3; // And access the right bit and byte return ((fByteArray[byteOfs] & mask1) != 0); } bool isEmpty() const { if (fBitCount < 65) return ((fBits1 == 0) && (fBits2 == 0)); for (unsigned int index = 0; index < fByteCount; index++) { if (fByteArray[index] != 0) return false; } return true; } void setBit(const unsigned int bitToSet) { if (bitToSet >= fBitCount) ThrowXMLwithMemMgr(ArrayIndexOutOfBoundsException, XMLExcepts::Bitset_BadIndex, fMemoryManager); if (fBitCount < 65) { const unsigned int mask = (0x1UL << (bitToSet % 32)); if (bitToSet < 32) { fBits1 &= ~mask; fBits1 |= mask; } else { fBits2 &= ~mask; fBits2 |= mask; } } else { // Create the mask and byte values const XMLByte mask1 = XMLByte(0x1 << (bitToSet % 8)); const unsigned int byteOfs = bitToSet >> 3; // And access the right bit and byte fByteArray[byteOfs] &= ~mask1; fByteArray[byteOfs] |= mask1; } } void zeroBits() { if (fBitCount < 65) { fBits1 = 0; fBits2 = 0; } else { for (unsigned int index = 0; index < fByteCount; index++) fByteArray[index] = 0; } } int hashCode() const { if (fBitCount < 65) { return fBits1+ fBits2 * 31; } else { int hash = 0; for (int index = fByteCount - 1; index >= 0; index--) hash = fByteArray[index] + hash * 31; return hash; } } private : // ----------------------------------------------------------------------- // Unimplemented constructors and operators // ----------------------------------------------------------------------- CMStateSet(); // ----------------------------------------------------------------------- // Private data members // // fBitCount // The count of bits that the outside world wants to support, // so its the max bit index plus one. // // fByteCount // If the bit count is > 64, then we use the fByteArray member to // store the bits, and this indicates its size in bytes. Otherwise // its value is meaningless and unset. // // fBits1 // fBits2 // When the bit count is <= 64 (very common), these hold the bits. // Otherwise, the fByteArray member holds htem. // // fByteArray // The array of bytes used when the bit count is > 64. It is // allocated as required. // ----------------------------------------------------------------------- unsigned int fBitCount; unsigned int fByteCount; unsigned int fBits1; unsigned int fBits2; XMLByte* fByteArray; MemoryManager* fMemoryManager; }; XERCES_CPP_NAMESPACE_END #endif