ASN1CBitStr.h

Go to the documentation of this file.

/*
 * Copyright (c) 1997-2023 Objective Systems, Inc.
 *
 * This software is furnished under a license and may be used and copied
 * only in accordance with the terms of such license and with the
 * inclusion of the above copyright notice. This software or any other
 * copies thereof may not be provided or otherwise made available to any
 * other person. No title to and ownership of the software is hereby
 * transferred.
 *
 * The information in this software is subject to change without notice
 * and should not be construed as a commitment by Objective Systems, Inc.
 *
 * PROPRIETARY NOTICE
 *
 * This software is an unpublished work subject to a confidentiality agreement
 * and is protected by copyright and trade secret law.  Unauthorized copying,
 * redistribution or other use of this work is prohibited.
 *
 * The above notice of copyright on this source code product does not indicate
 * any actual or intended publication of such source code.
 *
 *****************************************************************************/

#ifndef _ASN1CBITSTR_H_
#define _ASN1CBITSTR_H_

#include "rtsrc/asn1CppTypes.h"
//
// ASN1CBitStr
//
// Bit string implementation. This class provides all functionalty
// necessary for bit strings.
//
#ifndef _NO_UTILS_CLASSES

class ASN1CBitStrSizeHolder {
 public:
   virtual ASN1CBitStrSizeHolder* clone () = 0;
   virtual OSSIZE getValue () const = 0;

   virtual int setValue (OSSIZE value) = 0;

   virtual ~ASN1CBitStrSizeHolder() {}
} ;

class ASN1CBitStrSizeHolder8 : public ASN1CBitStrSizeHolder {
 protected:
   OSUINT8& mSize;

 public:
   ASN1CBitStrSizeHolder8 (OSUINT8& value) : mSize(value) {}
   virtual ASN1CBitStrSizeHolder* clone () {
      return new ASN1CBitStrSizeHolder8 (mSize);
   }
   virtual OSSIZE getValue () const { return mSize; }
   virtual int setValue (OSSIZE value);

   virtual ~ASN1CBitStrSizeHolder8() {}

 private:
   ASN1CBitStrSizeHolder8& operator= (const ASN1CBitStrSizeHolder8&) {
      return *this;
   }
} ;

class ASN1CBitStrSizeHolder16 : public ASN1CBitStrSizeHolder {
 protected:
   OSUINT16& mSize;

 public:
   ASN1CBitStrSizeHolder16 (OSUINT16& value) : mSize(value) {}
   virtual ASN1CBitStrSizeHolder* clone () {
      return new ASN1CBitStrSizeHolder16 (mSize);
   }
   virtual OSSIZE getValue () const { return mSize; }
   virtual int setValue (OSSIZE value);

   virtual ~ASN1CBitStrSizeHolder16() {}

 private:
   ASN1CBitStrSizeHolder16& operator= (const ASN1CBitStrSizeHolder16&) {
      return *this;
   }
} ;

class ASN1CBitStrSizeHolder32 : public ASN1CBitStrSizeHolder {
 protected:
   OSUINT32& mSize;

 public:
   ASN1CBitStrSizeHolder32 (OSUINT32& value) : mSize(value) {}
   virtual ASN1CBitStrSizeHolder* clone () {
      return new ASN1CBitStrSizeHolder32 (mSize);
   }
   virtual OSSIZE getValue () const { return mSize; }
   virtual int setValue (OSSIZE value);

   virtual ~ASN1CBitStrSizeHolder32() {}

 private:
   ASN1CBitStrSizeHolder32& operator= (const ASN1CBitStrSizeHolder32&) {
      return *this;
   }
} ;

class ASN1CBitStrSizeHolder64 : public ASN1CBitStrSizeHolder {
 protected:
   OSSIZE& mSize;

 public:
   ASN1CBitStrSizeHolder64 (OSSIZE& value) : mSize(value) {}
   virtual ASN1CBitStrSizeHolder* clone () {
      return new ASN1CBitStrSizeHolder64 (mSize);
   }
   virtual OSSIZE getValue () const { return mSize; }
   virtual int setValue (OSSIZE value);

   virtual ~ASN1CBitStrSizeHolder64() {}

 private:
   ASN1CBitStrSizeHolder64& operator= (const ASN1CBitStrSizeHolder64&) {
      return *this;
   }
} ;


class EXTRTCLASS ASN1CBitStr : public ASN1CType {
 private:
   OSSIZE      _numbits; /* used when constructor does not provide
                            a value by reference to give us something to
                            refer to */
   OSOCTET*    _units;   // placeholder

 protected:
   OSOCTET**   mpUnits;                /* pointer to pointer to data*/
   OSOCTET**   mppExtData;             // extended bit string data
   OSSIZE      mMaxNumBits;
   ASN1CBitStrSizeHolder* mpNumBits;
   OSSIZE      mUnitsUsed;             /* number of bytes used in *mpUnits */
   OSSIZE      mUnitsAllocated;
   OSBOOL      mDynAlloc;              /* true if *mpUnits is owned by me */

 private:
   OSOCTET* allocateMemory (OSSIZE sz);
   OSOCTET* reallocateMemory
      (OSOCTET* old, OSSIZE oldBufSz, OSSIZE newBufSz);
   void freeMemory (OSOCTET* mem);

   /*
    * Set the field mUnitsUsed with the logical size in units of the bit
    * set.  WARNING:This function assumes that the number of units actually
    * in use is less than or equal to the current value of mUnitsUsed!
    */
   void recalculateUnitsUsed();

   /*
    * Ensures that the bit string can hold enough units.
    * param     unitsRequired the minimum acceptable number of units.
    */
   int checkCapacity (OSSIZE unitsRequired);

   /*
    * Returns the unit of this bitset at index j as if this bit string had an
    * infinite amount of storage.
    */
   OSOCTET getBits (OSSIZE j);

   void privateInit (OSSIZE nbits);
   void privateInit (OSOCTET* bitStr, OSSIZE maxNumbits_, OSOCTET** ppExtData);
   void privateInit (ASN1TDynBitStr& bitStr);
   void privateInit (ASN1TDynBitStr64& bitStr);

 protected:
   /*
   * Creates an empty bit string. The string should be additionaly initialized
   * by call to 'init' method.
   */
   EXTRTMETHOD ASN1CBitStr (OSRTMessageBufferIF& msgBuf);

   /*
   * Default protected ctor. mpContext should be set and the string should be
   * additionaly initialized by call to 'init' method.
   */
   EXTRTMETHOD ASN1CBitStr();

   /*
    * This constructor creates an empty bit string.
    *
    * @param ctxt - Reference to reference-counted context object.
    */
   EXTRTMETHOD ASN1CBitStr (OSRTContext& ctxt);

#if SIZE_MAX > OSUINT32_MAX        //if size_t > 32 bits
   /*
    * This constructor initializes the internal bit string to the
    * given value.
    *
    * @param pBits - Pointer to binary bit string data.
    * @param numbits - Reference to counter to hold number of bits.
    * @param maxNumbits - Maximum size (in bits) of this bit string.
    */
   EXTRTMETHOD ASN1CBitStr
      (OSOCTET* pBits, OSSIZE& numbits, OSSIZE maxNumbits,
       OSOCTET** ppExtData = 0);
#endif

   /*
    * This constructor initializes the internal bit string to the
    * given value.
    *
    * @param pBits - Pointer to binary bit string data.
    * @param numbits - Reference to counter to hold number of bits.
    * @param maxNumbits - Maximum size (in bits) of this bit string.
    */
   EXTRTMETHOD ASN1CBitStr
      (OSOCTET* pBits, OSUINT32& numbits, OSSIZE maxNumbits,
       OSOCTET** ppExtData = 0);

   EXTRTMETHOD ASN1CBitStr
      (OSOCTET* pBits, OSUINT8& numbits, OSSIZE maxNumbits,
       OSOCTET** ppExtData = 0);

   EXTRTMETHOD ASN1CBitStr
      (OSOCTET* pBits, OSUINT16& numbits, OSSIZE maxNumbits,
       OSOCTET** ppExtData = 0);

   // Fixed-size bit string
   EXTRTMETHOD ASN1CBitStr (OSOCTET* pBits, OSSIZE maxNumbits);

   /*
    * This constructor initializes the internal bit string to the
    * given value.
    *
    * @param bitstr - Reference to a bit string variable.
    */
   EXTRTMETHOD ASN1CBitStr (ASN1TDynBitStr& bitStr);

   /*
    * Creates bits string from ASN1TDynBitStr64. Ctor does not copy bytes,
    * just assign array (data member of ASN1TDynBitStr64) to units.
    * This string will be extendable.
    */
   EXTRTMETHOD ASN1CBitStr (ASN1TDynBitStr64& bitStr);

   void initBase (OSOCTET* pBits, OSSIZE numbits, OSSIZE maxNumbits);

   EXTRTMETHOD void init
      (OSOCTET* pBits, OSUINT32& numbits, OSSIZE maxNumbits);

   EXTRTMETHOD void init
      (OSOCTET* pBits, OSUINT8& numbits, OSSIZE maxNumbits);

   EXTRTMETHOD void init
      (OSOCTET* pBits, OSUINT16& numbits, OSSIZE maxNumbits);

   EXTRTMETHOD void init (ASN1TDynBitStr& bitStr);

 public:
   EXTRTMETHOD ASN1CBitStr (OSRTMessageBufferIF& msgbuf, OSSIZE nbits);

#if SIZE_MAX > OSUINT32_MAX        //if size_t > 32 bits

   EXTRTMETHOD ASN1CBitStr
      (OSRTMessageBufferIF& msgbuf, OSOCTET* bitStr,
       OSSIZE& numbits, OSSIZE maxNumbits_, OSOCTET** ppExtData = 0);
#endif

   EXTRTMETHOD ASN1CBitStr
      (OSRTMessageBufferIF& msgbuf, OSOCTET* bitStr,
       OSUINT32& numbits, OSSIZE maxNumbits_, OSOCTET** ppExtData = 0);

   EXTRTMETHOD ASN1CBitStr
      (OSRTMessageBufferIF& msgbuf, OSOCTET* bitStr,
       OSUINT8& numbits, OSSIZE maxNumbits_, OSOCTET** ppExtData = 0);

   EXTRTMETHOD ASN1CBitStr
      (OSRTMessageBufferIF& msgbuf, OSOCTET* bitStr,
       OSUINT16& numbits, OSSIZE maxNumbits_, OSOCTET** ppExtData = 0);

   EXTRTMETHOD ASN1CBitStr
      (OSRTMessageBufferIF& msgbuf, OSOCTET* bitStr, OSSIZE maxNumbits_);

   /*
    * Creates bits string from ASN1TDynBitStr. Ctor does not copy bytes,
    * just assign array (data member of ASN1TDynBitStr) to units.
    * This string will be extendable.
    */
   EXTRTMETHOD ASN1CBitStr
      (OSRTMessageBufferIF& msgBuf, ASN1TDynBitStr& bitStr);

   /*
    * Creates bits string from ASN1TDynBitStr64. Ctor does not copy bytes,
    * just assign array (data member of ASN1TDynBitStr64) to units.
    * This string will be extendable.
    */
   EXTRTMETHOD ASN1CBitStr
      (OSRTMessageBufferIF& msgBuf, ASN1TDynBitStr64& bitStr);

   /*
    * Creates empty bit string. If nbits == 0 then bit string is dynamic;
    * else capacity will be fixed to nbits.
    */
   EXTRTMETHOD ASN1CBitStr (OSRTContext& ctxt, OSSIZE nbits);

#if SIZE_MAX > OSUINT32_MAX        //if size_t > 32 bits
   /*
    * Creates bits string from array of bits. Ctor does not copy bytes,
    * just assign passed array to units.
    * Param bitStr - pointer to static byte array
    * Param numbits - reference to length of bit string (in bits);
    * Param maxNumbits_  - sets maximum length in bits
    */
   EXTRTMETHOD ASN1CBitStr
   (OSRTContext& ctxt, OSOCTET* bitStr,
      OSSIZE& octsNumbits, OSSIZE maxNumbits_, OSOCTET** ppExtData = 0);
#endif

   EXTRTMETHOD ASN1CBitStr
      (OSRTContext& ctxt, OSOCTET* bitStr,
       OSUINT32& octsNumbits, OSSIZE maxNumbits_, OSOCTET** ppExtData = 0);

   EXTRTMETHOD ASN1CBitStr
      (OSRTContext& ctxt, OSOCTET* bitStr,
       OSUINT8& octsNumbits, OSSIZE maxNumbits_, OSOCTET** ppExtData = 0);

   EXTRTMETHOD ASN1CBitStr
      (OSRTContext& ctxt, OSOCTET* bitStr,
       OSUINT16& octsNumbits, OSSIZE maxNumbits_, OSOCTET** ppExtData = 0);

   EXTRTMETHOD ASN1CBitStr
      (OSRTContext& ctxt, OSOCTET* bitStr, OSSIZE maxNumbits_);

   /*
   * Creates bits string from ASN1TDynBitStr. Ctor does not copy bytes,
   * just assign array (data member of ASN1TDynBitStr) to units.
   * This string will be extendable.
   */
   EXTRTMETHOD ASN1CBitStr (OSRTContext& ctxt, ASN1TDynBitStr& bitStr);

   /*
   * Creates bits string from ASN1TDynBitStr64. Ctor does not copy bytes,
   * just assign array (data member of ASN1TDynBitStr64) to units.
   * This string will be extendable.
   */
   EXTRTMETHOD ASN1CBitStr(OSRTContext& ctxt, ASN1TDynBitStr64& bitStr);

   /*
   * Copy constructor.
   */
   EXTRTMETHOD ASN1CBitStr (const ASN1CBitStr& bitStr);

   /*
   * Copy constructor, but allows to specify 'extendable' parameter
   */
   EXTRTMETHOD ASN1CBitStr (const ASN1CBitStr& bitStr, OSBOOL extendable);


   EXTRTMETHOD ~ASN1CBitStr();

   /*
   * Sets the bit at the specified index to 1.
   *
   * Returns: 0 - if succeed, or
   *          RTERR_OUTOFBND - if 'bitIndex' is out of bounds, or
   *          other error codes (see asn1type.h).
   */
   EXTRTMETHOD int set (OSSIZE bitIndex);

   /*
   * Sets the bits from the specified fromIndex(inclusive) to the
   * specified toIndex(exclusive) to 1.
   *
   * Returns: 0 - if succeed, or
   *          RTERR_OUTOFBND - if one of indexes is out of bounds, or
   *          RTERR_RANGERR - if fromIndex > toIndex, or
   *          other error codes (see asn1type.h).
   */
   EXTRTMETHOD int set (OSSIZE fromIndex, OSSIZE toIndex);

   /*Returns (details): RTERR_OUTOFBND - if 'bitIndex' is out of bounds, or
   *          other error codes (see asn1type.h).
   */
   inline int change (OSSIZE bitIndex, OSBOOL value) {
      return (value) ? set (bitIndex) : clear (bitIndex);
   }

   /*
   * Sets the bit specified by the index to 0.
   *
   * Returns: 0 - if succeed, or
   *          RTERR_OUTOFBND - if 'bitIndex' is out of bounds, or
   *          other error codes (see asn1type.h).
   */
   EXTRTMETHOD int clear (OSSIZE bitIndex);

   /*
   * Sets the bits from the specified fromIndex(inclusive) to the
   * specified toIndex(exclusive) to 0.
   *
   * Returns: 0 - if succeed, or
   *          RTERR_OUTOFBND - if one of indexes is out of bounds, or
   *          RTERR_RANGERR - if fromIndex > toIndex, or
   *          other error codes (see asn1type.h).
   */
   EXTRTMETHOD int clear (OSSIZE fromIndex, OSSIZE toIndex);

   /*
   * Sets all of the bits in this bit string to 0.
   */
   EXTRTMETHOD void clear();

   /*
   * Sets the bit at the specified index to to the complement of its
   * current value.
   *
   * Returns: 0 - if succeed, or
   *          RTERR_OUTOFBND - if 'bitIndex' is out of bounds, or
   *          other error codes (see asn1type.h).
   */
   EXTRTMETHOD int invert (OSSIZE bitIndex);

   /*
   * Sets each bit from the specified fromIndex(inclusive) to the
   * specified toIndex(exclusive) to the complement of its current
   * value.
   *
   * Returns: 0 - if succeed, or
   *          RTERR_OUTOFBND - if one of indexes is out of bounds, or
   *          RTERR_RANGERR - if fromIndex > toIndex, or
   *          other error codes (see asn1type.h).
   */
   EXTRTMETHOD int invert(OSSIZE fromIndex, OSSIZE toIndex);

   /*
   * Returns the value of the bit with the specified index.
   */
   EXTRTMETHOD OSBOOL get(OSSIZE bitIndex);

   /*
   * Returns TRUE if the value of the bit with the specified index is set to 1.
   */
   inline OSBOOL isSet(OSSIZE bitIndex) { return get(bitIndex); }

   /*
   * Returns true if this bit string contains no bits that are set
   * to 1.
   */
   inline OSBOOL isEmpty() { return (mUnitsUsed == 0); }

   /*
   * Returns the number of bytes of space actually in use by this
   * bit string to represent bit values.
   */
   EXTRTMETHOD OSSIZE size() const;

   EXTRTMETHOD OSSIZE length() const;

   /*
   * Returns the number of bits set to 1 in this
   * bit string.
   */
   EXTRTMETHOD OSSIZE cardinality() const;

   /*
   * Copies bit string to buffer (pBuf).
   */
   EXTRTMETHOD int getBytes (OSOCTET* pBuf, OSSIZE bufSz);

   EXTRTMETHOD int get
      (OSSIZE fromIndex, OSSIZE toIndex, OSOCTET* pBuf, OSSIZE bufSz);

   EXTRTMETHOD int doAnd (const OSOCTET* pOctstr, OSSIZE octsNumbits);

   inline int doAnd (const ASN1TDynBitStr& bitStr) {
      return doAnd(bitStr.data, bitStr.numbits);
   }

   inline int doAnd(const ASN1CBitStr& bitStr) {
      return doAnd(*bitStr.mpUnits, bitStr.length());
   }


   EXTRTMETHOD int doOr(const OSOCTET* pOctstr, OSSIZE octsNumbits);

   inline int doOr(const ASN1TDynBitStr& bitStr) {
      return doOr(bitStr.data, bitStr.numbits);
   }

   inline int doOr(const ASN1CBitStr& bitStr) {
      return doOr(*bitStr.mpUnits, bitStr.length());
   }

   EXTRTMETHOD int doXor(const OSOCTET* pOctstr, OSSIZE octsNumbits);

   inline int doXor(const ASN1TDynBitStr& bitStr) {
      return doXor(bitStr.data, bitStr.numbits);
   }

   inline int doXor(const ASN1CBitStr& bitStr) {
      return doXor(*bitStr.mpUnits, bitStr.length());
   }

   /*
   * Clears all of the bits in this bit string whose corresponding
   * bit is set in the specified bit string.
   *
   * Returns: 0 - if succeed, or
   *          ASN_E_INVLEN - if 'octsNumbits' is negative, or
   *          RTERR_INVPARAM - if pOctstr is null, or
   *          other error codes (see asn1type.h).
   */
   EXTRTMETHOD int doAndNot(const OSOCTET* pOctstr, OSSIZE octsNumbits);

   inline int doAndNot(const ASN1TDynBitStr& bitStr) {
      return doAndNot(bitStr.data, bitStr.numbits);
   }

   inline int doAndNot(const ASN1CBitStr& bitStr) {
      return doAndNot(*bitStr.mpUnits, bitStr.length());
   }

   /*
   * Shifts all bits to the left by 'shift' bits.
   */
   EXTRTMETHOD int shiftLeft(OSSIZE shift);

   /*
   * Shifts all bits to the right by 'shift' bits.
   */
   EXTRTMETHOD int shiftRight(OSSIZE shift);

   /*
   * Returns number of unused bits in last unit.
   */
   EXTRTMETHOD OSUINT32 unusedBitsInLastUnit();

   EXTRTMETHOD operator ASN1TDynBitStr();

   EXTRTMETHOD operator ASN1TDynBitStr*();
} ;
#else
typedef class _ASN1CBitStr : public ASN1CType {
 public:
   _ASN1CBitStr (OSRTMessageBufferIF& msgBuf, OSUINT32 nbits) :
      ASN1CType (msgBuf) {}

   _ASN1CBitStr (OSRTMessageBufferIF& msgBuf, OSOCTET* bitStr,
      OSUINT32& octsNumbits, OSUINT32 maxNumbits_) :
      ASN1CType (msgBuf) {}

   _ASN1CBitStr (OSRTMessageBufferIF& msgBuf, ASN1TDynBitStr& bitStr) :
      ASN1CType (msgBuf) {}
} ASN1CBitStr;
#endif // _NO_UTILS_CLASSES
#endif // _ASN1CBITSTR_H_