Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12345]

Hg::And< T, U >	Takes the logical and of the two input types. The types passed in must have a static boolean value named "value"
Hg::And< Or< std::is_base_of< array_trait, T >, is_std_array< T > >, Not< std::is_base_of< vector_trait, T > > >
Hg::And< Or< std::is_base_of< vector_trait, T >, is_std_vector< T > >, Not< std::is_base_of< array_trait, T > > >
Hg::detail::array_size< Hg::BitFieldArray< T, N > >	Extracts the array extent from a std::array definition
Hg::detail::array_size< std::array< T, N > >	Extracts the array extent from a std::array definition
Hg::at< SeqT, IdxT >	Returns the value of the item at the specified index
Hg::at< MT, 0 >	Specialization that handles an MT sequence
Hg::at< MT, IdxT >	Specialization that handles an MT sequence
Hg::at< SeqT, 0 >	Terminating case that returns the value at the specified index.
Hg::back< MT >	Specialization for an MT TypeList
Hg::back< TypeList< TMP_ARRAY_32(T)> >	This allows the last type of the list to be returned
Hg::basic_msg< MsgT, StorageT >	An object that defines and manages access to a formatted message buffer
Hg::basic_msg< T, BufferedStaticStoragePolicy >
Hg::BitField< OwnerT, TagT, OffsetT, CountT, T >	Represents a single entry for a bit field type definition
Pb::conditional< Predicate, TrueType, FalseType >	Provides an implementation of a compile-time conditional when the local library does not support it
Pb::conditional< false, TrueType, FalseType >	Specialization for the false condition of the conditional
Hg::container_trait	A container_trait describes any type that is not a fundamental type or bitfield. These types facilitate more complex data structures
Hg::nested_trait	A nested type indicates that the data that is contained within, possibly requires an internal inspection to facilitate correct behavior
Hg::sequence_trait	Sequence types are a class of types that contain more than one element of the same type in series
Hg::array_trait	A sequence type that has a fixed size
Hg::BitFieldArray< T, N >	Represents a set of fields that provide homogeneous bit-field access to each of the data values
Hg::opaque_array_trait	Indicates the format of the array data is undefined, opaque
Hg::opaque_trait	Indicates the fields format is undefined and will be determined by context
Hg::opaque_array_trait	Indicates the format of the array data is undefined, opaque
Hg::opaque_vector_trait	Indicates the format of the vector data is undefined, opaque
Hg::vector_trait	A sequence type that represents a dynamically sized field
Hg::BitFieldVector< T, A >	Represents a set of fields that provide homogeneous bit-field access to each of the data values
Hg::opaque_vector_trait	Indicates the format of the vector data is undefined, opaque
Hg::TypeList< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31 >	A template-type list that is composed from a collection of types
Hg::contains< SeqT, ValueT >	Searches the integer_sequence and indicates of the specified value is found
Hg::detail::DeclareTypeSequence< T, ValueTraitT >	ValueTraitT The trait type of the value_type of the container
Hg::detail::DeduceArrayType< T, N >	A convenience meta-function to define the correct type of array for a msg field. The deduced type can be accessed through the public typedef type
Hg::detail::DeduceMsgTypeList< T, SizeT >	A convenience meta-function to define the typelist of a message object that is derived from the specified field-types
Hg::detail::DeduceProxyType< IdxT, FormatT >	A convenience meta-function to define the correct type of DataProxy holder. The constructed type can be accessed through the public typedef type
Hg::detail::DeduceTypeAtTrait< IdxT, FormatT >	A specialization that will deduce the traits from an index in a TypeList
Hg::detail::DeduceTypeTrait< ValueT >	A convenience meta-function to define the type trait tag that is best suited for specified type. The constructed type can be accessed through the public typedef type
Hg::detail::DefineFieldType< Idx, format_t >	A meta-function that simplfies the declaration of a FieldType. Publically derive from the type member of this struct
Hg::dynamic_fields< T >	Extracts index values of the vector types in a message
Hg::dynamic_size_trait	Indicates the field or message has a dynamic size determined at run-time
Hg::vector_trait	A sequence type that represents a dynamically sized field
Hg::detail::DynamicSizeWorker< MsgT, false >	Specialization that does not request dynamic size values for non-dynamic msgs
Hg::empty_type< T >	Compares types against the MT type
Hg::EndianType< T, isSwap >	Policy class used to perform byte-order operations
Hg::EndianType< T, false >	Policy class used to perform byte-order operations
Hg::detail::field_data_t< FieldT >	Type definition that indicates the parameterized-type located at an index in a type container
Hg::detail::field_data_t< index_type >
Hg::detail::field_data_t< std::vector< SubTypeT, AllocT > >	(Dynamic-Array Specialization) Type definitions for field in type-container
Hg::detail::FieldTypes< FieldT, TraitT >	Provides the data field type definitions
Hg::Datum< IdxT, FormatT >
Hg::detail::DataProxy< array_trait, IdxT, FormatT >	A template to provide access to sequences of data fields
Hg::detail::DataProxy< vector_trait, IdxT, FormatT >	A template to provide access to sequences of data fields
Hg::detail::DataProxy< opaque_vector_trait, IdxT, FormatT >	A template to provide access to sequences of data fields
Hg::Datum< kt_idx, format_t >
Hg::detail::DataProxy< datum_trait, kt_idx, format_t >	A template to adapt all field types to the Datum assignment
Hg::detail::DataProxy< packed_trait, kt_idx, format_t >	A proxy template specialization for bitfield data types
Hg::Datum< Idx, format_t >	A type-wrapper that provides transparent access to a range of memory in a message buffer as if it were the specified type itself
Hg::detail::FieldTypes< FieldT, nested_trait >	Nested Specialization for the index and data field type definitions
Hg::detail::FieldTypes< FieldT, packed_trait >	Packed Bits Specialization for the index and data field type definitions
Hg::find< SeqT, ValueT >	Searches the integer_sequence for a value and returns the position. If the value is not found, Hg::npos is returned
Hg::find< MT, ValueT >	Searches the integer_sequence for a value and returns the position. If the value is not found, Hg::npos is returned
Hg::detail::ForEachTypeHelper< CurIndex, EndIndex, ContainerT, Function >	This parameterized construct is used to iterate through each type in the specified type container
Hg::front< MT >	Specialization for an MT Type Container
Hg::front< TypeList< TMP_ARRAY_32(T)> >	This allows the first type of the list to be returned
Hg::GetTail< SeqT >	Returns the Tail of an Integral Sequence. This is similar to PopFront, however, as soon as a 0 is encountered, MT will be returned, rather than the remainder of the list
Hg::GetTail< MT >	Specialization of GetTail for the MT node type
Hg::has_dynamic< T >	Template to determine if a container has any dynamically sized entry types
Hg::detail::has_format_type< T >	Detect if the specified type has a type member called 'format_type'
Hg::HostByteOrderT< E >	Byte-order management policy for network data transfers
Hg::instance_of< T >	This construct provides mechanism to declare and initialize compile-time global constants
Hg::integer_sequence< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31 >	A parameterized type that is a sequence of integer values
Hg::is_opaque< T >	Detect a sequence type that uses an unsigned char (byte_t)
Hg::is_opaque< std::array< byte_t, N > >	Detect a std::array opaque type. N is the number of entries
Hg::is_opaque< std::vector< byte_t, A > >	Detect a std::vector opaque type. A is the allocator
Hg::is_std_array< T >	Detect a std::array type. This is the default false case
Hg::is_std_array< std::array< T, N > >	Detect a std::array type. This version identifies the std::array
Hg::is_std_vector< T >	Detect a std::vector type. This is the default false case
Hg::is_std_vector< std::vector< T, A > >	Detect a std::vector type. This version identifies the std::vector. T is the type the vector contains, A is the allocator
Hg::IsTailEmpty< SeqT >	Compares the tail-type of the sequence and indicates if the type is empty
Hg::IsTailEmpty< MT >	Specialization for an MT type sequence.
Hg::length< ContainerT >	Count the number of elements in the specified type container
Hg::make_Hg_type_list< T >	Creates a type list suitable for processing within Hg messages
Hg::Message< MsgT, StorageT >	An object that defines and manages access to a formatted message buffer
Hg::message_size_trait< T >	Indicates the type size the specified message is, static or dynamic
Hg::msg_size< HgMsgT, has_dynamic >	Reports the number of bytes this message object occupies. This instance of size calculates the size for dynamically sized messages
Hg::msg_size< T, false >	Specialization returns the size of a fixed size message
Hg::msg_view< MsgT, ByteOrderT >	The MsgView object to manage structured access over an opaque buffer
Hg::msg_view_const_iterator< T >	Iterator for nonmutable msg_view
Hg::msg_view_iterator< T >	Iterator for a mutable msg_view
Hg::MsgBuffer< StorageT >	MsgBuffer Template Definition. This abstracts the behavior of the buffer with respect to the Byte-Order of the message
Hg::MsgBuffer< BufferedStaticStoragePolicy >	(Static) MsgBuffer Template Definition. This class is a specialization of the template MsgBuffer, and uses a static_storage_policy
Hg::MsgBuffer< storage_type >
Hg::MT	A type to represent an MT type for defining type lists and type arrays
Hg::NetByteOrderT< E >	Byte-order management policy for network data transfers
Hg::Not< T >	Takes the logical not of the type. The type passed in must have a static boolean value named "value"
Hg::OffsetOf< Index, ContainerT >	Calculate the pointer offset in bytes for the specified type
Hg::OffsetOf< 0, ContainerT >	The item at index 0 will always have an offset of 0
Hg::one_or_zero< Predicate >	Casts a static const boolean to an int of one or a zero
Hg::one_or_zero< false >	Specialization for the false condition of the bool selector
Hg::opaque_value< T >	Detect if the current value type is opaque
Hg::Or< T, U >	Takes the logical or of the input types. The types passed in must have a static boolean value named "value"
Hg::pop_front< TypeList< TPop, TMP_ARRAY_31(T)> >	This allows the first type of the list to be removed, and the remainder of the list will become the type typedef
Hg::pop_front< TypeNode< T1, T2 > >	Specialization for a TypeNode
tmp::math::pow< T, var, exp >	Static calculation of power function
tmp::math::pow< T, var, 0 >	Static calculation of power function
tmp::math::pow< T, var, 1 >	Static calculation of power function
Hg::push_back< TypeList< TMP_ARRAY_32(T)>, T >	This allows the a new type to be pushed at the back of the list. The new list will become the typedef of the pushed type and the existing type list
Hg::push_front< MT, T >	Specialization for an MT TypeList: results with type T and empty
Hg::push_front< TypeList< TMP_ARRAY_32(T)>, T >	This allows the a new type to be pushed at the front of the list. The new list will become the typedef of the pushed type and the existing type list
Hg::push_front< TypeNode< T1, T2 >, T >	Specialization for a TypeNode: TypeList
Hg::reverse_nodes< ToT, FromT >	Reverses the order the nodes in an integral_node list
Hg::reverse_nodes< MT, SeqT::type >
Hg::reverse< SeqT >	Reverses the order the values in an integral_sequence
Hg::reverse_nodes< ToT, MT >	A terminating case for reversal of an integral_node list
Hg::SizeAt< index, ContainerT >	Calculate the size in bytes for the specified type
Hg::SizeOf< T >	Template to determine the size of a type or type container
Hg::detail::SizeOfVector< T, A, TypeTraitT >	Determines the number of bytes required to serialize a vector
Hg::detail::SizeOfVector< T, A, nested_trait >	Determines the number of bytes required to serialize a vector. This version handles a vector with sub-messages
Hg::detail::SizeOfVector< T, A, vector_trait >	Determines the number of bytes required to serialize a vector. This version handles a vector with variable-length types
Hg::static_size_trait	Indicates the field or message has a fixed static size at compile-time
Hg::array_trait	A sequence type that has a fixed size
Hg::fundamental_trait	Fundamental_trait identifies fundamental integral types
Hg::packed_trait	Packed_trait identifies fundamental integral types, that automatically perform bit-shift and mask operations to simulate bit-fields
Hg::StaticStoragePolicy< IsBufferedT >	Storage Policy implementation for fixed-size memory buffers
Hg::StoragePolicy< IsBufferedT >	Storage Policy implementation for contiguous memory buffers
Hg::TailValue< SeqT >	Safely extracts the last value in an integral sequence
Hg::TailValue< MT >	Specialization to TailValue for the MT type node
Hg::type_check< T >	Static Assertion Base Template to verify type constraints for an object
Hg::type_check< type_container< ContainerT >::value >
Hg::ContainerSize< ContainerT >	Calculates the static size of the container passed in. This value is equivalent to the offset of the "end" item in the container
Hg::TypeAt< Index, ContainerT, ErrorT >	Return the type at the specified array index
Hg::TypeNode< H, T >	A fundamental type used for template meta-programming type containers
Hg::TypeNode< H, MT >	A terminator for TypeNode chains
Hg::value_if< predicate, T, trueValue, falseValue >	This construct provides the compile-time equivalent of the ternary operator ?: for value selection
Hg::value_if< false, T, trueValue, falseValue >	Specialization for the false condition of the value selector
Hg::value_if< vector_value< front< T >::type >::value, bool, true, has_dynamic< pop_front< T >::type >::value >
Hg::yes_t< T >	Affirmative Type for use in SFINAE selection templates