XnBitSet.h

Go to the documentation of this file.

/****************************************************************************
*                                                                           *
*  OpenNI 1.x Alpha                                                         *
*  Copyright (C) 2011 PrimeSense Ltd.                                       *
*                                                                           *
*  This file is part of OpenNI.                                             *
*                                                                           *
*  OpenNI is free software: you can redistribute it and/or modify           *
*  it under the terms of the GNU Lesser General Public License as published *
*  by the Free Software Foundation, either version 3 of the License, or     *
*  (at your option) any later version.                                      *
*                                                                           *
*  OpenNI is distributed in the hope that it will be useful,                *
*  but WITHOUT ANY WARRANTY; without even the implied warranty of           *
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the             *
*  GNU Lesser General Public License for more details.                      *
*                                                                           *
*  You should have received a copy of the GNU Lesser General Public License *
*  along with OpenNI. If not, see <http://www.gnu.org/licenses/>.           *
*                                                                           *
****************************************************************************/
#ifndef __XNBITSET_H__
#define __XNBITSET_H__

#include <XnArray.h>

class XnBitSet
{
public:
    XnBitSet() : m_nSize(0) {}

    XnStatus Reserve(XnUInt32 nBits)
    {
        return m_array.Reserve((nBits >> 5) + 1);
    }

    XnStatus SetSize(XnUInt32 nBits)
    {
        return m_array.SetSize((nBits >> 5) + 1, 0);
    }

    XnStatus Set(XnUInt32 nIndex, XnBool bValue)
    {
        XnUInt32 nArrayIndex = (nIndex >> 5);
        XnUInt32 nMask = (1 << ((~nIndex) & 0x1F));
        XnUInt32 nOldVal = nArrayIndex < m_array.GetSize() ? m_array[nArrayIndex] : 0;
        XnUInt32 nNewVal = bValue ? (nOldVal | nMask) : (nOldVal & (~nMask));
        XnStatus nRetVal = m_array.Set(nArrayIndex, nNewVal, 0);
        XN_IS_STATUS_OK(nRetVal);
        m_nSize = XN_MAX(m_nSize, nIndex + 1);
        return XN_STATUS_OK;
    }
    
    XnBool IsSet(XnUInt32 nIndex) const
    {
        XnUInt32 nArrayIndex = (nIndex >> 5);
        if (nArrayIndex >= m_array.GetSize())
        {
            return FALSE;
        }
        return (m_array[nArrayIndex] & (1 << ((~nIndex) & 0x1F))) ? TRUE : FALSE;
    }

    XnStatus SetData(const XnUInt32* pData, XnUInt32 nSizeInDwords)
    {
        XnStatus nRetVal = m_array.SetData(pData, nSizeInDwords);
        XN_IS_STATUS_OK(nRetVal);
        m_nSize = (nSizeInDwords << 5);
        return XN_STATUS_OK;
    }

    XnStatus SetDataBytes(const XnUInt8* pData, XnUInt32 nSizeInBytes)
    {
        //XnStatus nRetVal = m_array.SetData(reinterpret_cast<const XnUInt32*>(pData), XN_MAX(1, nSizeInBytes >> 2));
        XnUInt32 nSizeInDwords = XN_MAX(1, nSizeInBytes >> 2);
        XnStatus nRetVal = m_array.SetSize(nSizeInDwords);
        XN_IS_STATUS_OK(nRetVal);
        for (XnUInt32 nDwordIdx = 0, nByteIdx = 0; nDwordIdx < nSizeInDwords; nDwordIdx++, nByteIdx += 4)
        {
            m_array[nDwordIdx] = ((pData[nByteIdx] << 24) | (pData[nByteIdx + 1] << 16) | (pData[nByteIdx + 2] << 8) | pData[nByteIdx + 3] );
        }
        m_nSize = (nSizeInBytes << 3);
        return XN_STATUS_OK;
    }

    const XnUInt32* GetData() const
    {
        return m_array.GetData();
    }

    XnUInt32* GetData()
    {
        return m_array.GetData();
    }

    XnUInt32 GetDataSize() const
    {
        return m_array.GetSize();
    }

    XnUInt32 GetSize() const
    {
        return m_nSize;
    }

    void Clear()
    {
        m_array.Clear();
        m_nSize = 0;
    }

    XnBool IsEmpty() const
    {
        return m_array.IsEmpty();
    }
    
private:
    XnArray<XnUInt32> m_array;
    XnUInt32 m_nSize;
};

#endif // __XNBITSET_H__