Class List

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

[detail level 1234]

►Nanonymous_namespace{chapter-1.cpp}
Ctest_result	Container for test input and output
►Nanonymous_namespace{chapter-2.cpp}
CTestA
CTestB
►Nboost	Exists to inject functionality into the Boost namespace
►Nmpl	Exists to inject functionality into the Boost MPL namespace
Cadvance< chapter5::tiny_iterator< Tiny, Pos >, N >	Iterator advance is simple numerical addition
Cadvance< chapter7::zip_iterator< IteratorSeq, random_access_iterator_tag >, N >	Creates a sequence from the result of boost::mpl::advance
►Cat_impl< chapter5::tiny_tag >	Forward to tiny_at for O(1) access
Capply
►Cat_impl< chapter7::zip_view_tag >	Create a sequence from the result of boost::mpl::at
Capply
Capply< chapter7::zip_view< S >, N >
Capply_impl
Capply_impl< S, random_access_iterator_tag, N >
►Cbegin_impl< chapter5::tiny_tag >	Initialize the iterator with a position of 0
Capply
►Cbegin_impl< chapter7::permutation_view_tag >	Load an iterator with the beginning to both sequences
Capply
Capply< chapter7::permutation_view< Indices, Sequence > >
►Cbegin_impl< exercise_5_10::inorder_view_tag >	The begin algorithm needs to traverse to the leftmost element, creating iterators along the way
Capply	Start here. The root's parent is also the end of the sequence
Capply_on_iterator	For the leaf, we've reached the beginning. Set visit count to 1
Capply_on_iterator< chapter5::tree< Cur, L, R >, Parent >	For every subtree, set the visit count to 1
Capply_on_iterator< chapter5::tree<>, Parent >	With an empty tree, begin == end
►Cbegin_impl< exercise_5_6::dimensions_tag >	Just wrap the sequence in an iterator
Capply
►Cbegin_impl< exercise_5_7::dimensions_b_tag >	Wrap an iterator around the front of the sequence
Capply
►Cbegin_impl< exercise_5_8::fibonacci_series_tag >	Start with 1 in the "last" position so we don't waste time with 0+0
Capply
►Cbegin_impl< exercise_6_1::binary_tag >	Simply return the binary type as is
Capply
Capply< exercise_6_1::binary< N > >
►Cclear_impl< chapter5::tiny_tag >	Simply return a new, empty tiny sequence
Capply
Cderef< chapter5::tiny_iterator< Tiny, Pos > >	Dereferencing the iterator is the first time we actually examine tiny
Cderef< chapter7::permutation_iterator< CurIdxIter, SeqBegin > >	Advance the prescribed amount, and return the element found
Cderef< exercise_5_10::inorder_view_iterator< chapter5::tree< Cur, L, R >, Parent, VisitCount > >	Grab the first value from the subtree contained in the iterator
Cderef< exercise_5_10::inorder_view_iterator< Cur, Parent, VisitCount > >	This specialization is only for leaf nodes. Grab it directly from the iterator
Cderef< exercise_5_6::dimensions_iterator< S > >	The iterator just contains a subset of the underlying sequence
Cderef< exercise_5_7::dimensions_b_iterator< S > >	The sequence IS its identity, really
Cderef< exercise_5_8::fibonacci_series_iterator< N, LastN > >	Give us N
Cderef< exercise_6_1::binary< N > >	Algorithms require the full binary type for computations
Cderef< exercise_7_7::reverse_iterator< ForwardIt > >	Undo double-indirection of the reverse_iterator
Cdistance< chapter5::tiny_iterator< Tiny, Pos1 >, chapter5::tiny_iterator< Tiny, Pos2 > >	Our iterators deal in integers, so simply subtract the two
►Cend_impl< chapter5::tiny_tag >	Finding the end requires tiny_size, which is O(1) complexity
Capply
►Cend_impl< chapter5::tree_tag >	Pass along our special "end" type
Capply
►Cend_impl< chapter7::permutation_view_tag >	An iterator with the end of the indices sequence and the beginning of the other
Capply
►Cend_impl< exercise_5_10::inorder_view_tag >	Simply returns inorder_view_iterator_end
Capply
►Cend_impl< exercise_5_6::dimensions_tag >	The end is a boost::mpl::void_ type
Capply
►Cend_impl< exercise_5_7::dimensions_b_tag >	Wrap an iterator around boost::mpl::void_
Capply
►Cend_impl< exercise_6_1::binary_tag >	When we have a value of 0, there are no more digits
Capply
Capply< exercise_6_1::binary< N > >
►Cerase_impl< chapter5::tiny_tag >	Use our tiny_erase to form the new sequence in O(1) time
Capply
Capply< S, chapter5::tiny_iterator< S, First >, chapter5::tiny_iterator< S, Last > >
Capply< S, First, mpl_::na >
►Cinsert_impl< chapter5::tiny_tag >	Using tiny_insert is O(1) time
Capply
Capply< Tiny, chapter5::tiny_iterator< Tiny, Pos >, T >
Cnext< chapter5::tiny_iterator< Tiny, Pos > >	Iterator next simply increments our numerical position info
Cnext< chapter7::permutation_iterator< CurIdxIter, SeqBegin > >	Advance only the index iterator
Cnext< chapter7::zip_iterator< IteratorSeq, Category > >	Creates a sequence of the next element for each (sub-)iterator
Cnext< exercise_5_10::inorder_view_iterator< chapter5::tree< Cur, L, R >, Parent, 0 > >	We've never visited this item, so we should start by going left
Cnext< exercise_5_10::inorder_view_iterator< chapter5::tree< Cur, L, R >, Parent, 1 > >	Seen this node once, so we should present it as the "next" item
Cnext< exercise_5_10::inorder_view_iterator< chapter5::tree< Cur, L, R >, Parent, 2 > >	Visited this node twice already, so the only place to go is right
Cnext< exercise_5_10::inorder_view_iterator< chapter5::tree< Cur, L, R >, Parent, 3 > >	Go back up the tree. If we reach "end" as the parent, we've fully traversed the tree
Cnext< exercise_5_10::inorder_view_iterator< chapter5::tree< Cur, L, R >, Parent, VisitCount > >	This is an error – Visit count must not be [0,3]
Cnext< exercise_5_10::inorder_view_iterator< chapter5::tree< Cur, L, void_ >, Parent, 2 > >	Same as above, but R node is empty, so go back up..
Cnext< exercise_5_10::inorder_view_iterator< chapter5::tree< Cur, void_, R >, Parent, 0 > >	Same as above, but L node is empty, so go back up..
Cnext< exercise_5_10::inorder_view_iterator< Cur, Parent, 0 > >	Visiting a leaf for the first time: present it as the "next" item
Cnext< exercise_5_10::inorder_view_iterator< Cur, Parent, VisitCount > >	In-order traversal
Cnext< exercise_5_6::dimensions_iterator< S > >	The sequence itself defines "next"
Cnext< exercise_5_7::dimensions_b_iterator< S > >	Next is defined by the sequence
Cnext< exercise_5_8::fibonacci_series_iterator< 1134903170, 701408733 > >	Establish an end (based on 32-bit signed int size)
Cnext< exercise_5_8::fibonacci_series_iterator< N, LastN > >	Make the new N the sum of both numbers; save the old N
Cnext< exercise_6_1::binary< N > >	Strip the least-significant binary digit from the number
Cnext< exercise_7_7::reverse_iterator< ForwardIt > >	Turn next into prior
►Cpop_back_impl< chapter5::tiny_tag >	This forwards operation to the erase metafunction
Capply
►Cpop_back_impl< exercise_5_7::dimensions_b_tag >	Popping from the back just means drop one array dimension
Capply
Capply< exercise_5_7::dimensions_b< T[N]> >
►Cpop_front_impl< chapter5::tiny_tag >	This forwards operation to the erase metafunction
Capply
Cprior< chapter5::tiny_iterator< Tiny, Pos > >	Iterator prior simply decrements our numerical position info
Cprior< chapter7::permutation_iterator< CurIdxIter, SeqBegin > >	Move only the index iterator
Cprior< chapter7::zip_iterator< IteratorSeq, Category > >	Specialize prior, but only for bidirection or better iterator types
Cprior< exercise_5_7::dimensions_b_iterator< S > >	Prev is defined by the sequence
Cprior< exercise_5_8::fibonacci_series_iterator< 0, 1 > >	Don't go before 0..
Cprior< exercise_5_8::fibonacci_series_iterator< 1, 1 > >	Special case because we chose an irregular "begin" iterator value
Cprior< exercise_5_8::fibonacci_series_iterator< N, LastN > >	Backward iteration is computable easily
Cprior< exercise_7_7::reverse_iterator< ForwardIt > >	Turn prior into next
►Cpush_back_impl< chapter5::tiny_tag >	If we can insert, use that, otherwise, use tiny_push_back
Capply
►Cpush_back_impl< chapter5::tree_tag >	Alter a tree structure by adding an element with sorted placement
Capply	The basic implementation makes a tree, assuming that the existing sequence (S) is a leaf node
Capply< chapter5::tree< Cur, L, R >, New >	Assuming that we're operating on a (sub)tree, recreate new trees with the added element
Capply< chapter5::tree<>, New >	Initial case
Capply< void_, New >	An "extra" step that terminates recursion if we're simply adding to a (sub)tree's open space
►Cpush_back_impl< exercise_5_7::dimensions_b_tag >	Just convert the input to an integer, and add to the array dimension
Capply	Just convert whatever we get into a value..
Capply_num
Capply_num< exercise_5_7::dimensions_b< T >, N >
►Cpush_front_impl< chapter5::tiny_tag >	Front insertion is straightforward. Assert we're not already full
Capply
Crbegin	Grab a reverse_iterator from the a sequence directly
Crend	Acquire a reverse_iterator at the end of a sequence
►Csize_impl< chapter5::tiny_tag >	Forward the MPL size lambda over to tiny_size
Capply
►Nchapter1	Solutions for Chapter 1
Cbinary	Prepend higher bits to lowest bit
Cbinary< 0 >	Recursion termination
►Nchapter3	Provide utilities availble to all Chapter 3 solutions
Ctwice	Apply a metafunction to its own result
►Nchapter4	Provide utilities availble to all Chapter 4 solutions
Cundefined_false	If the template parameter is false, template instantiation is an error
Cundefined_false< true >	Define this metafunction if specialized to true
Cundefined_true	If the template parameter is true, template instantiation is an error
Cundefined_true< false >	Define this metafunction if specialized to false
►Nchapter5	Provide utilities availble to all Chapter 5 solutions
Cnone	Quickly define a NULL type
Ctiny	A small, random-access sequence type
Ctiny_at	Provide O(1) access to sequences tagged with tiny_tag
Ctiny_at< Tiny, 0 >
Ctiny_at< Tiny, 1 >
Ctiny_at< Tiny, 2 >
Ctiny_erase	Erase a range of elements from a tiny sequence
Ctiny_erase< S, 0, 1 >
Ctiny_erase< S, 0, 2 >
Ctiny_erase< S, 0, 3 >
Ctiny_erase< S, 1, 2 >
Ctiny_erase< S, 1, 3 >
Ctiny_erase< S, 2, 3 >
Ctiny_insert	Insert into the tiny sequence
Ctiny_insert< Tiny, T, 0 >
Ctiny_insert< Tiny, T, 1 >
Ctiny_insert< Tiny, T, 2 >
Ctiny_iterator	Define an iterator for use with the tiny sequence type
Ctiny_push_back	Add an element to the end of the tiny sequence
Ctiny_push_back< Tiny, T, 0 >
Ctiny_push_back< Tiny, T, 1 >
Ctiny_push_back< Tiny, T, 2 >
Ctiny_size	Used to improve end metafunction performance, etc
Ctiny_size< none, none, none >
Ctiny_size< T0, none, none >
Ctiny_size< T0, T1, none >
Ctiny_tag	Type for tag-based implementation of algorithms below
Ctree	A basic type to represent a binary tree
Ctree_tag	Used for Boost MPL's tag-based dispatch of sequence metafunctions
►Nchapter7	Provide utilities availble to all Chapter 7 solutions
Cextract_iterator_category	A simple metafunction to get the iterator category from the first iterator in a sequence
Cleast_refined_iterator_category	Assuming a sequence of sequences, find the least refined category of all subsequences
Cpermutation_iterator	Iterates across a seqence in an order defined by another sequence
Cpermutation_view	Alter the order sequence traversal using a sequence of positions
Cpermutation_view_tag	Type for tag-based implementation of algorithms below
Czip_iterator	An iterator into a sequence of sequences
Czip_view	Wraps corresponding elements across a sequence of sequences
Czip_view_tag	Type for tag-based implementation of algorithms below
►Nexercise_2_0	Encapsulate solution for Exercise 2-0
►Nno_boost	Contains a set of solutions implemented without the aid of the Boost MPL
Cadd_const_ref	This is a home-grown implementation to the problem
Cadd_const_ref< T & >	Partial specialization for when T is already a reference
Cadd_const_ref< T const >	(Paranoia) Strip off const on T const to avoid T const const&. Not required
Cadd_const_ref_impl	The default implementation adds a const& to the template type
Cadd_const_ref_impl< T, true >	Simply return the original type if we're already a reference type
►Nwith_boost	Contains a set of solutions implemented with Boost MPL
Cadd_const_ref	Boost MPL implementation
Cadd_const_ref	A unary metafunction that returns T if it is a reference type, and otherwise returns T const&
►Nexercise_2_1	Encapsulate solution for Exercise 2-1
►Ncpp20	Encapsulate solution for Exercise 2-1 (C++20)
Creplace_type	Given an arbitrary compound type, replace nested types
Creplace_type< C &, X, Y >	Descend through reference types
Creplace_type< C *, X, Y >	Descend through pointer types
Creplace_type< C[N], X, Y >	Descend through array types
Creplace_type< Cr(*)(CArgs...), X, Y >	Decend through all aspects of pointers to functions
Creplace_type_dispatch	Internal type used by replace_type
Creplace_type_dispatch< C, X, Y, false >	Recurse into replace_type
Creplace_type_dispatch< C, X, Y, true >	Replace leaf types
Creplace_type	Given an arbitrary compound type, replace nested types
Creplace_type< C &, X, Y >	Descend through reference types
Creplace_type< C *, X, Y >	Descend through pointer types
Creplace_type< C[N], X, Y >	Descend through array types
Creplace_type< Cr(*)(), X, Y >	Descent through nullary function types
Creplace_type< Cr(*)(C0), X, Y >	Descent through unary function types
Creplace_type< Cr(*)(C0, C1), X, Y >	Descent through binary function types
Creplace_type< Cr(*)(CArgs...), X, Y >	Decend through all aspects of pointers to functions
Creplace_type_dispatch	Internal type used by replace_type
Creplace_type_dispatch< C, X, Y, false >	Recurse into replace_type
Creplace_type_dispatch< C, X, Y, true >	Replace leaf types
►Nexercise_2_3	Encapsulate solution for Exercise 2-3
Ctype_descriptor
►Nexercise_2_4	Encapsulate solution for Exercise 2-4
►Ncpp20	Encapsulate solution for Exercise 2-4 (C++20)
Ctype_descriptor	Print (a limited set of) data-types
Ctype_descriptor	Print (a limited set of) data-types
►Nexercise_2_5	Encapsulate solution for Exercise 2-5
►Ncpp20	Encapsulate solution for Exercise 2-5 (C++20)
Ctype_descriptor_eng	Display data-types in English wording
Ctype_descriptor_eng	Display data-types in English wording
►Nexercise_3_0	Encapsulate solution for Exercise 3-0
Cchecked_binary	Compile-time binary to decimal number translation
Cchecked_binary< 0 >	Recursion termination
►Nexercise_3_1	Encapsulate solution for Exercise 3-1
Cex_3_1	Add 1 to all items in a sequence (w/o placeholder args)
►Cex_3_1apply	Metafunction to apply during transformation
Capply	Apply T+1
Cex_3_1b	Add 1 to all items in a sequence (w/ placeholder args)
►Nexercise_3_2	Encapsulate solution for Exercise 3-2
Cex_3_2	Given a sequence of numbers, return a sequence of their squares
►Nexercise_3_5	Encapsulate solution for Exercise 3-5
►Nsection_3_1	Modification of algorithms from Chapter 3, Section 1
Cdivide_dimensions	Divide all elements of two dimension sequences
Cmultiply_dimensions	Multiply all elements of two dimension sequences
Cquantity	A numerical quanitity with intrinsic dimensions
►Nexercise_3_6	Encapsulate solution for Exercise 3-6
►Ctwice_lambda	A lambda to perform a metafunction twice
Capply	When applied, performs the given function twice
►Nexercise_4_1	Encapsulate solution for Exercise 4-1
Clogical_and	Short-circuit logical OR evaluation of two boolean values
Clogical_and< boost::mpl::false_, E2 >	Short-circuit on a true value
Clogical_and< boost::mpl::true_, E2 >	If the first value is true, the result is whatever E2's value is
Clogical_or	Short-circuit logical OR evaluation of two boolean values
Clogical_or< boost::mpl::false_, E2 >	If the first value is false, the result is whatever E2's value is
Clogical_or< boost::mpl::true_, E2 >	Short-circuit on a true value
►Nexercise_4_2	Encapsulate solution for Exercise 4-2
Clogical_or5	Short-circuit logical OR evaluation for up to five boolean values
Clogical_or5< boost::mpl::false_, boost::mpl::false_, boost::mpl::false_, boost::mpl::false_, E5 >	If everything is a simple boost::mpl::false_ we can end recursion
Clogical_or5< boost::mpl::false_, E2, E3, E4, E5 >	Pop/Evaluate the second value, putting false_ as the last parameter
Clogical_or5< boost::mpl::true_, E2, E3, E4, E5 >	Short-circuit on a true value
►Nexercise_4_3	Encapsulate solution for Exercise 4-3
Cformula	Fix algorithm 2 in Exercise 4-3:
Cnext_if	Fix algorithm 1 in Exercise 4-3:
►Nexercise_4_4	Encapsulate solution for Exercise 4-4
Cis_data_member_pointer	Returns true if T is a pointer, but not a member function pointer
Cis_pointer_to_function	Returns true if T is a pointer to a (non-member) function type
Cis_reference_to_function_pointer	Returns true if T is a reference to a pointer to a (non-member) function!
Cis_reference_to_non_const	Returns true if T is a reference type to a constant type
►Nexercise_5_1	Encapsulate solution for Exercise 5-1
Cdouble_first_half	Double the values in the first half of the given sequence
Cdouble_first_half_impl	Represents a single iteration across the sequence
►Nexercise_5_10	Encapsulate solution for Exercise 5-10
Cinorder_view	Compels iterators to traverse the tree "in order"
Cinorder_view_iterator	Establish an iterator to contain in-order traversal of the binary tree
Cinorder_view_tag	A tag for tag-dispatched sequence metafunctions
►Nexercise_5_6	Encapsulate solution for Exercise 5-6
Cdimensions	Represent the dimensions in an array type as a sequence of numbers
Cdimensions< T[N]>	Basically a tuple where the "head" is the value, and the rest is accessed by "tail"
Cdimensions_iterator	Define a (forward-only) iterator for our dimensions sequence
Cdimensions_tag	A tag for tag-dispatched sequence metafunctions
►Nexercise_5_7	Encapsulate solution for Exercise 5-7
Cbegin_impl_traversal	Begin_impl_traversal walks the list to find the beginning
Cbegin_impl_traversal< S, boost::mpl::void_ >	We've found the beginning
Cdimensions_b	Represent the dimensions in an array type as a sequence of numbers
Cdimensions_b_impl	Implement the dimensions_b sequence
Cdimensions_b_impl< T[N], Next >	Descend through the T types, removing an array each time
Cdimensions_b_iterator	Define a bi-directional iterator for our dimensions_b sequence
Cdimensions_b_tag	A tag for tag-dispatched sequence metafunctions
►Nexercise_5_8	Encapsulate solution for Exercise 5-8
Cfibonacci_series	The Fibonacci series for use with Boost MPL sequences
Cfibonacci_series_iterator	Iterator for moving through Fibonacci series sequence
Cfibonacci_series_tag	A tag for tag-dispatched sequence metafunctions
►Nexercise_6_0	Encapsulate solution for Exercise 6-0
Cfind_smaller	Find the type with a smaller size in bytes
Cfind_smaller< no_type, T2 >	Specialize the initial case
Cno_type	Provide a type to return if the sequence is empty (no "small" type)
Creplace_with_smaller	This is our "inserter." It really just replaces instead of inserting, though
Csmallest	This is the metafunction that returns the smallest type in the sequence
►Nexercise_6_1	Encapsulate solution for Exercise 6-1
►Cbinary	Compile-time binary to decimal number translation
Capply_binary_digit	Mathematics used by accumulate is broken out for clarity..
Capply_binary_digit< T1, binary< N2 > >	Specialization so we can get direct access to the binary numebr
Cbinary_tag	A tag for tag-dispatched sequence metafunctions
►Nexercise_6_3	Encapsulate solution for Exercise 6-3
Cbinary_tree_inserter	Basically indistinguishable from from any other inserter since we have a generic insert metafunction
►Nexercise_6_4	Encapsulate solution for Exercise 6-4
Cbinary_tree_search	Perform a search on a binary tree structure
Cbinary_tree_search< boost::mpl::void_, Elem >	If we get an empty subtree, indicate that there is nothing found
Cbinary_tree_search< chapter5::tree< Cur, L, R >, Elem >	The usual binary tree logic
Ctree_end	Quick and dirty (non-iterator, I know) way to mark the end of the tree sequence..
►Nexercise_7_3	Encapsulate solution for Exercise 7-3
Crotate_view	A shifted and wrapped view onto the original sequence
►Nexercise_7_7	Encapsulate solution for Exercise 7-7
Cis_valid_reverse_category	Determines if the source iterator is suitable for reversal
Creverse_iterator	Wraps any iterator with the intent of reversing the direction of next and prior
►Ntest_4_4	Tests functionality from Exercise 4-4
Ctest_class