ASN1CBitStr.h

Go to the documentation of this file.

/*
 * Copyright (c) 1997-2018 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.
//
// Author Artem Bolgar.
// version 1.52   21 Feb, 2003
//
#ifndef _NO_UTILS_CLASSES

class ASN1CBitStrSizeHolder {
 public:
   virtual ASN1CBitStrSizeHolder* clone () = 0;
   virtual OSUINT32 getValue () const = 0;
   virtual int setValue (OSUINT32 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 OSUINT32 getValue () const { return mSize; }
   virtual int setValue (OSUINT32 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 OSUINT32 getValue () const { return mSize; }
   virtual int setValue (OSUINT32 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 OSUINT32 getValue () const { return mSize; }
   virtual int setValue (OSUINT32 value);

   virtual ~ASN1CBitStrSizeHolder32() {}

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

class EXTRTCLASS ASN1CBitStr : public ASN1CType {
 private:
   OSUINT32    _numbits; // placeholder
   OSOCTET*    _units;   // placeholder

 protected:
   OSOCTET**   mpUnits;
   OSUINT32    mMaxNumBits;
   ASN1CBitStrSizeHolder* mpNumBits;
   OSUINT32    mUnitsUsed;
   OSUINT32    mUnitsAllocated;
   OSBOOL      mDynAlloc;

 private:
   OSOCTET* allocateMemory (OSUINT32 sz);
   OSOCTET* reallocateMemory
      (OSOCTET* old, OSUINT32 oldBufSz, OSUINT32 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 (OSUINT32 unitsRequired);

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

   void privateInit (OSUINT32 nbits);
   void privateInit (OSOCTET* bitStr, OSUINT32 maxNumbits_);
   void privateInit (ASN1TDynBitStr& 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);

   /*
    * 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, OSUINT32 maxNumbits);

   EXTRTMETHOD ASN1CBitStr
      (OSOCTET* pBits, OSUINT8& numbits, OSUINT32 maxNumbits);

   EXTRTMETHOD ASN1CBitStr
      (OSOCTET* pBits, OSUINT16& numbits, OSUINT32 maxNumbits);

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

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

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

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

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

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

   EXTRTMETHOD void init (ASN1TDynBitStr& bitStr);

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

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

   EXTRTMETHOD ASN1CBitStr
      (OSRTMessageBufferIF& msgbuf, OSOCTET* bitStr,
       OSUINT8& numbits, OSUINT32 maxNumbits_);

   EXTRTMETHOD ASN1CBitStr
      (OSRTMessageBufferIF& msgbuf, OSOCTET* bitStr,
       OSUINT16& numbits, OSUINT32 maxNumbits_);

   EXTRTMETHOD ASN1CBitStr
      (OSRTMessageBufferIF& msgbuf, OSOCTET* bitStr, OSUINT32 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 empty bit string. If nbits == 0 then bit string is dynamic;
    * else capacity will be fixed to nbits.
    */
   EXTRTMETHOD ASN1CBitStr (OSRTContext& ctxt, OSUINT32 nbits);

   /*
    * 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,
       OSUINT32& octsNumbits, OSUINT32 maxNumbits_);

   EXTRTMETHOD ASN1CBitStr
      (OSRTContext& ctxt, OSOCTET* bitStr,
       OSUINT8& octsNumbits, OSUINT32 maxNumbits_);

   EXTRTMETHOD ASN1CBitStr
      (OSRTContext& ctxt, OSOCTET* bitStr,
       OSUINT16& octsNumbits, OSUINT32 maxNumbits_);

   EXTRTMETHOD ASN1CBitStr
      (OSRTContext& ctxt, OSOCTET* bitStr, OSUINT32 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);

   /*
   * 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 (OSUINT32 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 (OSUINT32 fromIndex, OSUINT32 toIndex);

   /*Returns (details): RTERR_OUTOFBND - if 'bitIndex' is out of bounds, or
   *          other error codes (see asn1type.h).
   */
   inline int change (OSUINT32 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 (OSUINT32 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 (OSUINT32 fromIndex, OSUINT32 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 (OSUINT32 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(OSUINT32 fromIndex, OSUINT32 toIndex);

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

   /*
   * Returns TRUE if the value of the bit with the specified index is set to 1.
   */
   inline OSBOOL isSet(OSUINT32 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 OSUINT32 size() const;

   /*
   * Returns the "logical size" of this bit string: the index of
   * the highest set bit in the bit string plus one. Returns zero
   * if the bit string contains no set bits.
   */
   EXTRTMETHOD OSUINT32 length() const;

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

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

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

   EXTRTMETHOD int doAnd (const OSOCTET* pOctstr, OSUINT32 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, OSUINT32 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, OSUINT32 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, OSUINT32 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(OSUINT32 shift);

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

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

   /*
   * Returns filled ASN1TDynBitStr. Memory for data is not
   * reallocated, thus, this ASN1TDynBitStr will be eligible while
   * this ASN1CBitStr is in scope.
   */
   EXTRTMETHOD operator ASN1TDynBitStr();

   /*
   * Returns pointer to filled ASN1TDynBitStr. In this method,
   * memory is allocated, and bits are copied to it.
   */
   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_