BitMask.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------+
|
|   Supplied under applicable software license agreement.
|
|   Copyright (c) 2018 Bentley Systems, Incorporated. All rights reserved.
|
+---------------------------------------------------------------------------------------*/
#pragma once

#include <DgnPlatform/DgnPlatform.h>

#include <stdio.h>

BEGIN_BENTLEY_NAMESPACE

enum class BitMaskOperation
    {
    Or          = 1,
    And         = 2,
    Xor         = 3,
    OrNot       = 4,
    AndNot      = 5,
    };

/*=================================================================================**/
typedef BitMaskP* BitMaskH;

/*=================================================================================**/
struct      BitMask : NonCopyableClass
{
private:
    virtual void MakeClassAbstract() = 0;
public:
public:

DGNPLATFORM_EXPORT static BitMaskP     Create (bool defaultBitValue);

DGNPLATFORM_EXPORT static BitMaskP     Clone (BitMaskCR source);

DGNPLATFORM_EXPORT static void         FreeAndClear (BitMaskH bitMask);

DGNPLATFORM_EXPORT void                Free ();

DGNPLATFORM_EXPORT UInt32              GetCapacity () const;

DGNPLATFORM_EXPORT StatusInt           EnsureCapacity (UInt32 numBits);

DGNPLATFORM_EXPORT StatusInt           SetCapacity (UInt32 numBits);

DGNPLATFORM_EXPORT bool                GetDefaultBitValue () const;

DGNPLATFORM_EXPORT void                SetDefaultBitValue (bool value);

DGNPLATFORM_EXPORT bool                Test (UInt32 bitIndex) const;

DGNPLATFORM_EXPORT bool                Test (BitMaskCR testMask) const;


DGNPLATFORM_EXPORT StatusInt            SetBit (UInt32 bitIndex, bool value);

DGNPLATFORM_EXPORT StatusInt           Set (UInt32 bitIndex);

DGNPLATFORM_EXPORT void                SetAll ();

DGNPLATFORM_EXPORT StatusInt           Clear (UInt32 bitIndex);

DGNPLATFORM_EXPORT void                ClearAll ();

DGNPLATFORM_EXPORT StatusInt           Invert (UInt32 bitIndex);

DGNPLATFORM_EXPORT void                InvertAll ();

DGNPLATFORM_EXPORT void                Or (BitMaskCR rhs);

DGNPLATFORM_EXPORT void                And (BitMaskCR rhs);

DGNPLATFORM_EXPORT void                XOr (BitMaskCR rhs);

DGNPLATFORM_EXPORT void                AndNot (BitMaskCR rhs);

DGNPLATFORM_EXPORT void                OrNot (BitMaskCR rhs);

DGNPLATFORM_EXPORT StatusInt           SetBits (UInt32 arraySize, const UInt32 *bitIndexArray, bool value);

DGNPLATFORM_EXPORT StatusInt           SetFromBitMask (BitMaskCR source);

DGNPLATFORM_EXPORT StatusInt           SetFromBitArray (UInt32 numValidBits, const UInt16* bitArray);

DGNPLATFORM_EXPORT void                SetFromString (WStringCR sourceString, UInt32 indexOrigin, UInt32 maxIndex);

DGNPLATFORM_EXPORT UInt32              GetNumBitsSet () const;

DGNPLATFORM_EXPORT bool                IsEqual (BitMaskCP other) const;

DGNPLATFORM_EXPORT bool                AnyBitSet () const;

DGNPLATFORM_EXPORT void                LogicalOperation (BitMaskCR rhs, BitMaskOperation operation);

DGNPLATFORM_EXPORT void                Dump (FILE *file, bool asString, UInt32 indexOrigin) const;


DGNPLATFORM_EXPORT void                ToString (WStringR outString, UInt32 indexOrigin) const;
};

/*=================================================================================**/
struct BitMaskHolder 
{
private:
    BitMaskP    m_mask;

public:
explicit BitMaskHolder (bool defaultBitValue=false) {m_mask = BitMask::Create (defaultBitValue);}

~BitMaskHolder() {m_mask->Free();}

BitMaskHolder (BitMaskHolder const& source) {m_mask = BitMask::Clone(*source.m_mask);}

explicit BitMaskHolder (BitMask const& source) {m_mask = BitMask::Clone(source);}

BitMaskHolder& operator=(BitMaskHolder const& source) {if (this == &source) return *this; m_mask->Free(); m_mask = BitMask::Clone(*source.m_mask); return *this;}

BitMaskHolder& operator=(BitMaskCR source) {m_mask->Free(); m_mask = BitMask::Clone(source); return *this;}

void SetBitMask (BitMaskP source) 
    {
    if (source == m_mask)
       return;

    if (NULL != m_mask) 
        m_mask->Free(); 

    m_mask = source; 
    }

BitMaskP  operator->() {return m_mask;}

//  Access the BitMask's methods
BitMaskCP operator->() const {return m_mask;}

BitMaskR  operator*() {return *m_mask;}

BitMaskP *operator& () { return &m_mask; }

operator BitMaskP () { return m_mask; }

//   Access the BitMask's methods
BitMaskCR  operator*() const {return *m_mask;}

BitMaskCP get() const {return m_mask;}
};

//=======================================================================================
// @bsiclass                                                     Bentley Systems
//=======================================================================================
template <bool defaultVal> struct BitMaskRef
{
private:
    BitMaskP    m_mask;

public:
    void Clear() {if (m_mask) m_mask->Free(); m_mask=NULL;}
    explicit BitMaskRef () {m_mask = NULL;}
    ~BitMaskRef () {Clear();}

    BitMaskP GetBitMask() {if (NULL == m_mask) {m_mask=BitMask::Create(defaultVal);} return m_mask;}
    bool IsValid() const {return NULL != m_mask;}
};

END_BENTLEY_NAMESPACE