cl_Bitset.hpp

Go to the documentation of this file.

/*
 * BELFEM -- The Berkeley Lab Finite Element Framework
 * Copyright (c) 2026, The Regents of the University of California,
 * through Lawrence Berkeley National Laboratory (subject to receipt of any required
 * approvals from the U.S. Dept. of Energy).  All rights reserved.
 *
 * Developers: Christian Messe, Gregory Giard
 *
 * See the top-level LICENSE file for the complete license and disclaimer.
 */
 
#ifndef BELFEM_CL_BITSET_HPP
#define BELFEM_CL_BITSET_HPP
 
 
#include <bitset>
 
#include "typedefs.hpp"
 
namespace belfem
{
//------------------------------------------------------------------------------

    template < index_t N >
    class Bitset
    {
//------------------------------------------------------------------------------
 
        // the wrapped standard bitset
        std::bitset< N > mBitset;
 
//------------------------------------------------------------------------------
    public:
//------------------------------------------------------------------------------
 

        Bitset() = default;
 
//------------------------------------------------------------------------------

        Bitset( const Bitset< N > & aBitset ) :
                mBitset( aBitset.mBitset )
        {
        }
 
//------------------------------------------------------------------------------

        Bitset( Bitset< N > && aBitset ) :
                mBitset( std::move( aBitset.mBitset ) )
        {
        }
 
//------------------------------------------------------------------------------

        ~Bitset() = default;
 
//------------------------------------------------------------------------------

        inline index_t
        size() const
        {
            return N;
        }
 
//------------------------------------------------------------------------------

        inline void
        set( const index_t aIndex )
        {
            mBitset.set( aIndex );
        }
 
//------------------------------------------------------------------------------

        inline void
        reset( const index_t aIndex )
        {
            mBitset.reset( aIndex );
        }
 
 
//------------------------------------------------------------------------------

        inline void
        reset()
        {
            mBitset.reset();
        }
 
 
//------------------------------------------------------------------------------

        inline void
        flip( const index_t aIndex )
        {
            mBitset.flip( aIndex );
        }
 
//------------------------------------------------------------------------------

        inline bool
        test( const index_t aIndex ) const
        {
            return mBitset.test( aIndex );
        }
 
//------------------------------------------------------------------------------

        inline index_t
        count() const
        {
            return mBitset.count();
        }
 
//------------------------------------------------------------------------------

        inline std::bitset< N > &
        data()
        {
            return mBitset ;
        }
 
//------------------------------------------------------------------------------

        inline const std::bitset< N > &
        data() const
        {
            return mBitset ;
        }
 
//------------------------------------------------------------------------------

        Bitset< N > &
        operator=( const Bitset< N > & aBitset )
        {
            if( this != & aBitset )
            {
                mBitset = aBitset.mBitset ;
            }
            return *this ;
        }
 
//------------------------------------------------------------------------------

        Bitset< N > &
        operator=( Bitset< N > && aBitset )
        {
            if( this != & aBitset )
            {
                mBitset = std::move( aBitset.mBitset ) ;
            }
            return *this ;
        }
 
//------------------------------------------------------------------------------

        inline bool
        operator==( const Bitset< N > & aBitset ) const
        {
            return mBitset == aBitset.mBitset ;
        }
 
//------------------------------------------------------------------------------

        inline bool
        operator!=( const Bitset< N > & aBitset ) const
        {
            return mBitset != aBitset.mBitset ;
        }
 
//------------------------------------------------------------------------------
    };
}
 
#endif //BELFEM_CL_BITSET_HPP