Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123]

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