cl_Set.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_SET_HPP
#define BELFEM_CL_SET_HPP
 
#include <unordered_set>
#include <string>
 
#include "assert.hpp"
 
namespace belfem
{
//------------------------------------------------------------------------------

    template< typename Key >
    class Set
    {
        std::unordered_set< Key > mSet;
 
//------------------------------------------------------------------------------
    public:
//------------------------------------------------------------------------------
 
        using iterator = typename std::unordered_set< Key >::iterator;
        using const_iterator = typename std::unordered_set< Key >::const_iterator;

        Set() = default;
 
//------------------------------------------------------------------------------

        Set( std::initializer_list< Key > aInit ) : mSet( aInit )
        {
        }
 
//------------------------------------------------------------------------------

        template< typename InputIt >
        Set( InputIt aFirst, InputIt aLast ) : mSet( aFirst, aLast )
        {
        }
 
//------------------------------------------------------------------------------

        Set( const Set< Key > & aSet ) = default;
 
//------------------------------------------------------------------------------

        Set( Set< Key > && aSet ) noexcept = default;
 
//------------------------------------------------------------------------------

        Set< Key > & operator=( const Set< Key > & aSet ) = default;
 
//------------------------------------------------------------------------------

        Set< Key > & operator=( Set< Key > && aSet ) noexcept = default;
 
//------------------------------------------------------------------------------

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

        void
        clear()
        {
            mSet.clear();
        }
 
//------------------------------------------------------------------------------

        size_t
        size() const
        {
            return mSet.size();
        }
 
//------------------------------------------------------------------------------

        bool
        empty() const
        {
            return mSet.empty();
        }
 
//------------------------------------------------------------------------------

        std::pair< iterator, bool >
        insert( const Key & aKey )
        {
            return mSet.insert( aKey );
        }
 
//------------------------------------------------------------------------------

        std::pair< iterator, bool >
        insert( Key && aKey )
        {
            return mSet.insert( std::move( aKey ) );
        }
 
//------------------------------------------------------------------------------

        template< typename InputIt >
        void
        insert( InputIt aFirst, InputIt aLast )
        {
            mSet.insert( aFirst, aLast );
        }
 
//------------------------------------------------------------------------------

        template< typename... Args >
        std::pair< iterator, bool >
        emplace( Args&&... args )
        {
            return mSet.emplace( std::forward< Args >( args )... );
        }
 
//------------------------------------------------------------------------------

        bool
        key_exists( const Key & aKey ) const
        {
            return mSet.find( aKey ) != mSet.end();
        }
 
//------------------------------------------------------------------------------

        bool
        contains( const Key & aKey ) const
        {
            return this->key_exists( aKey );
        }
 
//------------------------------------------------------------------------------

        size_t
        count( const Key & aKey ) const
        {
            return mSet.count( aKey );
        }
 
//------------------------------------------------------------------------------

        iterator
        find( const Key & aKey )
        {
            return mSet.find( aKey );
        }
 
//------------------------------------------------------------------------------

        const_iterator
        find( const Key & aKey ) const
        {
            return mSet.find( aKey );
        }
 
//------------------------------------------------------------------------------

        size_t
        erase( const Key & aKey )
        {
            return mSet.erase( aKey );
        }
 
//------------------------------------------------------------------------------

        iterator
        erase( const_iterator aPos )
        {
            return mSet.erase( aPos );
        }
 
//------------------------------------------------------------------------------

        iterator
        erase( const_iterator aFirst, const_iterator aLast )
        {
            return mSet.erase( aFirst, aLast );
        }
 
//------------------------------------------------------------------------------

        void
        reserve( size_t n )
        {
            mSet.reserve( n );
        }
 
//------------------------------------------------------------------------------

        iterator
        begin()
        {
            return mSet.begin();
        }
 
//------------------------------------------------------------------------------

        const_iterator
        begin() const
        {
            return mSet.begin();
        }
 
//------------------------------------------------------------------------------

        iterator
        end()
        {
            return mSet.end();
        }
 
//------------------------------------------------------------------------------

        const_iterator
        end() const
        {
            return mSet.end();
        }
 
//------------------------------------------------------------------------------

        std::unordered_set< Key > &
        set_data()
        {
            return mSet;
        }
 
//------------------------------------------------------------------------------

        const std::unordered_set< Key > &
        set_data() const
        {
            return mSet;
        }
 
//------------------------------------------------------------------------------

        void
        swap( Set< Key > & aOther )
        {
            mSet.swap( aOther.mSet );
        }
 
//------------------------------------------------------------------------------

        Set< Key >
        operator|( const Set< Key > & aOther ) const
        {
            Set< Key > tResult( *this );
            tResult.insert( aOther.begin(), aOther.end() );
            return tResult;
        }
 
//------------------------------------------------------------------------------

        Set< Key >
        operator&( const Set< Key > & aOther ) const
        {
            Set< Key > tResult;
            for ( const auto & tKey : mSet )
            {
                if ( aOther.contains( tKey ) )
                {
                    tResult.insert( tKey );
                }
            }
            return tResult;
        }
 
//------------------------------------------------------------------------------

        Set< Key >
        operator-( const Set< Key > & aOther ) const
        {
            Set< Key > tResult;
            for ( const auto & tKey : mSet )
            {
                if ( !aOther.contains( tKey ) )
                {
                    tResult.insert( tKey );
                }
            }
            return tResult;
        }
 
//------------------------------------------------------------------------------

        Set< Key >
        operator^( const Set< Key > & aOther ) const
        {
            Set< Key > tResult;
 
            // Add elements from this set not in other
            for ( const auto & tKey : mSet )
            {
                if ( !aOther.contains( tKey ) )
                {
                    tResult.insert( tKey );
                }
            }
 
            // Add elements from other set not in this
            for ( const auto & tKey : aOther )
            {
                if ( !this->contains( tKey ) )
                {
                    tResult.insert( tKey );
                }
            }
 
            return tResult;
        }
 
//------------------------------------------------------------------------------

        bool
        is_subset_of( const Set< Key > & aOther ) const
        {
            if ( this->size() > aOther.size() )
            {
                return false;
            }
 
            for ( const auto & tKey : mSet )
            {
                if ( !aOther.contains( tKey ) )
                {
                    return false;
                }
            }
            return true;
        }
 
//------------------------------------------------------------------------------

        bool
        is_superset_of( const Set< Key > & aOther ) const
        {
            return aOther.is_subset_of( *this );
        }
 
//------------------------------------------------------------------------------

        bool
        operator==( const Set< Key > & aOther ) const
        {
            if ( this->size() != aOther.size() )
            {
                return false;
            }
 
            for ( const auto & tKey : mSet )
            {
                if ( !aOther.contains( tKey ) )
                {
                    return false;
                }
            }
            return true;
        }
 
//------------------------------------------------------------------------------

        bool
        operator!=( const Set< Key > & aOther ) const
        {
            return !( *this == aOther );
        }
 
//------------------------------------------------------------------------------
    };
 
//------------------------------------------------------------------------------
} // namespace belfem
 
#endif // BELFEM_CL_SET_HPP