encryption.hpp

#ifndef BLUETOE_ENCRYPTION_HPP
#define BLUETOE_ENCRYPTION_HPP
 
#include <bluetoe/meta_tools.hpp>
#include <bluetoe/meta_types.hpp>
 
namespace bluetoe {
 
    template < typename ... Options >
    class server;
 
    template < typename ... Options >
    class service;
 
    template < typename ... Options >
    class characteristic;
 
    namespace details {
        struct requires_encryption_meta_type {};
        struct no_encryption_required_meta_type {};
        struct may_require_encryption_meta_type {};
    }
 
    struct requires_encryption {
        struct meta_type :
            details::requires_encryption_meta_type,
            details::valid_server_option_meta_type,
            details::valid_service_option_meta_type,
            details::valid_characteristic_option_meta_type {};
    };
 
    struct no_encryption_required {
        struct meta_type :
            details::no_encryption_required_meta_type,
            details::valid_server_option_meta_type,
            details::valid_service_option_meta_type,
            details::valid_characteristic_option_meta_type {};
    };
 
    struct may_require_encryption {
        struct meta_type :
            details::may_require_encryption_meta_type,
            details::valid_server_option_meta_type,
            details::valid_service_option_meta_type,
            details::valid_characteristic_option_meta_type {};
    };
 
    namespace details {
 
        template < typename Server, bool Default = false >
        struct requires_encryption_support_t
        {
            static bool constexpr value = Default;
        };
 
        template < typename ... Options, typename T >
        struct requires_encryption_support_t< std::tuple< T, Options... >, false >
        {
            static bool constexpr value =
                requires_encryption_support_t< T, false >::value
             || requires_encryption_support_t< std::tuple< Options... >, false >::value;
        };
 
        template < typename ... Options, typename T >
        struct requires_encryption_support_t< std::tuple< T, Options... >, true >
        {
            static bool constexpr value =
                requires_encryption_support_t< T, true >::value
             && requires_encryption_support_t< std::tuple< Options... >, true >::value;
        };
 
        template < bool Default, typename ... Options >
        struct encryption_default
        {
            static bool constexpr require_encryption =
                details::has_option< requires_encryption, Options... >::value;
 
            static bool constexpr may_require =
                details::has_option< may_require_encryption, Options... >::value;
 
            static bool constexpr require_not_encryption =
                 details::has_option< no_encryption_required, Options... >::value;
 
            // require !require default | value
            //    true    false   false |  true
            //   false     true   false | false
            //   false    false   false | false
            //    true    false    true |  true
            //   false     true    true | false
            //   false    false    true |  true
            static bool constexpr value =
                ( require_encryption && !require_not_encryption )
             || ( !require_encryption && !require_not_encryption && Default );
 
            static bool constexpr maybe = value || may_require;
        };
 
        template < typename ... Options, bool Default >
        struct requires_encryption_support_t< bluetoe::server< Options... >, Default > {
            static bool constexpr default_val = encryption_default< Default, Options... >::maybe;
 
            static bool constexpr value =
                requires_encryption_support_t<
                    typename bluetoe::server< Options... >::services,
                    default_val >::value;
        };
 
        template < typename ... Options, bool Default >
        struct requires_encryption_support_t< bluetoe::service< Options... >, Default > {
            static bool constexpr default_val = encryption_default< Default, Options... >::maybe;
 
            static bool constexpr value =
                requires_encryption_support_t<
                    typename bluetoe::service< Options... >::characteristics,
                    default_val >::value;
        };
 
        template < typename ... Options, bool Default >
        struct requires_encryption_support_t< bluetoe::characteristic< Options... >, Default > {
            // @TODO the default for a characteristic should always be true
            static bool constexpr value = encryption_default< Default, Options... >::maybe;
        };
 
        template < typename Characteristic, typename Service, typename Server >
        struct characteristic_requires_encryption;
 
        template < typename ... CharacteristicOptions, typename ... ServiceOptions, typename ... ServerOptions >
        struct characteristic_requires_encryption<
            bluetoe::characteristic< CharacteristicOptions... >,
            bluetoe::service< ServiceOptions... >,
            bluetoe::server< ServerOptions... > >
        {
            // @TODO the default for a characteristic should always be true
            static bool constexpr server_requires_encryption  = encryption_default< false, ServerOptions... >::value;
            static bool constexpr service_requires_encryption = encryption_default< server_requires_encryption, ServiceOptions... >::value;
 
            static bool constexpr value                       = encryption_default< service_requires_encryption, CharacteristicOptions... >::value;
        };
    }
 
} // namespace bluetoe
 
#endif