characteristic_value.hpp

#ifndef BLUETOE_CHARACTERISTIC_VALUE_HPP
#define BLUETOE_CHARACTERISTIC_VALUE_HPP
 
#include <bluetoe/meta_tools.hpp>
#include <bluetoe/attribute.hpp>
#include <bluetoe/codes.hpp>
#include <bluetoe/meta_types.hpp>
#include <type_traits>
#include <climits>
#include <cstring>
 
namespace bluetoe {
 
    namespace details {
        // type defines the value of a characteristic
        struct characteristic_value_meta_type {};
        // type is a valid parameter to a characteristic
        struct characteristic_parameter_meta_type {};
        // type is a characteristic read handler
        struct characteristic_value_read_handler_meta_type {};
        // type is a characteristic write handler
        struct characteristic_value_write_handler_meta_type {};
 
        struct characteristic_value_declaration_parameter {};
        struct client_characteristic_configuration_parameter {};
        struct characteristic_subscription_call_back_meta_type {};
    }
 
    struct no_read_access {
        using meta_type = details::valid_characteristic_option_meta_type;
    };
 
    struct no_write_access {
        using meta_type = details::valid_characteristic_option_meta_type;
    };
 
    struct notify {
        struct meta_type :
            details::client_characteristic_configuration_parameter,
            details::characteristic_parameter_meta_type,
            details::valid_characteristic_option_meta_type {};
    };
 
    struct indicate {
        struct meta_type :
            details::client_characteristic_configuration_parameter,
            details::characteristic_parameter_meta_type,
            details::valid_characteristic_option_meta_type {};
    };
 
    struct notify_on_subscription {
        template < typename UUID, typename Server >
        static void on_subscription( std::uint16_t flags, Server& srv )
        {
            if ( flags & details::client_characteristic_configuration_notification_enabled )
                srv.template notify< UUID >();
        }
 
        struct meta_type :
            details::characteristic_subscription_call_back_meta_type,
            details::characteristic_parameter_meta_type,
            details::valid_characteristic_option_meta_type {};
    };
 
    struct indicate_on_subscription {
        template < typename UUID, typename Server >
        static void on_subscription( std::uint16_t flags, Server& srv )
        {
            if ( flags & details::client_characteristic_configuration_indication_enabled )
                srv.template indicate< UUID >();
        }
 
        struct meta_type :
            details::characteristic_subscription_call_back_meta_type,
            details::characteristic_parameter_meta_type,
            details::valid_characteristic_option_meta_type {};
    };
 
    struct default_on_characteristic_subscription {
        template < typename UUID, typename Server >
        static void on_subscription( std::uint16_t, Server& ) {}
 
        struct meta_type :
            details::characteristic_subscription_call_back_meta_type,
            details::characteristic_parameter_meta_type,
            details::valid_characteristic_option_meta_type {};
    };
    struct write_without_response {
        struct meta_type :
            details::characteristic_parameter_meta_type,
            details::valid_characteristic_option_meta_type {};
    };
 
    struct only_write_without_response {
        struct meta_type :
            details::characteristic_parameter_meta_type,
            details::valid_characteristic_option_meta_type {};
    };
 
    namespace details {
        template < bool RequiresEncryption >
        struct encryption_requirements;
 
        template <>
        struct encryption_requirements< false > {
            static attribute_access_result check( const connection_security_attributes& ) {
                return attribute_access_result::success;
            }
        };
 
        template <>
        struct encryption_requirements< true > {
            static attribute_access_result check( const connection_security_attributes& attr )
            {
                if ( attr.is_encrypted )
                    return attribute_access_result::success;
 
                return attr.pairing_status == device_pairing_status::no_key
                    ? attribute_access_result::insufficient_authentication
                    : attribute_access_result::insufficient_encryption;
            }
        };
 
        /*
         * Base for value_implementations, providing common attributes and tests
         */
        template < typename ... Options >
        struct value_impl_base
        {
           static constexpr bool has_only_write_without_response = details::has_option< only_write_without_response, Options... >::value;
        };
    }
 
    template < typename T, T* Ptr >
    class bind_characteristic_value
    {
    public:
        template < typename ... Options >
        class value_impl : public details::value_impl_base< Options... >
        {
        public:
            static constexpr bool has_read_access  = !details::has_option< no_read_access, Options... >::value;
            static constexpr bool has_write_access = !std::is_const< T >::value && !details::has_option< no_write_access, Options... >::value;
            static constexpr bool has_write_without_response = details::has_option< write_without_response, Options... >::value;
            static constexpr bool has_notification = details::has_option< notify, Options... >::value;
            static constexpr bool has_indication   = details::has_option< indicate, Options... >::value;
 
            template < class Server, std::size_t ClientCharacteristicIndex, bool RequiresEncryption >
            static details::attribute_access_result characteristic_value_access( details::attribute_access_arguments& args, std::size_t )
            {
                const auto security_result = details::encryption_requirements< RequiresEncryption >::check( args.connection_security );
 
                if ( security_result != details::attribute_access_result::success )
                    return security_result;
 
                if ( args.type == details::attribute_access_type::read )
                {
                    return characteristic_value_read_access( args, std::integral_constant< bool, has_read_access >() );
                }
                else if ( args.type == details::attribute_access_type::write )
                {
                    return characteristic_value_write_access( args, std::integral_constant< bool, has_write_access >() );
                }
 
                return details::attribute_access_result::write_not_permitted;
            }
 
            /*
             * Used to find this characteristic for notification
             */
            static constexpr bool is_this( const void* value )
            {
                return value == Ptr;
            }
 
        private:
            static constexpr details::attribute_access_result characteristic_value_read_access( details::attribute_access_arguments& args, const std::true_type& )
            {
                return details::attribute_value_read_access( args, static_cast< const std::uint8_t* >( static_cast< const void* >( Ptr ) ), sizeof( T ) );
            }
 
            static constexpr details::attribute_access_result characteristic_value_read_access( details::attribute_access_arguments&, const std::false_type& )
            {
                return details::attribute_access_result::read_not_permitted;
            }
 
            static details::attribute_access_result characteristic_value_write_access( details::attribute_access_arguments& args, const std::true_type& )
            {
                if ( args.buffer_offset > sizeof( T ) )
                    return details::attribute_access_result::invalid_offset;
 
                if ( args.buffer_size + args.buffer_offset > sizeof( T ) )
                    return details::attribute_access_result::invalid_attribute_value_length;
 
                args.buffer_size = std::min< std::size_t >( args.buffer_size, sizeof( T ) - args.buffer_offset );
 
                std::uint8_t* const ptr = static_cast< std::uint8_t* >( static_cast< void* >( Ptr ) );
                std::copy( args.buffer, args.buffer + args.buffer_size, ptr + args.buffer_offset );
 
                return details::attribute_access_result::success;
            }
 
            static constexpr details::attribute_access_result characteristic_value_write_access( details::attribute_access_arguments&, const std::false_type& )
            {
                return details::attribute_access_result::write_not_permitted;
            }
 
        };
 
        struct meta_type :
            details::characteristic_value_meta_type,
            details::characteristic_value_declaration_parameter,
            details::valid_characteristic_option_meta_type {};
    };
 
    template < class T, T Value >
    struct fixed_value {
        template < typename ... Options >
        class value_impl : public details::value_impl_base< Options... >
        {
        public:
            static constexpr bool has_read_access  = !details::has_option< no_read_access, Options... >::value;
            static constexpr bool has_write_access = false;
            static constexpr bool has_write_without_response = false;
            static constexpr bool has_notification = details::has_option< notify, Options... >::value;
            static constexpr bool has_indication   = details::has_option< indicate, Options... >::value;
 
            template < class Server, std::size_t ClientCharacteristicIndex, bool RequiresEncryption  >
            static details::attribute_access_result characteristic_value_access( details::attribute_access_arguments& args, std::size_t )
            {
                const auto security_result = details::encryption_requirements< RequiresEncryption >::check( args.connection_security );
 
                if ( security_result != details::attribute_access_result::success )
                    return security_result;
 
                if ( !has_read_access )
                    return details::attribute_access_result::read_not_permitted;
 
                if ( args.type != details::attribute_access_type::read )
                    return details::attribute_access_result::write_not_permitted;
 
                if ( args.buffer_offset > sizeof( T ) )
                    return details::attribute_access_result::invalid_offset;
 
                args.buffer_size = std::min< std::size_t >( args.buffer_size, sizeof( T ) - args.buffer_offset );
 
                // copy data
                std::uint8_t* output = args.buffer;
                for ( auto i = args.buffer_offset; i != args.buffer_offset + args.buffer_size; ++i, ++output )
                    *output = ( Value >> ( 8 * i ) ) & 0xff;
 
                return details::attribute_access_result::success;
            }
 
            static constexpr bool is_this( const void* )
            {
                return false;
            }
        };
 
        struct meta_type :
            details::characteristic_value_meta_type,
            details::characteristic_value_declaration_parameter,
            details::valid_characteristic_option_meta_type {};
    };
 
    template < std::uint8_t Value >
    using fixed_uint8_value = fixed_value< std::uint8_t, Value >;
 
    template < std::uint16_t Value >
    using fixed_uint16_value = fixed_value< std::uint16_t, Value >;
 
 
    template < std::uint32_t Value >
    using fixed_uint32_value = fixed_value< std::uint32_t, Value >;
 
    template < class Text >
    struct cstring_wrapper
    {
        template < typename ... Options >
        class value_impl : public details::value_impl_base< Options... >
        {
        public:
            static constexpr bool has_read_access  = true;
            static constexpr bool has_write_access = false;
            static constexpr bool has_write_without_response = false;
            static constexpr bool has_notification = false;
            static constexpr bool has_indication   = false;
 
            template < class Server, std::size_t ClientCharacteristicIndex, bool RequiresEncryption  >
            static details::attribute_access_result characteristic_value_access( details::attribute_access_arguments& args, std::size_t )
            {
                const auto security_result = details::encryption_requirements< RequiresEncryption >::check( args.connection_security );
 
                if ( security_result != details::attribute_access_result::success )
                    return security_result;
 
                if ( args.type != details::attribute_access_type::read )
                    return details::attribute_access_result::write_not_permitted;
 
                const char* value  = static_cast< const char* >( static_cast< const void* >( Text::value() ) );
                std::size_t length = Text::size();
 
                if ( args.buffer_offset > length )
                    return details::attribute_access_result::invalid_offset;
 
                args.buffer_size = std::min< std::size_t >( args.buffer_size, length - args.buffer_offset );
 
                // copy data
                std::copy( value + args.buffer_offset, value + args.buffer_offset + args.buffer_size, args.buffer );
 
                return details::attribute_access_result::success;
            }
 
            static constexpr bool is_this( const void* )
            {
                return false;
            }
 
        };
 
        struct meta_type :
            details::characteristic_value_meta_type,
            details::characteristic_value_declaration_parameter,
            details::valid_characteristic_option_meta_type {};
    };
 
    template < const char* const Name >
    struct cstring_value : cstring_wrapper< cstring_value< Name > >
    {
        static constexpr char const * name = Name;
 
        static constexpr char const * value()
        {
            return name;
        }
 
        static constexpr std::size_t size()
        {
            return std::strlen( name );
        }
    };
 
    template < const std::uint8_t* const Value, std::size_t Size >
    struct fixed_blob_value : cstring_wrapper< fixed_blob_value< Value, Size > >
    {
        static constexpr std::uint8_t const * value()
        {
            return Value;
        }
 
        static constexpr std::size_t size()
        {
            return Size;
        }
    };
 
    namespace details {
        template < class T >
        struct invoke_read_handler {
            template < class Server >
            static constexpr std::uint8_t call_read_handler( std::size_t offset, std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size, void* server )
            {
                return T::template call_read_handler< Server >( offset, read_size, out_buffer, out_size, server );
            }
        };
 
        template <>
        struct invoke_read_handler< no_such_type > {
            template < class Server >
            static constexpr std::uint8_t call_read_handler( std::size_t, std::size_t, std::uint8_t*, std::size_t&, void* )
            {
                return error_codes::read_not_permitted;
            }
        };
 
        template < class T >
        struct invoke_write_handler {
            template < class Server, std::size_t ClientCharacteristicIndex >
            static constexpr std::uint8_t call_write_handler( std::size_t offset, std::size_t write_size, const std::uint8_t* value, const details::client_characteristic_configuration& config, void* server )
            {
                return T::template call_write_handler< Server, ClientCharacteristicIndex >( offset, write_size, value, config, server );
            }
        };
 
        template <>
        struct invoke_write_handler< no_such_type > {
            template < class Server, std::size_t ClientCharacteristicIndex >
            static constexpr std::uint8_t call_write_handler( std::size_t, std::size_t, const std::uint8_t*, const details::client_characteristic_configuration&, void* )
            {
                return error_codes::write_not_permitted;
            }
        };
 
        struct value_handler_base {
 
            template < typename ... Options >
            class value_impl : public details::value_impl_base< Options... >
            {
            public:
                using read_handler_type = typename find_by_meta_type< characteristic_value_read_handler_meta_type, Options... >::type;
                using write_handler_type = typename find_by_meta_type< characteristic_value_write_handler_meta_type, Options... >::type;
                static constexpr bool no_read          = has_option< no_read_access, Options... >::value;
                static constexpr bool no_write         = has_option< no_write_access, Options... >::value;
 
                static constexpr bool has_read_handler = !std::is_same< read_handler_type, no_such_type >::value;
                static constexpr bool has_read_access  = has_read_handler && !no_read;
                static constexpr bool has_write_access = !std::is_same< write_handler_type, no_such_type >::value;
                static constexpr bool has_write_without_response = details::has_option< write_without_response, Options... >::value;
                static constexpr bool has_notification = has_option< notify, Options... >::value;
                static constexpr bool has_indication   = has_option< indicate, Options... >::value;
 
                static_assert( !( no_write && ( has_write_access || has_write_without_response ) ), "There is no point in providing a write_handler and disabling write by using no_write_access" );
 
                static_assert( !has_notification || ( has_notification && has_read_handler ), "When enabling notification, the characteristic needs to have a read_handler" );
                static_assert( !has_indication || ( has_indication && has_read_handler ), "When enabling indications, the characteristic needs to have a read_handler" );
 
                static_assert( has_read_access || has_write_access || has_notification || has_indication, "Ups!");
 
                template < class Server, std::size_t ClientCharacteristicIndex, bool RequiresEncryption >
                static attribute_access_result characteristic_value_access( attribute_access_arguments& args, std::size_t /* attribute_index */ )
                {
                    const auto security_result = details::encryption_requirements< RequiresEncryption >::check( args.connection_security );
 
                    if ( security_result != details::attribute_access_result::success )
                        return security_result;
 
                    if ( args.type == attribute_access_type::read )
                    {
                        return static_cast< attribute_access_result >(
                            invoke_read_handler< read_handler_type >::template call_read_handler< Server >( args.buffer_offset, args.buffer_size, args.buffer, args.buffer_size, args.server ) );
                    }
                    else if ( args.type == attribute_access_type::write )
                    {
                        return static_cast< attribute_access_result >(
                            invoke_write_handler< write_handler_type >::template call_write_handler< Server, ClientCharacteristicIndex >( args.buffer_offset, args.buffer_size, args.buffer, args.client_config, args.server ) );
                    }
                    else
                    {
                        return attribute_access_result::request_not_supported;
                    }
                }
 
                static constexpr bool is_this( const void* /* value */ )
                {
                    return false;
                }
            };
 
            struct meta_type :
                characteristic_value_meta_type,
                characteristic_value_declaration_parameter,
                details::valid_characteristic_option_meta_type {};
        };
 
        template < typename T >
        inline std::pair< std::uint8_t, T > deserialize( std::size_t write_size, const std::uint8_t* value )
        {
            static_assert( CHAR_BIT == 8, "needs porting!" );
 
            if ( write_size != sizeof( T ) )
                return std::pair< std::uint8_t, T >{ error_codes::invalid_attribute_value_length, 0 };
 
            T result = 0;
 
            for ( const std::uint8_t* v = value + sizeof( T ); v != value; --v )
            {
                result = ( result << 8 ) | *( v - 1 );
            }
 
            return std::pair< std::uint8_t, T >{ error_codes::success, result };
        }
 
        template <>
        inline std::pair< std::uint8_t, bool > deserialize( std::size_t write_size, const std::uint8_t* value )
        {
            if ( write_size != 1 )
                return std::make_pair( error_codes::invalid_attribute_value_length, false );
 
            if ( *value == 0 )
            {
                return std::pair< std::uint8_t, bool >{ error_codes::success, false };
            }
            else if ( *value == 1 )
            {
                return std::pair< std::uint8_t, bool >{ error_codes::success, true };
            }
 
            return std::pair< std::uint8_t, bool >{ error_codes::out_of_range, false };
        }
    }
 
    template < std::uint8_t (*F)( std::size_t offset, std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size ) >
    struct free_read_blob_handler : details::value_handler_base
    {
        template < class Server >
        static constexpr std::uint8_t call_read_handler( std::size_t offset, std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size, void* )
        {
            return F( offset, read_size, out_buffer, out_size );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_read_handler_meta_type {};
    };
 
    template < std::uint8_t (*F)( std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size ) >
    struct free_read_handler : details::value_handler_base
    {
        template < class Server >
        static constexpr std::uint8_t call_read_handler( std::size_t offset, std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size, void* )
        {
            return offset == 0
                ? F( read_size, out_buffer, out_size )
                : static_cast< std::uint8_t >( error_codes::attribute_not_long );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_read_handler_meta_type {};
    };
 
    template < std::uint8_t (*F)( std::size_t offset, std::size_t write_size, const std::uint8_t* value ) >
    struct free_write_blob_handler : details::value_handler_base
    {
        template < class Server, std::size_t ClientCharacteristicIndex >
        static constexpr std::uint8_t call_write_handler( std::size_t offset, std::size_t write_size, const std::uint8_t* value, const details::client_characteristic_configuration& , void* )
        {
            return F( offset, write_size, value );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_write_handler_meta_type {};
    };
 
    template < std::uint8_t (*F)( std::size_t write_size, const std::uint8_t* value ) >
    struct free_raw_write_handler : details::value_handler_base
    {
        template < class Server, std::size_t ClientCharacteristicIndex >
        static constexpr std::uint8_t call_write_handler( std::size_t offset, std::size_t write_size, const std::uint8_t* value, const details::client_characteristic_configuration& , void* )
        {
            return offset == 0
                ? F( write_size, value )
                : static_cast< std::uint8_t >( error_codes::attribute_not_long );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_write_handler_meta_type {};
    };
 
    template < class Obj, Obj& O, std::uint8_t (Obj::*F)( std::size_t offset, std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size ) >
    struct read_blob_handler : details::value_handler_base
    {
        template < class Server >
        static constexpr std::uint8_t call_read_handler( std::size_t offset, std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size, void* )
        {
            return (O.*F)( offset, read_size, out_buffer, out_size );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_read_handler_meta_type {};
    };
 
    template < class Obj, const Obj& O, std::uint8_t (Obj::*F)( std::size_t offset, std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size ) const >
    struct read_blob_handler_c : details::value_handler_base
    {
        template < class Server >
        static constexpr std::uint8_t call_read_handler( std::size_t offset, std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size, void* )
        {
            return (O.*F)( offset, read_size, out_buffer, out_size );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_read_handler_meta_type {};
    };
 
    template < class Obj, volatile Obj& O, std::uint8_t (Obj::*F)( std::size_t offset, std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size ) volatile >
    struct read_blob_handler_v : details::value_handler_base
    {
        template < class Server >
        static constexpr std::uint8_t call_read_handler( std::size_t offset, std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size, void* )
        {
            return (O.*F)( offset, read_size, out_buffer, out_size );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_read_handler_meta_type {};
    };
 
    template < class Obj, const volatile Obj& O, std::uint8_t (Obj::*F)( std::size_t offset, std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size ) const volatile >
    struct read_blob_handler_cv : details::value_handler_base
    {
        template < class Server >
        static constexpr std::uint8_t call_read_handler( std::size_t offset, std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size, void* )
        {
            return (O.*F)( offset, read_size, out_buffer, out_size );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_read_handler_meta_type {};
    };
 
    template < class Obj, Obj& O, std::uint8_t (Obj::*F)( std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size ) >
    struct read_handler : details::value_handler_base
    {
        template < class Server >
        static constexpr std::uint8_t call_read_handler( std::size_t offset, std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size, void* )
        {
            return offset == 0
                ? (O.*F)( read_size, out_buffer, out_size )
                : static_cast< std::uint8_t >( error_codes::attribute_not_long );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_read_handler_meta_type {};
    };
 
    template < class Obj, const Obj& O, std::uint8_t (Obj::*F)( std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size ) const >
    struct read_handler_c : details::value_handler_base
    {
        template < class Server >
        static constexpr std::uint8_t call_read_handler( std::size_t offset, std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size, void* )
        {
            return offset == 0
                ? (O.*F)( read_size, out_buffer, out_size )
                : static_cast< std::uint8_t >( error_codes::attribute_not_long );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_read_handler_meta_type {};
    };
 
    template < class Obj, volatile Obj& O, std::uint8_t (Obj::*F)( std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size ) volatile >
    struct read_handler_v : details::value_handler_base
    {
        template < class Server >
        static constexpr std::uint8_t call_read_handler( std::size_t offset, std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size, void* )
        {
            return offset == 0
                ? (O.*F)( read_size, out_buffer, out_size )
                : static_cast< std::uint8_t >( error_codes::attribute_not_long );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_read_handler_meta_type {};
    };
 
    template < class Obj, const volatile Obj& O, std::uint8_t (Obj::*F)( std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size ) const volatile >
    struct read_handler_cv : details::value_handler_base
    {
        template < class Server >
        static constexpr std::uint8_t call_read_handler( std::size_t offset, std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size, void* )
        {
            return offset == 0
                ? (O.*F)( read_size, out_buffer, out_size )
                : static_cast< std::uint8_t >( error_codes::attribute_not_long );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_read_handler_meta_type {};
    };
 
    template < class Obj, Obj& O, std::uint8_t (Obj::*F)( std::size_t offset, std::size_t write_size, const std::uint8_t* value ) >
    struct write_blob_handler : details::value_handler_base
    {
        template < class Server, std::size_t ClientCharacteristicIndex >
        static constexpr std::uint8_t call_write_handler( std::size_t offset, std::size_t write_size, const std::uint8_t* value, const details::client_characteristic_configuration& , void* )
        {
            return (O.*F)( offset, write_size, value );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_write_handler_meta_type {};
    };
 
    template < class Obj, const Obj& O, std::uint8_t (Obj::*F)( std::size_t offset, std::size_t write_size, const std::uint8_t* value ) const >
    struct write_blob_handler_c : details::value_handler_base
    {
        template < class Server, std::size_t ClientCharacteristicIndex >
        static constexpr std::uint8_t call_write_handler( std::size_t offset, std::size_t write_size, const std::uint8_t* value, const details::client_characteristic_configuration& , void* )
        {
            return (O.*F)( offset, write_size, value );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_write_handler_meta_type {};
    };
 
    template < class Obj, volatile Obj& O, std::uint8_t (Obj::*F)( std::size_t offset, std::size_t write_size, const std::uint8_t* value ) volatile >
    struct write_blob_handler_v : details::value_handler_base
    {
        template < class Server, std::size_t ClientCharacteristicIndex >
        static constexpr std::uint8_t call_write_handler( std::size_t offset, std::size_t write_size, const std::uint8_t* value, const details::client_characteristic_configuration& , void* )
        {
            return (O.*F)( offset, write_size, value );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_write_handler_meta_type {};
    };
 
    template < class Obj, const volatile Obj& O, std::uint8_t (Obj::*F)( std::size_t offset, std::size_t write_size, const std::uint8_t* value ) const volatile >
    struct write_blob_handler_cv : details::value_handler_base
    {
        template < class Server, std::size_t ClientCharacteristicIndex >
        static constexpr std::uint8_t call_write_handler( std::size_t offset, std::size_t write_size, const std::uint8_t* value, const details::client_characteristic_configuration& , void* )
        {
            return (O.*F)( offset, write_size, value );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_write_handler_meta_type {};
    };
 
    template < class Obj, Obj& O, std::uint8_t (Obj::*F)( std::size_t write_size, const std::uint8_t* value ) >
    struct write_handler : details::value_handler_base
    {
        template < class Server, std::size_t ClientCharacteristicIndex >
        static constexpr std::uint8_t call_write_handler( std::size_t offset, std::size_t write_size, const std::uint8_t* value, const details::client_characteristic_configuration& , void* )
        {
            return offset == 0
                ? (O.*F)( write_size, value )
                : static_cast< std::uint8_t >( error_codes::attribute_not_long );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_write_handler_meta_type {};
    };
 
    template < class Obj, const Obj& O, std::uint8_t (Obj::*F)( std::size_t write_size, const std::uint8_t* value ) const >
    struct write_handler_c : details::value_handler_base
    {
        template < class Server, std::size_t ClientCharacteristicIndex >
        static constexpr std::uint8_t call_write_handler( std::size_t offset, std::size_t write_size, const std::uint8_t* value, const details::client_characteristic_configuration& , void* )
        {
            return offset == 0
                ? (O.*F)( write_size, value )
                : static_cast< std::uint8_t >( error_codes::attribute_not_long );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_write_handler_meta_type {};
    };
 
    template < class Obj, volatile Obj& O, std::uint8_t (Obj::*F)( std::size_t write_size, const std::uint8_t* value ) volatile >
    struct write_handler_v : details::value_handler_base
    {
        template < class Server, std::size_t ClientCharacteristicIndex >
        static std::uint8_t call_write_handler( std::size_t offset, std::size_t write_size, const std::uint8_t* value, const details::client_characteristic_configuration& , void* )
        {
            return offset == 0
                ? (O.*F)( write_size, value )
                : static_cast< std::uint8_t >( error_codes::attribute_not_long );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_write_handler_meta_type {};
    };
 
    template < class Obj, const volatile Obj& O, std::uint8_t (Obj::*F)( std::size_t write_size, const std::uint8_t* value ) const volatile >
    struct write_handler_cv : details::value_handler_base
    {
        template < class Server, std::size_t ClientCharacteristicIndex >
        static constexpr std::uint8_t call_write_handler( std::size_t offset, std::size_t write_size, const std::uint8_t* value, const details::client_characteristic_configuration& , void* )
        {
            return offset == 0
                ? (O.*F)( write_size, value )
                : static_cast< std::uint8_t >( error_codes::attribute_not_long );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_write_handler_meta_type {};
    };
 
    template < class Mixin, std::uint8_t (Mixin::*F)( std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size ) >
    struct mixin_read_handler : details::value_handler_base
    {
        template < class Server >
        static std::uint8_t call_read_handler( std::size_t offset, std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size, void* server )
        {
            assert( server );
            static_assert( std::is_convertible< Server*, Mixin* >::value, "Use bluetoe::mixin<> to mixin an instance of the mixin_read_handler into the server." );
 
            Mixin& mixin = static_cast< Mixin& >( *static_cast< Server* >( server ) );
 
            return offset == 0
                ? (mixin.*F)( read_size, out_buffer, out_size )
                : static_cast< std::uint8_t >( error_codes::attribute_not_long );
 
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_read_handler_meta_type {};
    };
 
    template < class Mixin, std::uint8_t (Mixin::*F)( std::size_t write_size, const std::uint8_t* value ) >
    struct mixin_write_handler : details::value_handler_base
    {
        template < class Server, std::size_t ClientCharacteristicIndex >
        static std::uint8_t call_write_handler( std::size_t offset, std::size_t write_size, const std::uint8_t* value, const details::client_characteristic_configuration& , void* server )
        {
            assert( server );
            static_assert( std::is_convertible< Server*, Mixin* >::value, "Use bluetoe::mixin<> to mixin an instance of the mixin_write_handler into the server." );
 
            Mixin& mixin = static_cast< Mixin& >( *static_cast< Server* >( server ) );
 
            return offset == 0
                ? (mixin.*F)( write_size, value )
                : static_cast< std::uint8_t >( error_codes::attribute_not_long );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_write_handler_meta_type {};
    };
 
    template < class Mixin, std::uint8_t (Mixin::*F)( std::size_t offset, std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size ) >
    struct mixin_read_blob_handler : details::value_handler_base
    {
        template < class Server >
        static std::uint8_t call_read_handler( std::size_t offset, std::size_t read_size, std::uint8_t* out_buffer, std::size_t& out_size, void* server )
        {
            assert( server );
            static_assert( std::is_convertible< Server*, Mixin* >::value, "Use bluetoe::mixin<> to mixin an instance of the mixin_read_blob_handler into the server." );
 
            Mixin& mixin = static_cast< Mixin& >( *static_cast< Server* >( server ) );
            return (mixin.*F)( offset, read_size, out_buffer, out_size );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_read_handler_meta_type {};
    };
 
    template < class Mixin, std::uint8_t (Mixin::*F)( std::size_t offset, std::size_t write_size, const std::uint8_t* value ) >
    struct mixin_write_blob_handler : details::value_handler_base
    {
        template < class Server, std::size_t ClientCharacteristicIndex >
        static std::uint8_t call_write_handler( std::size_t offset, std::size_t write_size, const std::uint8_t* value, const details::client_characteristic_configuration& , void* server )
        {
            assert( server );
            static_assert( std::is_convertible< Server*, Mixin* >::value, "Use bluetoe::mixin<> to mixin an instance of the mixin_write_blob_handler into the server." );
 
            Mixin& mixin = static_cast< Mixin& >( *static_cast< Server* >( server ) );
            return (mixin.*F)( offset, write_size, value );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_write_handler_meta_type {};
    };
 
    template < class Mixin, std::pair< std::uint8_t, bool > (Mixin::*F)( std::size_t write_size, const std::uint8_t* value ), typename IndicationUUID >
    struct mixin_write_indication_control_point_handler : details::value_handler_base
    {
        template < class Server, std::size_t >
        static std::uint8_t call_write_handler( std::size_t offset, std::size_t write_size, const std::uint8_t* value, const details::client_characteristic_configuration& config, void* server_ptr )
        {
            assert( server_ptr );
            static_assert( std::is_convertible< Server*, Mixin* >::value, "Use bluetoe::mixin<> to mixin an instance of the mixin_write_handler into the server." );
 
            if ( offset != 0 )
                return static_cast< std::uint8_t >( error_codes::attribute_not_long );
 
            // we have a void pointer, the type of the server and the server is derived from the mixin
            Server& server = *static_cast< Server* >( server_ptr );
            Mixin&  mixin  = static_cast< Mixin& >( server );
 
            // as this is a indication control point, this thingy must be configured for indications
            if ( !server.template configured_for_indications< IndicationUUID >( config ) )
                return error_codes::cccd_improperly_configured;
 
            const std::pair< std::uint8_t, bool > result = (mixin.*F)( write_size, value );
 
            if ( result.second )
                server.template indicate< IndicationUUID >();
 
            return static_cast< std::uint8_t >( result.first );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_write_handler_meta_type {};
    };
 
    template < class Mixin, std::pair< std::uint8_t, bool > (Mixin::*F)( std::size_t write_size, const std::uint8_t* value ), typename NotificationUUID >
    struct mixin_write_notification_control_point_handler : details::value_handler_base
    {
        template < class Server, std::size_t  >
        static std::uint8_t call_write_handler( std::size_t offset, std::size_t write_size, const std::uint8_t* value, const details::client_characteristic_configuration& config, void* server_ptr )
        {
            assert( server_ptr );
            static_assert( std::is_convertible< Server*, Mixin* >::value, "Use bluetoe::mixin<> to mixin an instance of the mixin_write_handler into the server." );
 
            if ( offset != 0 )
                return static_cast< std::uint8_t >( error_codes::attribute_not_long );
 
            // we have a void pointer, the type of the server and the server is derived from the mixin
            Server& server = *static_cast< Server* >( server_ptr );
            Mixin&  mixin  = static_cast< Mixin& >( server );
 
            // as this is a notification control point, this thingy must be configured for notification
            if ( !server.template configured_for_notifications< NotificationUUID >( config ) )
                return error_codes::cccd_improperly_configured;
 
            const std::pair< std::uint8_t, bool > result = (mixin.*F)( write_size, value );
 
            if ( result.second )
                server.template notify< NotificationUUID >();
 
            return static_cast< std::uint8_t >( result.first );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_write_handler_meta_type {};
    };
 
    template < typename T, std::uint8_t (*F)( T ) >
    struct free_write_handler : details::value_handler_base
    {
        template < class Server, std::size_t ClientCharacteristicIndex >
        static std::uint8_t call_write_handler( std::size_t offset, std::size_t write_size, const std::uint8_t* value, const details::client_characteristic_configuration& , void* )
        {
            if ( offset != 0 )
                return static_cast< std::uint8_t >( error_codes::attribute_not_long );
 
            const std::pair< std::uint8_t, T > deserialized_value = details::deserialize< T >( write_size, value );
 
            if ( deserialized_value.first != error_codes::success )
                return deserialized_value.first;
 
            return (*F)( deserialized_value.second );
        }
 
        struct meta_type : details::value_handler_base::meta_type, details::characteristic_value_write_handler_meta_type {};
    };
 
}
 
#endif