white_list.hpp

#ifndef BLUETOE_LINK_LAYER_WHITE_LIST_HPP
#define BLUETOE_LINK_LAYER_WHITE_LIST_HPP
 
#include <bluetoe/address.hpp>
#include <bluetoe/ll_meta_types.hpp>
 
#include <iterator>
#include <algorithm>
 
namespace bluetoe {
namespace link_layer {
 
    namespace details {
        struct white_list_meta_type {};
 
        template < std::size_t RequiredSize, bool SoftwareRequired, typename Radio, typename LinkLayer >
        class white_list_implementation;
    }
 
    template < std::size_t Size = 8 >
    class white_list
    {
    public:
        // this functions are purly for documentation purpose, the used implementations is in details::white_list_implementation
        static constexpr std::size_t maximum_white_list_entries = Size;
 
        bool add_to_white_list( const device_address& addr );
 
        bool remove_from_white_list( const device_address& addr );
 
        bool is_in_white_list( const device_address& addr ) const;
 
        std::size_t white_list_free_size() const;
 
        void clear_white_list();
 
        void connection_request_filter( bool b );
 
        bool connection_request_filter() const;
 
        void scan_request_filter( bool b );
 
        bool scan_request_filter() const;
 
        bool is_connection_request_in_filter( const device_address& addr ) const;
 
        bool is_scan_request_in_filter( const device_address& addr ) const;
 
        struct meta_type :
            details::white_list_meta_type,
            details::valid_link_layer_option_meta_type {};
 
        template < class Radio, class LinkLayer >
        struct impl :
            details::white_list_implementation<
                Size,
                ( Size > Radio::radio_maximum_white_list_entries ),
                Radio,
                LinkLayer
            >
        {
        };
    };
 
    struct no_white_list {
        template < class Radio, class LinkLayer >
        struct impl {
            bool is_connection_request_in_filter( const device_address& ) const
            {
                return true;
            }
 
            bool is_scan_request_in_filter( const device_address& ) const
            {
                return true;
            }
        };
 
        struct meta_type :
            details::white_list_meta_type,
            details::valid_link_layer_option_meta_type {};
    };
 
    namespace details {
 
        template < std::size_t Size, typename Radio, typename LinkLayer >
        class white_list_implementation< Size, true, Radio, LinkLayer >
        {
        public:
            static constexpr std::size_t maximum_white_list_entries = Size;
 
            white_list_implementation()
                : active_( false )
                , free_size_( Size )
                , connection_filter_( false )
                , scan_filter_( false )
            {
            }
 
            std::size_t white_list_free_size() const
            {
                return free_size_;
            }
 
            void clear_white_list()
            {
                free_size_ = Size;
            }
 
            bool add_to_white_list( const device_address& addr )
            {
                if ( is_in_white_list( addr ) )
                    return true;
 
                if ( free_size_ == 0 )
                    return false;
 
                addresses_[ Size - free_size_ ] = addr;
                --free_size_;
                return true;
            }
 
            bool is_in_white_list( const device_address& addr ) const
            {
                const auto end = std::begin( addresses_ ) + ( Size - free_size_ );
                return std::find( std::begin( addresses_ ), end, addr ) != end;
            }
 
            bool remove_from_white_list( const device_address& addr )
            {
                const auto end = std::begin( addresses_ ) + ( Size - free_size_ );
                const auto pos = std::find( std::begin( addresses_ ), end, addr );
 
                if ( pos == end )
                    return false;
 
                *pos = *( end - 1 );
                ++free_size_;
 
                return true;
            }
 
            void connection_request_filter( bool b )
            {
                connection_filter_ = b;
            }
 
            bool connection_request_filter() const
            {
                return connection_filter_;
            }
 
            void scan_request_filter( bool b )
            {
                scan_filter_ = b;
            }
 
            bool scan_request_filter() const
            {
                return scan_filter_;
            }
 
            bool is_connection_request_in_filter( const device_address& addr ) const
            {
                return !connection_filter_ || is_in_white_list( addr );
            }
 
            bool is_scan_request_in_filter( const device_address& addr ) const
            {
                return !scan_filter_ || is_in_white_list( addr );
            }
 
        private:
            bool            active_;
            std::size_t     free_size_;
            device_address  addresses_[ Size ];
            bool            connection_filter_;
            bool            scan_filter_;
        };
 
        template < std::size_t Size, typename Radio, typename LinkLayer >
        class white_list_implementation< Size, false, Radio, LinkLayer >
        {
        public:
            static constexpr std::size_t maximum_white_list_entries = Size;
 
            std::size_t white_list_free_size() const
            {
                return this_to_radio().radio_white_list_free_size();
            }
 
            void clear_white_list()
            {
                this_to_radio().radio_clear_white_list();
            }
 
            bool add_to_white_list( const device_address& addr )
            {
                return this_to_radio().radio_add_to_white_list( addr );
            }
 
            bool is_in_white_list( const device_address& addr ) const
            {
                return this_to_radio().radio_is_in_white_list( addr );
            }
 
            bool remove_from_white_list( const device_address& addr )
            {
                return this_to_radio().radio_remove_from_white_list( addr );
            }
 
            void connection_request_filter( bool b )
            {
                this_to_radio().radio_connection_request_filter( b );
            }
 
            bool connection_request_filter() const
            {
                return this_to_radio().radio_connection_request_filter();
            }
 
            void scan_request_filter( bool b )
            {
                this_to_radio().radio_scan_request_filter( b );
            }
 
            bool scan_request_filter() const
            {
                return this_to_radio().radio_scan_request_filter();
            }
 
            bool is_connection_request_in_filter( const device_address& addr ) const
            {
                return this_to_radio().radio_is_connection_request_in_filter( addr );
            }
 
            bool is_scan_request_in_filter( const device_address& addr ) const
            {
                return this_to_radio().radio_is_scan_request_in_filter( addr );
            }
        private:
            Radio& this_to_radio()
            {
                return static_cast< Radio& >( static_cast< LinkLayer& >( *this ) );
            }
 
            const Radio& this_to_radio() const
            {
                return static_cast< const Radio& >( static_cast< const LinkLayer& >( *this ) );
            }
        };
    }
}
}
#endif