bitarray.h

 
#ifndef _BitArray_h_
#define _BitArray_h_
 
#include "system/collections/icollection.h"
#include "system/collections/ienumerable.h"
#include "system/array.h"
 
#include <memory>
#include <vector>
 
 
#ifdef ASPOSECPPLIB_BEING_BUILT
#include <boost/dynamic_bitset.hpp>
#endif
 
 
namespace boost {
    template <class, class> class dynamic_bitset;
}
 
 
namespace System {
namespace Collections {
 
namespace Detail{
    typedef boost::dynamic_bitset<uint32_t, std::allocator<uint32_t>> BitsetType;
 
    struct BitsetSizeEquivalent 
    { 
        std::vector<uint32_t> m_data; 
        std::size_t m_size; 
    };
    struct BitsetReferenceSizeEquivalent 
    { 
        uint32_t &m_ref; 
        uint32_t m_mask;
        BitsetReferenceSizeEquivalent() = delete;
    };
 
    ASPOSECPP_3RD_PARTY_TYPE_HOLDER(BitsetType, dynamic_bitset, sizeof(BitsetSizeEquivalent), std::uint32_t*, BitsetHolder);
    ASPOSECPP_3RD_PARTY_TYPE_HOLDER_HIDDEN_TYPE(BitsetType::reference, reference, sizeof(BitsetReferenceSizeEquivalent), BitsetReferenceSizeEquivalent, BitsetReferenceHolder);
}
 
class ASPOSECPP_SHARED_CLASS BitArrayPtr;
 
class ASPOSECPP_SHARED_CLASS BitArray
    : virtual public Object
    , public Generic::ICollection<bool>
{
    RTTI_INFO(BitArray, ::System::BaseTypesInfo<System::Object>);
 
public:
    typedef Detail::BitsetType bitset;
 
    class Enumerator : virtual public Object, public Generic::IEnumerator<bool>
    {
        RTTI_INFO(BitArray::Enumerator, ::System::BaseTypesInfo<System::Object>);
 
        bitset& m_data;
        int m_current;
 
    public:
        ASPOSECPP_SHARED_API Enumerator(const SharedPtr<BitArray>& parent);
        ASPOSECPP_SHARED_API bool get_Current() const override;
        ASPOSECPP_SHARED_API bool MoveNext() override;
        ASPOSECPP_SHARED_API void Reset() override;
    };
 
    class ASPOSECPP_SHARED_CLASS Reference
    {
    public:
        ~Reference();
        ASPOSECPP_SHARED_API operator bool() const;
        ASPOSECPP_SHARED_API bool operator ~ () const;
        ASPOSECPP_SHARED_API Reference& operator = (bool value);
        ASPOSECPP_SHARED_API Reference& operator = (const Reference &reference);
        ASPOSECPP_SHARED_API Reference& operator |= (bool value);
        ASPOSECPP_SHARED_API Reference& operator &= (bool value);
        ASPOSECPP_SHARED_API Reference& operator ^= (bool value);
        ASPOSECPP_SHARED_API Reference& operator -= (bool value);
    private:
        friend class BitArray;
        template <typename T> Reference(const T &reference);
        Detail::BitsetReferenceHolder m_reference;
    };
 
    ASPOSECPP_SHARED_API SharedPtr<Generic::IEnumerator<bool> > GetEnumerator() override;
 
    ASPOSECPP_SHARED_API BitArray(const bitset& bits);
    ASPOSECPP_SHARED_API BitArray(const BitArray& bits);
    ASPOSECPP_SHARED_API BitArray(const BitArrayPtr& array);
    ASPOSECPP_SHARED_API BitArray(const System::ArrayPtr<bool>& values);
    ASPOSECPP_SHARED_API BitArray(const System::ArrayPtr<uint8_t>& bytes);
    ASPOSECPP_SHARED_API BitArray(const System::ArrayPtr<int>& values);
    ASPOSECPP_SHARED_API BitArray(int length, bool defaultValue = false);
 
    ASPOSECPP_SHARED_API Reference operator[](int index);
 
    ASPOSECPP_SHARED_API bool idx_get(int index) const;
    ASPOSECPP_SHARED_API void idx_set(int index, bool value);
 
    ASPOSECPP_SHARED_API int get_Length() const;
    ASPOSECPP_SHARED_API int get_Count() const override;
 
    ASPOSECPP_SHARED_API void Add(const bool &item) override;
    ASPOSECPP_SHARED_API void Clear() override;
    ASPOSECPP_SHARED_API bool Contains(const bool &item) const override;
    ASPOSECPP_SHARED_API bool Remove(const bool &item) override;
    ASPOSECPP_SHARED_API void CopyTo(System::ArrayPtr<bool> array, int arrayIndex) override;
 
    ASPOSECPP_SHARED_API BitArrayPtr And(const BitArrayPtr& value);
    ASPOSECPP_SHARED_API BitArrayPtr Or(const BitArrayPtr& value);
    ASPOSECPP_SHARED_API BitArrayPtr Xor(const BitArrayPtr& value);
    ASPOSECPP_SHARED_API BitArrayPtr Not();
 
    ASPOSECPP_SHARED_API bool Get(int index) const;
    ASPOSECPP_SHARED_API void Set(int index, bool value);
    ASPOSECPP_SHARED_API void SetAll(bool value);
 
    ASPOSECPP_SHARED_API bitset& data();
    ASPOSECPP_SHARED_API const bitset& data() const;
 
    ASPOSECPP_SHARED_API bool operator == (const BitArray &other) const;
    ASPOSECPP_SHARED_API bool operator != (const BitArray &other) const;
 
    ASPOSECPP_SHARED_API void SetTemplateWeakPtr(uint32_t argument) override;
 
    System::Details::VirtualizedIteratorBase<bool>* virtualizeBeginIterator() override;
    System::Details::VirtualizedIteratorBase<bool>* virtualizeEndIterator() override;
    System::Details::VirtualizedIteratorBase<bool>* virtualizeBeginConstIterator() const override;
    System::Details::VirtualizedIteratorBase<bool>* virtualizeEndConstIterator() const override;
 
protected:
    ASPOSECPP_SHARED_API ~BitArray() override;
    Detail::BitsetHolder m_data;
};
 
class ASPOSECPP_SHARED_CLASS BitArrayPtr : public SharedPtr<BitArray>
{
public:
    ASPOSECPP_SHARED_API BitArrayPtr();
    ASPOSECPP_SHARED_API BitArrayPtr(const SharedPtr<BitArray>& obj);
 
    ASPOSECPP_SHARED_API BitArray::Reference operator[] (int idx) const;
 
    ASPOSECPP_SHARED_API bool IsNull() const;
};
 
} // namespace Collections
} // namespace System
 
#endif // _BitArray_h_