ASN1CBitStr.h

Go to the documentation of this file.
00001 /*
00002  * Copyright (c) 1997-2014 Objective Systems, Inc.
00003  *
00004  * This software is furnished under a license and may be used and copied
00005  * only in accordance with the terms of such license and with the
00006  * inclusion of the above copyright notice. This software or any other
00007  * copies thereof may not be provided or otherwise made available to any
00008  * other person. No title to and ownership of the software is hereby
00009  * transferred.
00010  *
00011  * The information in this software is subject to change without notice
00012  * and should not be construed as a commitment by Objective Systems, Inc.
00013  *
00014  * PROPRIETARY NOTICE
00015  *
00016  * This software is an unpublished work subject to a confidentiality agreement
00017  * and is protected by copyright and trade secret law.  Unauthorized copying,
00018  * redistribution or other use of this work is prohibited.
00019  *
00020  * The above notice of copyright on this source code product does not indicate
00021  * any actual or intended publication of such source code.
00022  *
00023  *****************************************************************************/
00024 
00025 #ifndef _ASN1CBITSTR_H_
00026 #define _ASN1CBITSTR_H_
00027 
00028 #include "rtsrc/asn1CppTypes.h"
00037 
00038 //
00039 // ASN1CBitStr
00040 //
00041 // Bit string implementation. This class provides all functionalty
00042 // necessary for bit strings.
00043 //
00044 // Author Artem Bolgar.
00045 // version 1.52   21 Feb, 2003
00046 //
00047 #ifndef _NO_UTILS_CLASSES
00048 
00058 class ASN1CBitStrSizeHolder {
00059  public:
00060    virtual ASN1CBitStrSizeHolder* clone () = 0;
00061    virtual OSUINT32 getValue () const = 0;
00062    virtual int setValue (OSUINT32 value) = 0;
00063 
00064    virtual ~ASN1CBitStrSizeHolder() {}
00065 } ;
00066 
00067 class ASN1CBitStrSizeHolder8 : public ASN1CBitStrSizeHolder {
00068  protected:
00069    OSUINT8& mSize;
00070 
00071  public:
00072    ASN1CBitStrSizeHolder8 (OSUINT8& value) : mSize(value) {}
00073    virtual ASN1CBitStrSizeHolder* clone () {
00074       return new ASN1CBitStrSizeHolder8 (mSize);
00075    }
00076    virtual OSUINT32 getValue () const { return mSize; }
00077    virtual int setValue (OSUINT32 value);
00078 
00079    virtual ~ASN1CBitStrSizeHolder8() {}
00080 
00081  private:
00082    ASN1CBitStrSizeHolder8& operator= (const ASN1CBitStrSizeHolder8&) {
00083       return *this;
00084    }
00085 } ;
00086 
00087 class ASN1CBitStrSizeHolder16 : public ASN1CBitStrSizeHolder {
00088  protected:
00089    OSUINT16& mSize;
00090 
00091  public:
00092    ASN1CBitStrSizeHolder16 (OSUINT16& value) : mSize(value) {}
00093    virtual ASN1CBitStrSizeHolder* clone () {
00094       return new ASN1CBitStrSizeHolder16 (mSize);
00095    }
00096    virtual OSUINT32 getValue () const { return mSize; }
00097    virtual int setValue (OSUINT32 value);
00098 
00099    virtual ~ASN1CBitStrSizeHolder16() {}
00100 
00101  private:
00102    ASN1CBitStrSizeHolder16& operator= (const ASN1CBitStrSizeHolder16&) {
00103       return *this;
00104    }
00105 } ;
00106 
00107 class ASN1CBitStrSizeHolder32 : public ASN1CBitStrSizeHolder {
00108  protected:
00109    OSUINT32& mSize;
00110 
00111  public:
00112    ASN1CBitStrSizeHolder32 (OSUINT32& value) : mSize(value) {}
00113    virtual ASN1CBitStrSizeHolder* clone () {
00114       return new ASN1CBitStrSizeHolder32 (mSize);
00115    }
00116    virtual OSUINT32 getValue () const { return mSize; }
00117    virtual int setValue (OSUINT32 value);
00118 
00119    virtual ~ASN1CBitStrSizeHolder32() {}
00120 
00121  private:
00122    ASN1CBitStrSizeHolder32& operator= (const ASN1CBitStrSizeHolder32&) {
00123       return *this;
00124    }
00125 } ;
00126 
00127 class EXTRTCLASS ASN1CBitStr : public ASN1CType {
00128  private:
00129    OSUINT32    _numbits; // placeholder
00130    OSOCTET*    _units;   // placeholder
00131 
00132  protected:
00133    OSOCTET**   mpUnits;
00134    OSUINT32    mMaxNumBits;
00135    ASN1CBitStrSizeHolder* mpNumBits;
00136    OSUINT32    mUnitsUsed;
00137    OSUINT32    mUnitsAllocated;
00138    OSBOOL      mDynAlloc;
00139 
00140  private:
00141    OSOCTET* allocateMemory (OSUINT32 sz);
00142    OSOCTET* reallocateMemory
00143       (OSOCTET* old, OSUINT32 oldBufSz, OSUINT32 newBufSz);
00144    void freeMemory (OSOCTET* mem);
00145 
00146    /*
00147     * Set the field mUnitsUsed with the logical size in units of the bit
00148     * set.  WARNING:This function assumes that the number of units actually
00149     * in use is less than or equal to the current value of mUnitsUsed!
00150     */
00151    void recalculateUnitsUsed();
00152 
00153    /*
00154     * Ensures that the bit string can hold enough units.
00155     * param     unitsRequired the minimum acceptable number of units.
00156     */
00157    int checkCapacity (OSUINT32 unitsRequired);
00158 
00159    /*
00160     * Returns the unit of this bitset at index j as if this bit string had an
00161     * infinite amount of storage.
00162     */
00163    OSOCTET getBits (OSUINT32 j);
00164 
00165    void privateInit (OSUINT32 nbits);
00166    void privateInit (OSOCTET* bitStr, OSUINT32 maxNumbits_);
00167    void privateInit (ASN1TDynBitStr& bitStr);
00168 
00169  protected:
00170    /*
00171    * Creates an empty bit string. The string should be additionaly initialized
00172    * by call to 'init' method.
00173    */
00174    EXTRTMETHOD ASN1CBitStr (OSRTMessageBufferIF& msgBuf);
00175 
00176    /*
00177    * Default protected ctor. mpContext should be set and the string should be
00178    * additionaly initialized by call to 'init' method.
00179    */
00180    EXTRTMETHOD ASN1CBitStr();
00181 
00182    /*
00183     * This constructor creates an empty bit string.
00184     *
00185     * @param ctxt - Reference to reference-counted context object.
00186     */
00187    EXTRTMETHOD ASN1CBitStr (OSRTContext& ctxt);
00188 
00189    /*
00190     * This constructor initializes the internal bit string to the
00191     * given value.
00192     *
00193     * @param pBits - Pointer to binary bit string data.
00194     * @param numbits - Reference to counter to hold number of bits.
00195     * @param maxNumbits - Maximum size (in bits) of this bit string.
00196     */
00197    EXTRTMETHOD ASN1CBitStr
00198       (OSOCTET* pBits, OSUINT32& numbits, OSUINT32 maxNumbits);
00199 
00200    EXTRTMETHOD ASN1CBitStr
00201       (OSOCTET* pBits, OSUINT8& numbits, OSUINT32 maxNumbits);
00202 
00203    EXTRTMETHOD ASN1CBitStr
00204       (OSOCTET* pBits, OSUINT16& numbits, OSUINT32 maxNumbits);
00205 
00206    // Fixed-size bit string
00207    EXTRTMETHOD ASN1CBitStr (OSOCTET* pBits, OSUINT32 maxNumbits);
00208 
00209    /*
00210     * This constructor initializes the internal bit string to the
00211     * given value.
00212     *
00213     * @param bitstr - Reference to a bit string variable.
00214     */
00215    EXTRTMETHOD ASN1CBitStr (ASN1TDynBitStr& bitStr);
00216 
00217    void initBase (OSOCTET* pBits, OSUINT32 numbits, OSUINT32 maxNumbits);
00218 
00219    EXTRTMETHOD void init
00220       (OSOCTET* pBits, OSUINT32& numbits, OSUINT32 maxNumbits);
00221 
00222    EXTRTMETHOD void init
00223       (OSOCTET* pBits, OSUINT8& numbits, OSUINT32 maxNumbits);
00224 
00225    EXTRTMETHOD void init
00226       (OSOCTET* pBits, OSUINT16& numbits, OSUINT32 maxNumbits);
00227 
00228    EXTRTMETHOD void init (ASN1TDynBitStr& bitStr);
00229 
00230  public:
00240    EXTRTMETHOD ASN1CBitStr (OSRTMessageBufferIF& msgbuf, OSUINT32 nbits);
00241 
00253    EXTRTMETHOD ASN1CBitStr
00254       (OSRTMessageBufferIF& msgbuf, OSOCTET* bitStr,
00255        OSUINT32& numbits, OSUINT32 maxNumbits_);
00256 
00257    EXTRTMETHOD ASN1CBitStr
00258       (OSRTMessageBufferIF& msgbuf, OSOCTET* bitStr,
00259        OSUINT8& numbits, OSUINT32 maxNumbits_);
00260 
00261    EXTRTMETHOD ASN1CBitStr
00262       (OSRTMessageBufferIF& msgbuf, OSOCTET* bitStr,
00263        OSUINT16& numbits, OSUINT32 maxNumbits_);
00264 
00265    EXTRTMETHOD ASN1CBitStr
00266       (OSRTMessageBufferIF& msgbuf, OSOCTET* bitStr, OSUINT32 maxNumbits_);
00267 
00268    /*
00269     * Creates bits string from ASN1TDynBitStr. Ctor does not copy bytes,
00270     * just assign array (data member of ASN1TDynBitStr) to units.
00271     * This string will be extendable.
00272     */
00273    EXTRTMETHOD ASN1CBitStr
00274       (OSRTMessageBufferIF& msgBuf, ASN1TDynBitStr& bitStr);
00275 
00276    /*
00277     * Creates empty bit string. If nbits == 0 then bit string is dynamic;
00278     * else capacity will be fixed to nbits.
00279     */
00280    EXTRTMETHOD ASN1CBitStr (OSRTContext& ctxt, OSUINT32 nbits);
00281 
00282    /*
00283     * Creates bits string from array of bits. Ctor does not copy bytes,
00284     * just assign passed array to units.
00285     * Param bitStr - pointer to static byte array
00286     * Param numbits - reference to length of bit string (in bits);
00287     * Param maxNumbits_  - sets maximum length in bits
00288     */
00289    EXTRTMETHOD ASN1CBitStr
00290       (OSRTContext& ctxt, OSOCTET* bitStr,
00291        OSUINT32& octsNumbits, OSUINT32 maxNumbits_);
00292 
00293    EXTRTMETHOD ASN1CBitStr
00294       (OSRTContext& ctxt, OSOCTET* bitStr,
00295        OSUINT8& octsNumbits, OSUINT32 maxNumbits_);
00296 
00297    EXTRTMETHOD ASN1CBitStr
00298       (OSRTContext& ctxt, OSOCTET* bitStr,
00299        OSUINT16& octsNumbits, OSUINT32 maxNumbits_);
00300 
00301    EXTRTMETHOD ASN1CBitStr
00302       (OSRTContext& ctxt, OSOCTET* bitStr, OSUINT32 maxNumbits_);
00303 
00304    /*
00305    * Creates bits string from ASN1TDynBitStr. Ctor does not copy bytes,
00306    * just assign array (data member of ASN1TDynBitStr) to units.
00307    * This string will be extendable.
00308    */
00309    EXTRTMETHOD ASN1CBitStr (OSRTContext& ctxt, ASN1TDynBitStr& bitStr);
00310 
00311    /*
00312    * Copy constructor.
00313    */
00314    EXTRTMETHOD ASN1CBitStr (const ASN1CBitStr& bitStr);
00315 
00316    /*
00317    * Copy constructor, but allows to specify 'extendable' parameter
00318    */
00319    EXTRTMETHOD ASN1CBitStr (const ASN1CBitStr& bitStr, OSBOOL extendable);
00320 
00321 
00322    EXTRTMETHOD ~ASN1CBitStr();
00323 
00335    /*
00336    * Sets the bit at the specified index to 1.
00337    *
00338    * Returns: 0 - if succeed, or
00339    *          RTERR_OUTOFBND - if 'bitIndex' is out of bounds, or
00340    *          other error codes (see asn1type.h).
00341    */
00342    EXTRTMETHOD int set (OSUINT32 bitIndex);
00343 
00360    /*
00361    * Sets the bits from the specified fromIndex(inclusive) to the
00362    * specified toIndex(exclusive) to 1.
00363    *
00364    * Returns: 0 - if succeed, or
00365    *          RTERR_OUTOFBND - if one of indexes is out of bounds, or
00366    *          RTERR_RANGERR - if fromIndex > toIndex, or
00367    *          other error codes (see asn1type.h).
00368    */
00369    EXTRTMETHOD int set (OSUINT32 fromIndex, OSUINT32 toIndex);
00370 
00383    /*Returns (details): RTERR_OUTOFBND - if 'bitIndex' is out of bounds, or
00384    *          other error codes (see asn1type.h).
00385    */
00386    inline int change (OSUINT32 bitIndex, OSBOOL value) {
00387       return (value) ? set (bitIndex) : clear (bitIndex);
00388    }
00389 
00402    /*
00403    * Sets the bit specified by the index to 0.
00404    *
00405    * Returns: 0 - if succeed, or
00406    *          RTERR_OUTOFBND - if 'bitIndex' is out of bounds, or
00407    *          other error codes (see asn1type.h).
00408    */
00409    EXTRTMETHOD int clear (OSUINT32 bitIndex);
00410 
00427    /*
00428    * Sets the bits from the specified fromIndex(inclusive) to the
00429    * specified toIndex(exclusive) to 0.
00430    *
00431    * Returns: 0 - if succeed, or
00432    *          RTERR_OUTOFBND - if one of indexes is out of bounds, or
00433    *          RTERR_RANGERR - if fromIndex > toIndex, or
00434    *          other error codes (see asn1type.h).
00435    */
00436    EXTRTMETHOD int clear (OSUINT32 fromIndex, OSUINT32 toIndex);
00437 
00446    /*
00447    * Sets all of the bits in this bit string to 0.
00448    */
00449    EXTRTMETHOD void clear();
00450 
00466    /*
00467    * Sets the bit at the specified index to to the complement of its
00468    * current value.
00469    *
00470    * Returns: 0 - if succeed, or
00471    *          RTERR_OUTOFBND - if 'bitIndex' is out of bounds, or
00472    *          other error codes (see asn1type.h).
00473    */
00474    EXTRTMETHOD int invert (OSUINT32 bitIndex);
00475 
00495    /*
00496    * Sets each bit from the specified fromIndex(inclusive) to the
00497    * specified toIndex(exclusive) to the complement of its current
00498    * value.
00499    *
00500    * Returns: 0 - if succeed, or
00501    *          RTERR_OUTOFBND - if one of indexes is out of bounds, or
00502    *          RTERR_RANGERR - if fromIndex > toIndex, or
00503    *          other error codes (see asn1type.h).
00504    */
00505    EXTRTMETHOD int invert(OSUINT32 fromIndex, OSUINT32 toIndex);
00506 
00518    /*
00519    * Returns the value of the bit with the specified index.
00520    */
00521    EXTRTMETHOD OSBOOL get(OSUINT32 bitIndex);
00522 
00528    /*
00529    * Returns TRUE if the value of the bit with the specified index is set to 1.
00530    */
00531    inline OSBOOL isSet(OSUINT32 bitIndex) { return get(bitIndex); }
00532 
00541    /*
00542    * Returns true if this bit string contains no bits that are set
00543    * to 1.
00544    */
00545    inline OSBOOL isEmpty() { return (mUnitsUsed == 0); }
00546 
00555    /*
00556    * Returns the number of bytes of space actually in use by this
00557    * bit string to represent bit values.
00558    */
00559    EXTRTMETHOD OSUINT32 size() const;
00560 
00572    /*
00573    * Returns the "logical size" of this bit string: the index of
00574    * the highest set bit in the bit string plus one. Returns zero
00575    * if the bit string contains no set bits.
00576    */
00577    EXTRTMETHOD OSUINT32 length() const;
00578 
00588    /*
00589    * Returns the number of bits set to 1 in this
00590    * bit string.
00591    */
00592    EXTRTMETHOD OSUINT32 cardinality() const;
00593 
00607    /*
00608    * Copies bit string to buffer (pBuf).
00609    */
00610    EXTRTMETHOD int getBytes (OSOCTET* pBuf, OSUINT32 bufSz);
00611 
00637    EXTRTMETHOD int get
00638       (OSUINT32 fromIndex, OSUINT32 toIndex, OSOCTET* pBuf, OSUINT32 bufSz);
00639 
00657    EXTRTMETHOD int doAnd (const OSOCTET* pOctstr, OSUINT32 octsNumbits);
00658 
00670    inline int doAnd (const ASN1TDynBitStr& bitStr) {
00671       return doAnd(bitStr.data, bitStr.numbits);
00672    }
00673 
00684    inline int doAnd(const ASN1CBitStr& bitStr) {
00685       return doAnd(*bitStr.mpUnits, bitStr.length());
00686    }
00687 
00688 
00705    EXTRTMETHOD int doOr(const OSOCTET* pOctstr, OSUINT32 octsNumbits);
00706 
00718    inline int doOr(const ASN1TDynBitStr& bitStr) {
00719       return doOr(bitStr.data, bitStr.numbits);
00720    }
00721 
00732    inline int doOr(const ASN1CBitStr& bitStr) {
00733       return doOr(*bitStr.mpUnits, bitStr.length());
00734    }
00735 
00752    EXTRTMETHOD int doXor(const OSOCTET* pOctstr, OSUINT32 octsNumbits);
00753 
00765    inline int doXor(const ASN1TDynBitStr& bitStr) {
00766       return doXor(bitStr.data, bitStr.numbits);
00767    }
00768 
00779    inline int doXor(const ASN1CBitStr& bitStr) {
00780       return doXor(*bitStr.mpUnits, bitStr.length());
00781    }
00782 
00797    /*
00798    * Clears all of the bits in this bit string whose corresponding
00799    * bit is set in the specified bit string.
00800    *
00801    * Returns: 0 - if succeed, or
00802    *          ASN_E_INVLEN - if 'octsNumbits' is negative, or
00803    *          RTERR_INVPARAM - if pOctstr is null, or
00804    *          other error codes (see asn1type.h).
00805    */
00806    EXTRTMETHOD int doAndNot(const OSOCTET* pOctstr, OSUINT32 octsNumbits);
00807 
00822    inline int doAndNot(const ASN1TDynBitStr& bitStr) {
00823       return doAndNot(bitStr.data, bitStr.numbits);
00824    }
00825 
00839    inline int doAndNot(const ASN1CBitStr& bitStr) {
00840       return doAndNot(*bitStr.mpUnits, bitStr.length());
00841    }
00842 
00856    /*
00857    * Shifts all bits to the left by 'shift' bits.
00858    */
00859    EXTRTMETHOD int shiftLeft(OSUINT32 shift);
00860 
00874    /*
00875    * Shifts all bits to the right by 'shift' bits.
00876    */
00877    EXTRTMETHOD int shiftRight(OSUINT32 shift);
00878 
00885    /*
00886    * Returns number of unused bits in last unit.
00887    */
00888    EXTRTMETHOD OSUINT32 unusedBitsInLastUnit();
00889 
00900    /*
00901    * Returns filled ASN1TDynBitStr. Memory for data is not
00902    * reallocated, thus, this ASN1TDynBitStr will be eligible while
00903    * this ASN1CBitStr is in scope.
00904    */
00905    EXTRTMETHOD operator ASN1TDynBitStr();
00906 
00916    /*
00917    * Returns pointer to filled ASN1TDynBitStr. In this method,
00918    * memory is allocated, and bits are copied to it.
00919    */
00920    EXTRTMETHOD operator ASN1TDynBitStr*();
00921 } ;
00922 #else
00923 typedef class _ASN1CBitStr : public ASN1CType {
00924  public:
00925    _ASN1CBitStr (OSRTMessageBufferIF& msgBuf, OSUINT32 nbits) :
00926       ASN1CType (msgBuf) {}
00927 
00928    _ASN1CBitStr (OSRTMessageBufferIF& msgBuf, OSOCTET* bitStr,
00929       OSUINT32& octsNumbits, OSUINT32 maxNumbits_) :
00930       ASN1CType (msgBuf) {}
00931 
00932    _ASN1CBitStr (OSRTMessageBufferIF& msgBuf, ASN1TDynBitStr& bitStr) :
00933       ASN1CType (msgBuf) {}
00934 } ASN1CBitStr;
00935 #endif // _NO_UTILS_CLASSES
00936 #endif // _ASN1CBITSTR_H_
00937