bbm::concepts::backbone::control Concept Reference

A type T has valid control methods if: More...

#include <control.h>

Concept definition

template<typename T>
concept bbm::concepts::backbone::control =  requires(T a)
      {
        requires concepts::valid_trait<mask_t, T>;
        requires concepts::valid_trait<value_t, T>;
        requires concepts::valid_trait<remove_diff_t, T>;
        requires concepts::valid_trait<remove_packet_t, T>;
        requires concepts::valid_trait<index_t, T>;
 
        
        
        { cast<T>( std::declval<T>() ) } -> std::same_as<T>;
 
        
        
        { select( std::declval<mask_t<T>>(), a, a ) } -> std::convertible_to<T>;
 
 
        
        
        { lookup<T>( std::declval<std::vector<remove_packet_t<T>>>(), std::declval<size_t>(), std::declval<index_mask_t<size_t>>() ) } -> std::convertible_to<T>;  
        { lookup<T>( std::declval<std::vector<T>>(), std::declval<size_t>(), std::declval<index_mask_t<size_t>>() ) } -> std::convertible_to<T>;                   
        { lookup<T>( std::declval<std::vector<remove_packet_t<T>>>(), std::declval<index_t<T>>(), std::declval<index_mask_t<T>>() ) } -> std::convertible_to<T>;   
        { lookup<T>( std::declval<std::vector<T>>(), std::declval<index_t<T>>(), std::declval<index_mask_t<T>>() ) } -> std::convertible_to<T>;                    
        
        { lookup<T>( std::declval<std::vector<remove_packet_t<T>>>(), std::declval<size_t>() ) } -> std::convertible_to<T>;       
        { lookup<T>( std::declval<std::vector<T>>(), std::declval<size_t>()) } -> std::convertible_to<T>;                         
        { lookup<T>( std::declval<std::vector<remove_packet_t<T>>>(), std::declval<index_t<T>>() ) } -> std::convertible_to<T>;   
        { lookup<T>( std::declval<std::vector<T>>(), std::declval<index_t<T>>() ) } -> std::convertible_to<T>;                    
 
        
        
        { set( std::declval<std::vector<remove_packet_t<T>>>(), std::declval<size_t>(), std::declval<remove_packet_t<T>>(), std::declval<index_mask_t<size_t>>() ) }; 
        { set( std::declval<std::vector<T>>(), std::declval<size_t>(), std::declval<T>(), std::declval<index_mask_t<size_t>>() ) };                                   
        { set( std::declval<std::vector<remove_packet_t<T>>>(), std::declval<index_t<T>>(), std::declval<T>(), std::declval<index_mask_t<T>>() ) };                   
        { set( std::declval<std::vector<T>>(), std::declval<index_t<T>>(), std::declval<T>(), std::declval<index_mask_t<T>>() ) };                                    
 
        { set( std::declval<std::vector<remove_packet_t<T>>>(), std::declval<size_t>(), std::declval<remove_packet_t<T>>() ) }; 
        { set( std::declval<std::vector<T>>(), std::declval<size_t>(), std::declval<T>() ) };                                   
        { set( std::declval<std::vector<remove_packet_t<T>>>(), std::declval<index_t<T>>(), std::declval<T>() ) };              
        { set( std::declval<std::vector<T>>(), std::declval<index_t<T>>(), std::declval<T>() ) };                               
        
        
        
        { binary_search( std::declval<std::vector<T>>(), [](const T&) { return true; }, std::declval<index_mask_t<T>>() ) } -> std::convertible_to< index_t<T> >;
        { binary_search( std::declval<std::vector<T>>(), [](const T&) { return true; } ) } -> std::convertible_to< index_t<T> >;
        
      }

Detailed Description

A type T has valid control methods if:

• mask_t<T> is defined
• value_t<T> is defined
• remove_diff_t<T> is defined
• index_t<T> is defined
• cast<NewType>(oldType) cast oldType to newType
• select(Mask, T, T) returns a type T based on the mask.
• lookup<T>(container, index_t, index_mask_t) returns a type T; testing on std::vector as container
• set(container, index_t, T, index_mask_t) set a value in a container taking; similar to lookup handles packet data
• binary_search(container, predicate, index_mask_t) returns the index of the first element in container for which predicate is false.