Iterator

Abstract: Preface. Acknowledgments. Making the Most of This Book. 1. Introduction. Getting Started. So What's a Metaprogram? Metaprogramming in the Host Language. Metaprogramming in C++. Why Metaprogramming? When Metaprogramming? Why a Metaprogramming Library? 2. Traits and Type Manipulation. Type Associations. Metafunctions. Numerical Metafunctions. Making Choices at Compile Time. A Brief Tour of the Boost Type Traits Library. Nullary Metafunctions. Metafunction Definition. History. Details. Exercises. 3. A Deeper Look at Metafunctions. Dimensional Analysis. Higher-Order Metafunctions. Handling Placeholders. More Lambda Capabilities. Lambda Details. Details. Exercises. 4. Integral Type Wrappers and Operations. Boolean Wrappers and Operations. Integer Wrappers and Operations. Exercises. 5. Sequences and Iterators. Concepts. Sequences and Algorithms. Iterators. Iterator Concepts. Sequence Concepts. Sequence Equality. Intrinsic Sequence Operations. Sequence Classes. Integral Sequence Wrappers. Sequence Derivation. Writing Your Own Sequence. Details. Exercises. 6. Algorithms. Algorithms, Idioms, Reuse, and Abstraction. Algorithms in the MPL. Inserters. Fundamental Sequence Algorithms. Querying Algorithms. Sequence Building Algorithms. Writing Your Own Algorithms. Details. Exercises. 7. Views and Iterator Adaptors. A Few Examples. View Concept. Iterator Adaptors. Writing Your Own View. History. Exercises. 8. Diagnostics. Debugging the Error Novel. Using Tools for Diagnostic Analysis. Intentional Diagnostic Generation. History. Details. Exercises. 9. Crossing the Compile-Time/Runtime Boundary. for each. Implementation Selection. Object Generators. Structure Selection. Class Composition. (Member) Function Pointers as Template Arguments. Type Erasure. The Curiously Recurring Template Pattern. Explicitly Managing the Overload Set. The "sizeof Trick". Summary. Exercises. 10. Domain-Specific Embedded Languages. A Little Language. Goes a Long Way. DSLs, Inside Out. C++ as the Host Language. Blitz++ and Expression Templates. General-Purpose DSELs. The Boost Spirit Library. Summary. Exercises. 11. A DSEL DesignWalkthrough. Finite State Machines. Framework Design Goals. Framework Interface Basics. Choosing a DSL. Implementation. Analysis. Language Directions. Exercises. Appendix A. An Introduction to Preprocessor Metaprogramming. Motivation. Fundamental Abstractions of the Preprocessor. Preprocessor Library Structure. Preprocessor Library Abstractions. Exercise. Appendix B. The typename and template Keywords. The Issue. The Rules. Appendix C. Compile-Time Performance. The Computational Model. Managing Compilation Time. The Tests. Appendix D. MPL Portability Summary. Bibliography. Index.

Abstract: Preface. I. INTRODUCTION TO GENERIC PROGRAMMING. 1. A Tour of the STL. A Simple Example. Summary. 2. Algorithms and Ranges. Linear Search. Linear Search in C. Ranges. Linear Search in C++. Concepts and Modeling. Iterators. Input Iterators. Output Iterators. Forward Iterators. Bidirectional Iterators. Random Access Iterators. Refinement. Summary. 3. More about Iterators. Iterator Traits and Associated Types. Value Types. Difference Type. Reference and Pointer Types. Dispatching Algorithms and Iterator Tags. Putting It All Together. Iterator Traits without iterator_traits. Defining New Components. Iterator Adaptors. Advice for Defining an Iterator. Advice for Defining an Algorithm. Summary. 4. Function Objects. Generalizing Linear Search. Function Object Concepts. Unary and Binary Function Objects. Predicates and Binary Predicates. Associated Types. Function Object Adaptors. Predefined Function Objects. Summary. 5. Containers. A Simple Container. An Array Class. How It Works. Finishing Touches. Container Concepts. Containment of Elements. Iterators. The Hierarchy of Containers. The Trivial Container. Variable Size Container Concepts. Sequences. Associative Containers. Allocators. Summary. Which Container Should You Use? Defining Your Own Container. II. REFERENCE MANUAL: STL CONCEPTS. 6. Basic Concepts. Assignable. Default Constructible. Equality Comparable. Ordering. LessThan Comparable. Strict Weakly Comparable. 7. Iterators. Trivial Iterator. Input Iterator. Output Iterator. Forward Iterator. Bidirectional Iterator. Random Access Iterator. 8. Function Objects. Basic Function Objects. Generator. Unary Function. Binary Function. Adaptable Function Objects. Adaptable Generator. Adaptable Unary Function. Adaptable Binary Function. Predicates. Predicate. Binary Predicate. Adaptable Predicate. Adaptable Binary Predicate. Strict Weak Ordering. Specialized Concepts. Random Number Generator. Hash Function. 9. Containers. General Container Concepts. Container. Forward Container. Reversible Container. Random Access Container. Sequences. Sequence. Front Insertion Sequence. Back Insertion Sequence. Associative Containers. Associative Container. Unique Associative Container. Multiple Associative Container. Simple Associative Container. Pair Associative Container. Sorted Associative Container. Hashed Associative Container. Allocator. III. REFERENCED MANUAL: ALGORITHMS AND CLASSES. 10. Basic Components. pair. Iterator Primitives. iterator_traits. Iterator Tag Classes. distance. advance. Iterator Base Class. allocator. Memory Management Primitives. construct. destroy. uninitialized_copy. uninitialized_fill. uninitialized_fill_n. Temporary Buffers. get_temporary_buffer. return_temporary_buffer. 11. Nonmutating Algorithms. Linear Search. find. find_if. adjacent_find. find_first_of. Subsequence Matching. search. find_end. search_n. Counting Elements. count. count_if. for_each. Comparing Two Ranges. equal. mismatch. lexicographical_compare. Minimum and Maximum. min. max. min_element. max_element. 12. Basic Mutating Algorithms. Copying Ranges. copy. copy_backward. Swapping Elements. swap. iter_swap. swap_ranges. transform. Replacing Elements. replace. replace_if. replace_copy. replace_copy_if. Filling Ranges. fill. fill_n. generate. generate_n. Removing Elements. remove. remove_if. remove_copy. remove_copy_if. unique. unique_copy. Permuting Algorithms. reverse. reverse_copy. rotate. rotate_copy. next_permutation. prev_permutation. Partitions. partition. stable_partition. Random Shuffling and Sampling. random_shuffle. random_sample. random_sample_n. Generalized Numeric Algorithms. accumulate. inner_product. partial_sum. adjacent_difference. 13. Sorting and Searching. Sorting Ranges. sort. stable_sort. partial_sort. partial_sort_copy. nth_element. is_sorted. Operations on Sorted Ranges. Binary Search. Merging Two Sorted Ranges. Set Operations on Sorted Ranges. Heap Operations. make_heap. push_heap. pop_heap. sort_heap. is_heap. 14. Iterator Classes. Insert Iterators. front_insert_iterator. back_insert_iterator. insert_iterator. Stream Iterators. istream_iterator. ostream_iterator. istreambuf_iterator. ostreambuf_iterator. reverse_iterator. raw_storage_iterator. 15. Function Object Classes. Function Object Base Classes. unary_function. binary_function. Arithmetic Operations. plus. minus. multiplies. divides. modulus. negate. Comparisons. equal_to. not_equal_to. less. greater. less_equal. greater_equal. Logical Operations. logical_and. logical_or. logical_not. Identity and Projection. identity. project1st. project2nd. select1st. select2nd. Specialized Function Objects. hash. subtractive_rng. Member Function Adaptors. mem_fun_t. mem_fun_ref_t. mem_fun1_t. mem_fun1_ref_t. const_mem_fun_t. const_mem_fun_ref_t. const_mem_fun1_t. const_mem_fun1_ref_t. Other Adaptors. binder1st. binder2nd. pointer_to_unary_function. pointer_to_binary_function. unary_negate. binary_negate. unary_compose. binary_compose. 16. Container Classes. Sequences. vector. list. slist. deque. Associative Containers. set. map. multiset. multimap. hash_set. hash_map. hash_multiset. hash_multimap. Container Adaptors. stack. queue. priority_queue. Appendix A. Portability and Standardization. Language Changes. The Template Compilation Model. Default Template Parameters. Member Templates. Partial Specialization. New Keywords. Library Changes. Allocators. Container Adaptors. Minor Library Changes. Naming and Packaging. Bibliography. Index. 0201309564T04062001

Abstract: A computer system comprises a plurality of nodes interconnected by point-to-point links and forms a serial bus. Upon system initialization, the bus is scanned and device-specific identification information is retrieved from command and status configuration ROMs associated with each of the plurality of nodes. In one embodiment, a search routine is used to retrieve the device specific information. The search routine begins with the definition of an iterator which is used as a place holder during the search. A simple search begins at the root directory of a hierarchical tree data structure and continues until all directories within the tree have been searched. In more complex embodiments, search relationships (i.e., direction) parameters are defined. Search criteria such as node spec -- ID and software version numbers are specified and the search is commenced. The search continues until all matching device specific information entries have been returned. The device specific information can be used to load and configure associated drivers for nodes.

Abstract: The dynamic frames approach has proven to be a powerful formalism for specifying and verifying object-oriented programs. However, it requires writing and checking many frame annotations. In this paper, we propose a variant of the dynamic frames approach that eliminates the need to explicitly write and check frame annotations. Reminiscent of separation logic's frame rule, programmers write access assertions inside pre- and postconditions instead of writing frame annotations. From the precondition, one can then infer an upper bound on the set of locations writable or readable by the corresponding method. We implemented our approach in a tool, and used it to automatically verify several challenging programs, including subject-observer, iterator and linked list.