| Accumulate_File_Lines | This struct implements the bridge between the FileName::read_lines method and the lines_ data member of the Impl class. The lines_ data is a collection of pointers to std::string, not std::strings directly so this class performs the needed copies and dereferences to make the interface look right to FileName::read_lines |
| AddMapping | An AddMapping object exists only for the purpose of statically initializing the Impl::func map with valid entries. You declare a member function of the Impl class then you declare an object of type AddMapping to cause the function to appear in the func table. You only need to do this once, and it is the intent of addMapping's design that you do this at file scope -- not that it matters |
| BinaryParsed< IntegerType > | This class is a wrapper around a reference to an integer, which exists so that that operator>> can be specialized such that when a binary object is serialized, it will parse the stream for a binary integer instead of a decimal integer |
| HexParsed< IntegerType > | This class is a wrapper around a reference to an integer which exists so that that operator>> can be specialized such that when a Hex object is serialized, it will parse the stream for a hex integer instead of a decimal integer |
| IsIntType< T > | Wrapper around the member, value, which will be 1 if T is an integral type (including unsigned char but not regular char). For all other types, value will be 0 |
| OctalParsed< IntegerType > | This class is a wrapper around a reference to an integer which exists so that that operator>> can be specialized such that when a Octal object is serialized, it will parse the stream for a octal integer instead of a decimal integer |
| SKIPSET | An object which represents a set of characters which a Stream should ignore when parsing with operator>>. The parsed characters are discarded from the stream. At least one member of the set must appear or an error results |
| Stream | A Representation of a stream of bytes that can be parsed quickly. See its related operator >> functions. The Stream does not own the bytes, and so they must not be changed or destroyed while the parsing process is in effect |
| StreamReader< T, TypeCategory > | StreamReader is a class used to parse integers out of stream. The default implementation will not allow ANY class to compile. You must use a specialization to get the code to compile. See StreamReader specializations below. We made add specializations to StreamReader later to allow other kinds of classes to be parsable |
| StreamReader< T, 1 > | Decimal Integer StreamReader |
| StreamReader< T, 3 > | Hexadecimal Integer StreamReader |
| StreamReader< T, 5 > | Octal Integer StreamReader |
| StreamReader< T, 7 > | Binary Integer StreamReader |
| compile_stack_elt_t | |
| compile_stack_type | |
| CharCompare | |
| appChooser | |
| ascii_chart | An ascii_chart is a block of characters which contains a picture of a set of x,y pairs. The idea is that you use the plot() methods to fill the chart with spaces and stars representing data set |
| basicClassType< T > | Defines a member, value, to be one of the basicClassTypes values |
| basicClassType< void > | A type that contains enumeration value, named "value", which indicates the basic kind of data that a template parameter T refers to. This particular specialization of the template identifies the "void" type which cannot be identified by the more complex expression in the main specialization |
| caseless_compare | |
| CharCompare | < Comparator function needed for the stl search algorithm, below |
| CharSetTranslator | An object performs mappings between ASCII character set ranges. To use a CharSetTranslator, you construct it and then use either one of of the following members: |
| LhsSubrange | Information needed to describe character ranges in the left hand side of the mapping |
| compare_port_by_col_row | |
| compare_port_by_row_col | |
| CPP_Buffer_Token_Source | A source of tokens extracted from a character array |
| CPP_File_Token_Source | A source of CPP_Token's which comes from a named file |
| CPP_Stream_Token_Source | A source of CPP_Token's which comes from an istream |
| CPP_String_Token_Source | |
| CPP_Token | An object that represents a C++ lexical token. CPP_Token objects are usually obtained from token streams. See CPP_Token_Stream's for an example use |
| CPP_Token_Source | A generic representation of a stream of CPP_Token |
| CPP_Token_Stream< Iterator > | C++ token stream template (ie a source of CPP_Token objects) |
| CPP_Token_Stream_Prep | A CPP_Token_Stream, does not include preprocessor directives. Doing so would greatly complicate any grammer. Instead, preprocessor directives are handled only if desired in an out of band style. To handle preprocessor directives, derive a class from this one (CPP_Token_Stream_Prep) and implement a virtual method which will be invoked by the stream as preprocessor directives are encountered. Note that the '#' and any spaces surrounding it will not be included in the text passed to the virtual method |
| Info | |
| SymbolInfo | A description of a symbol as extracted by the cpptagdb.exe program. The description includes the type of the symbol, its full namespace name, its member name, the file and line where it is defined, and the kind of symbol it is: function, variable, namespace, etc |
| CsvViewer | A Comma Separated Values file viewer |
| cubic_spline | Cubic interpolatory spline. Derived from the example in the book Numerical Computing by Shampine and Allen. Copyright 1973. ISBN 0-8150-6 |
| info | Info stored for each x value in the sample data set |
| mouse_info | Used in mouse events to describe the position and buttons (Actually, not implemented at this time) |
| CursorWindow | Before directly using this class, you should consider reading text_windows |
| Dialog | A Dialog is a list of fields which which will be displayed in a viewport and the user can edit them. Users of a Dialog initalize the list of fields, each of which must be a Dialog::Element. They then let the user edit the fields. After editing is complete, the caller iterates over the fields to see what changed |
| Element | An input element in a Dialog. This is an abstract base class from which you can derive -- although there are some builtins (Ok,string, etc). The popup() function will handle some keys and some will be sent to the element's handle_key method. The draw() method may be invoked multiples times within the popup() function call |
| Impl | This class holds the dialog implementation data |
| visible_page | Find the dialog element with a given name |
| Ok | A dialog element that does nothing -- you typically use this as the last element of dialog so that the user has one last chance after entering data in the last real field to edit his work. It has not input semantics -- except wasting time |
| Password | Same as String, except that the user never gets to see what he has typed in |
| String | A String is a dialog element that prompts the user for a character string -- providing a default value. Normal keyboard editing keys are active. The 'tab' key has special interpretation. It completes the string under the cursor. That is, if you press the tab key, the string under the cursor is treated as a partial file name fragment and you are presented with the valid completions for your selection. If there is only one valid selection, it is chosen for you automatically |
| FileSelector | |
| input_event | An input_event is _any_ kind of input from the user, including keys, screen resizes, etc. If NoKey is the type, then the event should be ignored |
| Message | A Message object is a simpler version of a Dialog. It does not allow the user to make any selections -- it just presents the user with a scrolloing list of lines of test. When the user presses enter, the message goes away |
| Impl | Instead of burdening the include/cursorwindow file with these messy implementation details, they are encapsulated in this nested type which is not implemented in the aforenamed header |
| resize_handler | A resize_handler gets invoked if the user resizes the window. But only if you have specified the resize handler to use by calling the set_resize_handler() method. If you don't make such a call, the window size change event will be reported by the read_input() function. If you do make the setting, you will not receive any ResizeKey events. If you are using viewports, the resize_handler's job is mainly to enforce your viewport resize policy. That is, you use this function to scale the viewports after a resize. If you are not using viewports, this function's job will be to repaint the window correctly. If you are using viewports, the resizing event will automatically invoke their repaint methods after first invoking your resize_handler. See the file lib/cursorwindow.c and look for function resize_viewports() to see what a resize_handler has to do. Note that you can't use that code directly. If you are using a resize_handler of your own construction, you should maintain your own list of viewports over which can iterate |
| row_col | A pair of integers representing a row and a column |
| Selection | A Selection object is a simpler version of a Dialog. It presents the user with a list of strings of which he/she is allowed to select exactly one -- or press the escape key to abort. To use a Selection object, do the following: |
| Impl | Instead of burdening the include/cursorwindow file with these messy implementation details, they are encapsulated in this nested type which is not implemented in the aforenamed header |
| viewport | Before directly using this class, you should consider reading text_windows |
| repaint_handler | Derive from repaint_handler to implement your repaint object which will be invoked whenever there is a resize event or if some other viewport is created or deleted or activated. Your repaint handler is expected to ask for the viewports size and completely repaint this region. The cmd passed to your repaint handler is one of the cmd_constant enum values |
| Window | This class holds the real CursorWindow datastructures. It is hidden from view because its inclusion is unnecessary and because curses might be included which adds all kinds of annoying macros into your compilation stream |
| DirectoryViewer | An object of the DirectoryViewer class is passed to a ListViewer at the time of its construction so that the list viewer implements a directory viewing command interface |
| EOL_Sequence_t | |
| EtagsDB | A class that encapsulates the searching of the database created by the "etags" program. EtagsDB lets you read the database file and search it for a symbol. See "man etags" or a google search |
| EvalAnd< T, U, W, X > | Assuming that the input template parameter types are designed to contain a compile time constant member, named value, which evaluates to either true or false, construct a compile time constant in this class, also named value, which will be true if and only if all the template parameter classes are true |
| EvalOr< T, U, W, X > | Assuming that the input template parameter types are designed to contain a compile time constant member named value which evaluates to either true or false, construct a compile time constant in this class, also named value, which will be true if any of the template parameter classes is true |
| EvalTypeIf< bool, ZeroClass, OneClass > | A mechanism for selecting between either of two types based on a compile time constant expression |
| EvalTypeIf< 0, ZeroClass, OneClass > | |
| EvalTypeIf< 1, ZeroClass, OneClass > | |
| false_value_type | Type that means no. false_value_type::value == 1 |
| FileContents | An in-memory representation of a file's contents. An in memory copy of the file as returned by FileName::slurp(). If the ok() method returns true then no error occurred during the reading. However if it returns false, an explanation of the error can be obtained using 'error()' |
| FileMode | A representation of a file's mode (ie permissions and type). If the file is a symbolic link, the link bit will be 1, but the other bits will refer to file to which the link points. Note that this is the design of the FileMode class -- but also note that the FileMode class does not have way of populating itself. To obtain a FileMode object's value, call FileName::file_stat(&fileMode) |
| FileName | A file's name and handle for invoking many file system functions |
| Accum< Container > | An Accum object is a template class object whose role is to provide a generic interface for any standard sequence container to the accumulate_lines virtual interface |
| accumulate_lines | A class of functor objects whose purpose is to provide a generic interface between the read_* functions, below, and some container used to hold lines read |
| FileNameSorter | |
| is_separator | A functor that tells you if a specifed character is a path sepator. It is meant to be used as a parameter to StrTool::parse_words -- or any function needing a predicate indicating that a character is the path separator |
| Tree | A tree of file names, representing a directory hierarcy |
| FileNameComparator | |
| FileStatus | The complete description of a file's attributes |
| FileTime | A portable representation of a file's (local) time |
| fmtd< WIDTH, PRECISION, PAD, BASE, ERRCHR > | A numeric to ascii string conversion class based on snprintf. The constructor for this class constructs an object containing a char buffer holding the formatted resultant string |
| algo< bctClassType, char const *, fieldWidth, precision, lJust, padding, pad, base, errchr > | A specialization for the algo template that is creates the integer formatting algorithm used by fmtd<> below |
| algo< bctFloatType, T, fieldWidth, precision, lJust, padding, pad, base, errchr > | A specialization for the algo template that is creates the integer formatting algorithm used by fmtd<> below |
| algo< bctIntegralType, T, fieldWidth, precision, lJust, padding, pad, base, errchr > | A class which defines a member type, type, which actually implements the formatting algorithm for fmtd<> below |
| FloatFormatter< T, fieldWidth, precision, lJust, padding, pad, base, errchr > | This functor formats floats, doubles, and long doubles in the way that should be done for class fmtd<> |
| IntFormatter< T, fieldWidth, precision, lJust, padding, pad, base, errchr > | This functor formats ints, shorts, char, unsigned, long, long long, etc. in the way that should be done for class fmtd<> |
| StringFormatter< T, fieldWidth, precision, lJust, padding, pad, base, errchr > | This functor formats strings in the way that should be done for class fmtd<> |
| AnyType< T > | |
| AnyTypeBase | |
| EvalTypeIf< bool, ZeroClass, OneClass > | Define a member typedef that is either ZeroClass or OneClass based on the value of the bool. Note that effect is accomplished using specialization, not here in this base class. see below |
| EvalTypeIf< 0, ZeroClass, OneClass > | |
| EvalTypeIf< 1, ZeroClass, OneClass > | |
| IteratorReferent< Container > | Given a container as a template parameter, determine the return data type of its "iterator" -- particularly the constness thereof. Define a nested member typedef, type, which maps to the return value type of |
| IteratorReferent< const Container[N]> | |
| IteratorReferent< Container[N]> | |
| iteratorReturnsConst< Container > | Define a nested constant, value, which is true if the specified Container type has an iterator which returns a const version of Container::value_type. Set for example has no non-const iterator. If std::set is the Container passed in then the value will be true. It will be false for most normal containers |
| IteratorWrapper< T > | |
| IteratorWrapper< T * > | A wrapper around a pointer, which is an iterator to a normal C++ array |
| FTP | This class defines an interface to the ftp program. Basically it provides filesystem like queries and operations that operate on a remote machine using the ftp program to do the work |
| FileInfo | A FileInfo is a combination of the name of a file and its FileStatus |
| FTPviewer | An FTPviewer is a Viewer meant for displaying and editing files and directories exported by an ftp server. It a large extent, it looks and feels like a directory viewer -- except that the files and directories being displayed are on a remote system. The ftp viewer also maintains a reference to a 'current directory' on the local machine where files on the remote machine will be stored when you 'get' a file. Analogously, files in the local directory may be 'put' to the remote system |
| Impl | |
| hash_list< Key, Value, Hash > | A hash_list<Key,Value,Hash> is a list of pair<Key,Value> which can be quickly searched for a given K. Most operations are of fixed cost. Memory consumed is approximately 3 * sizeof(void*) + sizeof(K) + sizeof(V). The primary storage mechanism is a list of Key,Value,bucket_next objects. This gives O(1) insert, erase, iteration, etc. The 'bucket_next' member kept with the Key,Value pair lets us have a fixed time cost to find a given K -- there is a hash table containing all Keys -- this table's buckets thread through the individual objects stored in the linked list |
| index_helper | When using a non-const hash_list, and invoking the array index operator, [], you get back an index_helper object rather than a reference to the Value object you would expect to be gettting. This is because the behaviour of the array index operation requires that if the object isn't there already that it be inserted. You could insert a 'default' Value object into the container, only to have it deleted if you are writing code like this: |
| value_type | The objects actually stored in a hash_list are 'value_type' objects. The member, data_, contains the pair<Key,Value> that is the user data provided by an insert operation |
| Hasher< T > | Hasher<T> is a class object which pretends to be a function which returns a semi-unique value for objects you pass it. That is, it returns you an integer value which can be used as a hash code in various algoriths. To use a Hasher, you declare a Hasher object, then execute it like a function in order to get a hash value. For example: |
| Hasher< double > | Compute a hash value for a double precesion floating point number |
| Hasher< float > | Compute a hash value for a single precesion floating point number |
| Hasher< std::string > | String specific hash algorithm |
| Is_Path_Separator | |
| Is_Path_Space | A functor that tells you if a character is counted as a pathname separator |
| is_pathsep | |
| isArithmeticType< T > | IsArithmeticType<T>::value is a compile time constant that is only true if T can be used in normal arithmetic operations |
| isArithmeticType< const void > | IsArithmeticType<void> is a variant of isArithmeticType that does not define a member named value and thus will will not compile correctly if an arithmetic type is required |
| isArithmeticType< void > | IsArithmeticType<void> is a variant of isArithmeticType that does not define a member named value and thus will will not compile correctly if an arithmetic type is required |
| isArrayType< T > | IsArrayType<T>::value is true if T is an array |
| isArrayType< T const [N]> | IsArrayType<T>::value is true if T is an array |
| isArrayType< T[N]> | IsArrayType<T>::value is true if T is an array |
| isClassType< Type > | IsClassType<T>::value is a compile time constant that is true only if T is a class, or struct |
| isConstType< T > | See isConstType<T>::value for a const expression telling you whether or not T is a "const" type or not |
| isConstType< const T > | |
| isConvertibleType< From, To > | IsConvertible<From,To>::value is a compile time constant which is true if type From can be converted into type To without special syntax |
| isConvertibleType< const double, int > | |
| isConvertibleType< const float, int > | |
| isConvertibleType< const long double, int > | |
| isConvertibleType< const void, To > | A wrapper for a value that indicates that type "To" is a const void |
| isConvertibleType< double, int > | |
| isConvertibleType< float, int > | |
| isConvertibleType< long double, int > | |
| isConvertibleType< void, To > | A wrapper for a value that indicates that type "To" is a void |
| isEnumType< T > | IsEnumType<T>::value is a compile time constant that is only true if T is an enumeration type -- and not simple arithmetic value, pointer, class, function pointer, etc |
| isEnumType< const void > | |
| isEnumType< void > | |
| isFloatType< T > | IsFloatType<T>::value is a compile time constant that is only true if if T is a floating point number of some form |
| isFloatType< const void > | A definition of isFloatType for const void type. Void is not a flaot type |
| isFloatType< void > | A definition of isFloatType for void type. Void is not a flaot type |
| isFunctionType< T > | IsFunctionType<T>::value is a compile time constant that is only true only if T can be executed like a function of 0 to 9 parameters |
| isFunctionType< const void > | |
| isFunctionType< void > | |
| isIntegralType< T > | IsIntegralType<T>::value is a compile time constant that is only true if T is an int, short, char, long, long long, or unsigned versions thereof |
| isIntegralType< const void > | IsIntegralType<void> is a variant of isIntegralType that does not define a member named value and thus will will not compile correctly if an integral type is required |
| isIntegralType< void > | IsIntegralType<void> is a variant of isIntegralType that does not define a member named value and thus will will not compile correctly if an integral type is required |
| isPodType< T > | IsPodType<T>::value is a compile time constant that is true if T is a plain old data type and not a struct or union |
| ispodtype_impl< T > | |
| ispodtype_impl< char > | |
| ispodtype_impl< double > | |
| ispodtype_impl< float > | |
| ispodtype_impl< int > | |
| ispodtype_impl< long > | |
| ispodtype_impl< long long > | |
| ispodtype_impl< short > | |
| ispodtype_impl< T * > | |
| ispodtype_impl< T *const > | |
| ispodtype_impl< T[N]> | |
| ispodtype_impl< unsigned char > | |
| ispodtype_impl< unsigned int > | |
| ispodtype_impl< unsigned long long > | |
| ispodtype_impl< unsigned short > | |
| isPointerType< T > | IsPointerType<T>::value is a compile time constant that is true only if T is a pointer or a builtin array -- which can be treated like a pointer |
| isPointerType< T * > | |
| isPointerType< T *const > | |
| isPointerType< T const * > | |
| isPointerType< T const *const > | |
| isPointerType< T const [N]> | |
| isPointerType< T[N]> | |
| isPolymorphicType< T > | IsPolymorphicType<T>::value is a compile time constant that is true only if T is a class with virtual methods |
| isPolymorphicType_impl< plainT > | |
| d1 | |
| d2 | |
| isPolymorphicType_selector< is_class > | IsPolymorphicType_selector exists to work around a compile error problem: |
| rebind< T > | |
| isPolymorphicType_selector< true > | |
| rebind< T > | |
| isSameType< T, U > | Member value tells you whether two types are the same |
| isSignedType< T > | IsSignedType<T>::value is a compile time constant that is true only if T is a signed number |
| isSignedType< const void > | |
| isSignedType< void > | |
| isTemplate< T > | IsTemplate<T>::value is a compile time constant that is only true if T is a template of between 1 and 9 template parameters |
| isUnsignedType< T > | IsUnsignedType<T>:value is a compile time constant which is true only if T is an unsigned numeric type |
| isUnsignedType< const void > | |
| isUnsignedType< void > | |
| KeyViewer | An object of the KeyViewer class is passed to a ListViewer at the time of its construction so that the list viewer implements a way to see how keys are interpreted |
| ListViewer | A ListViewer is a simplified version of the generic Viewer interface. It only handles the viewing/editing of lists of strings. Each string is presented in vertical list form -- one string per line |
| policies | An abstract base class definining the list of strings to to be displayed/edited and a command handler. The command handler must not do any displaying of its own |
| MachineInfo | A description of the machine your program is running on and static methods to make inquiries |
| MRU< T > | A template container designed to provide a lightweight "most recently used" functionality. "Least recently used" is also implemented |
| BlockStatement | A group of statements that executes a single statement with a single pair of line context filters -- optionally with a "while condition" that allows the block to be run multiple times on the same input line while the condition is true |
| CompiledScript | A list of compiled muSED statements and the parsing tools needed to create it |
| DeleteStatement | A sed delete statement, usually specified like this: |
| Filter | A (possibly empty) criteria for deciding to execute a line in a sed script. The criteria include |
| FilterableStatement | A kind of sed Statement that can have 0, 1, or 2 filter criteria |
| GetStatement | A sed get statement, usually specified like this: |
| HoldStatement | A sed hold statement, usually specified like this: |
| OuterStatement | A fairly useless kind of statement that exists only to serve as the top level statement in a script. It is not "block" statement because it is not filterable |
| PrintStatement | A sed print statement, usually specified in one of the following forms: |
| QuitStatement | A sed quit statement, usually specified like this: |
| ScriptRuntimeContext | The runtime data needed to execute a muSED script on a stream of input lines. It contains the script and the activation state of the lines within the script, as well as the pattern and hold buffers, the only two variables defined by the sed language |
| Statement | A statement as defined by the sed language -- except for branches and labels which are not supported |
| SubstStatement | A regex replacment statement from sed. Typically specified something like this: |
| SwapStatement | A sed swap statement, usually specified like this: |
| TranslateStatement | A character set replacment statement from sed. Typically specified like this: |
| not_a_type | |
| Ostreamable< Derived, charT, traits > | A base class that hooks up a derived class to the ostream i/o operation set. To give your class the ability to act like an ostream, derive from Ostreamble<Derived> and implement the ostreamable_helper(charT c) function that outputs a single character |
| OstreamableBuffer< Owner, charT, traits > | Trivial implementation of a stream buffer that only just routes the overflow() behavior (that prints characters) to class that owns the OstreamableBuffer |
| pointerReferent< T > | PointerReferent<T>::type is the type that T points to if T is a pointer. If T is not a pointer, then pointerReference<T>::type is the same as T |
| pointerReferent< T * > | Determine the type referred to by a mutable pointer. See member "type" |
| pointerReferent< T const * > | Determine the type referred to by a const pointer. See member "type" |
| pointerReferent< T const [N]> | Determine the type referred to by a const array's name. See member "type" |
| pointerReferent< T[N]> | Determine the type referred to by an array's name. See member "type" |
| ProgramOptions | Class ProgramOptions represents the command line options and environment passed to a program by the operating system. A ProgramOptions object can be viewed as a map of environment variables as well as a list of non-option command parameters, and finally a map of options and their parameters |
| Descriptor | The description of a single option's type -- not its values, for that see ProgramOptions::Option |
| Descriptors | A collection of Descriptor's of options. This is a thin wrapper around a vector<Descriptor> Its main purpose is to define the add_option method so that the interface to array of descriptors becomes simpler to use |
| EnvVar | An EnvVar object exists to provide information about environment variables stored in the map of environment variables without having the user know about the implementation. Here is how an EnvVar is used: |
| Option | Interface to a given option. See documentation for it in the ProgramOptions class |
| removeAllExtents< T > | Like removeCV<T>, this function removes attributes from its template parameter T. In this case, it removes arrayness, constness, pointerness, and volatility. It defines a member type, type, which is the same as it's template parameter, T, but without *, &, [], or volatile keywords. In sort, it tells you what you are really looking at |
| removeAllExtents< T[N]> | See removeAllExtents<T> |
| removeConst< T > | Typename removeConst<T>::type is a type that is the non-const version of T. For normal classes, removeConst<T>::type is the same as T, but for T which is const, type is the non-const form |
| removeCV< T > | Typename removeCV<T>::type is the same as type T but is neither const nor is it volatile |
| removeReference< T > | Typename removeReference<T>::type is the same as type T, but is not a reference |
| removeReference_impl< U > | |
| removeReference_impl< V & > | |
| removeVolatile< T > | Typename removeVolatile<T>::type is a type that is the non-volatile version of T. For normal classes, removeVolatile<T>::type is the same as T, but for T which is const, type is the non-const form |
| removeVolatile< volatile T > | |
| Resources | A Resources object represents a set of named values. Both the names and the values are strings. Thus, a Resources object is roughly equivalent to the operating system's environment structure but Resource are not identical with environment variables because they cannot be obtained using getenv(), and cannot be set using putenv |
| SaveRestoreActiveWindow | This class exists to provide a way of saving and restoring the currently active viewport. You declare a variable of this type, initializing it with the pointer to the cursor window. It then saves the currently active viewport. When the SaveRestoreActiveWindow object is destructed, it restores the active viewport |
| ScriptTableViewer | A editor for tables produced by a user defined shell script program. See ../STV/README for an explanation of how to write such scripts |
| SessionInfo | |
| Sequence_Map< T, ID, H > | A Sequence_Map is a collection of related sequences of T objects. Sequences supported by a Sequence_Map can not contain optional members. The template argument, H is the name of a class object with an operator()(T) that produces and integer value which is a 'hash' of T |
| H1 | |
| node | |
| search | A 'search' is a context for comparing an arbitrary sequence with those stored in the Sequence_Map. The idea of course is to determine whether or not a given sequence exactly matches one found in the map -- and also what the ID of that sequence is. A search is a kind of iterator that scans through the structure of the Sequence_Map. You have to call operator++ to get to the next location in the sequence. If you want to know if you are sitting at the end of the sequence, call finished. A search does not exactly model an iterator so it has no comparison functions, and the Sequence_Map has no begin or end methods |
| sequence | A sequence is a handle object that lets you create patterns in the tree You construct a sequence object given a Sequence_Map object. You then add members to the sequence. When you are done, you call the complete() function to see if this is a valid (complete) sequence or if you have mistakenly create a subsequence of an existing sequence |
| SimpleRegex | This file defines a C++ wrapper around the standard regular expression functionality |
| match | Match a struct describing a sub-string that matched the pattern |
| skiprope< T > | An vector-like collection<T> which is implemented in such a way that no large blocks of memory are created. This allows inserts and deletes to be done in a time which is proportional to the size of the block being acted upon -- rather than upon the whole size of the container. To pay for _this_ performance gain, random accesses within the vector require O(ln(N)) time rather than O(1) as you usually see in a vector. Iteration is still O(1) but is much slower than iteration in a vector<T> |
| node_info | A structure describing a node in the rope. It is used in navigating the node data structure more easily than keeping track of the separate components of the description |
| skiprope_const_iterator< T > | A skiprope iterator simulates a pointer to type const T. The iterator knows about the structure of a skiprope. It knows that a skiprope is a linked list of nodes of varying widths |
| skiprope_iterator< T > | A skiprope iterator simulates a pointer to type T. The iterator knows about the structure of a skiprope. It knows that a skiprope is a linked list of nodes of varying widths |
| skiprope_level_desc< T > | |
| skiprope_node< T > | A skiprope_node is a chunk of a skiprope<T>. Each node is a vector<T> and the number of T's in the vector varies from node to node. The start position of any given node is equal to the sum of the nodes before it |
| link_info | |
| spline< X, Y, D > | A spline is an approximation to a single valued function of one variable. The function is approximated by first defining a specific set of sample values. Other data points of the function are interpolated given the defined set. That is, you can approximate data points that don't really exist using one the interpolate_* methods or the function call operator. See below |
| info | Info stored for each x value in the sample data set |
| StreamableString | This class implements a quick and dirty way to create formatted strings -- it is simpler to use that strstream but may be slower if you are working on large streams. This kind of string is appropriate for quick formatting activities |
| StrTool | This class just defines a bunch of string utility functions. They are part of a class just so that they don't clog up the global namespace. I suppose a namespace would have worked just as well |
| CharCompare | Functor object used to compare characters either case sensitively or or insentively |
| Is_Colon | |
| Is_Comma | |
| Is_Delim | |
| Is_Newline | If you want to use the parse_words method to split a string into lines, this is the Is_Separator parameter type for you |
| Is_Space | This struct is a 'functor' whose job it is to tell you whether a given character counts as 'space' in the normal way. You can write your own that have more or less complex tests... To use this struct, you construct an object of this type then execute the object like a funct -- passing it a character. The return value from the function call is a boolean value that tells you whether or not the character you pass in is whitespace |
| Is_Tab | |
| SymbolViewer | A Viewer for the symbol table stored in a CppTagDB as created by the program, cpptagdb.exe |
| SymbolViewerNodeInformation | Information that can be associated with a TreeViewerNode which is specific to symbols as defined in the SymbolViewer |
| TableEditor | An editor for table files whose fields are separated by some user defined character |
| TableViewer | A TableViewer is a kind of viewer that shows rows and columns and allows the user to move around within the table. The TableViewer class is meant primarily to be derived from. It handles the basics of table editing without doing anything really useful. You should derive from a TableViewer and implement various methods as needed to do something useful |
| CellInfo | |
| ColumnInfo | |
| CursorInfo | Set the "edit cell" for the table in world coordinates. If the cursor is currently visible and not already at the specified location it will be moved |
| FieldAttributes | |
| RowInfo | |
| TextViewer | A TextViewer is a Viewer meant for displaying but not editing ascii text files. It presents the user with the text of the named file and allows for scrolling (vertically and horizontally) as well as marking lines with the file for copying/pasting |
| impl | This class holds the actual guts of a viewer |
| TreeViewer | A TreeViewer allows the display of an acyclic directed graph of TreeViewerNodes |
| TreeViewerNode | A string object that is displayable in a tree structure. A node can have children, see methods children(), open(), and close() |
| TreeViewerNodeInfo | Derive from this class to implement data associated with tree viewer nodes. New up objects of your derived type and give them to tree viewer nodes using TreeViewerNode::adoptInfo(TreeViewerNodeInfo *); When the node gets deleted, the node info will get deleted |
| true_value_type | Type that means yes. true_value_type::value == 1 |
| UserInfo | Data about a given user and queries therefore. If the queries fail -- such as when a specified user id is invalid, the name_ will be an emtpy string. Otherwise, the data should be valid |
| Viewer | Before directly using any of the classes in this file, you should consider reading text_windows |
| ViewerManager | Before directly using any of the classes in this file, you should consider reading doc/text_windows |
| FileLocation | < The name of a file and a line number within it |
| ViewerSelector | This viewer allows the user to select from any extant viewer rather than creating a new viewer as does the appChooser class below |
| port | This class holds the actual viewport specific data |
| DefineHandler | This class exists so as to define an override of the virtual operator method(). Its behavior is to include #defines into the output data |
| DisplayList | This file defines a viewer program that uses a cursor window to display files, directories -- even remotely using ftp. It is not a real viewer because you can't go from a directory to looking at the files in it, for example. It is more of an example of how to do the basics |
| doubler< X > | This function is used to test the 'apply' |
| EditLine | A datastructure holding a line of text in an edit session. Lines of text are tab expanded before display and binary characters are converted into ~'s for display purposes |
| ElseifCounterInfo | |
| fail_stack_type | |
| cs | The type of an expression that can be printed using operator << |
| Char | |
| classification< T > | Contains member, printableClass, that indicates the printing style of type T |
| classification< char * > | |
| classification< char > | |
| classification< double > | |
| classification< float > | |
| classification< int > | < Superseeds the default printing type category for pointers |
| classification< long > | |
| classification< long long > | |
| classification< short > | |
| classification< std::string > | |
| classification< T * > | |
| classification< unsigned char * > | |
| classification< unsigned char > | |
| classification< unsigned char const * > | |
| classification< unsigned int > | |
| classification< unsigned long > | |
| classification< unsigned long long > | |
| classification< unsigned short > | |
| deconstify< T > | |
| deconstify< T const > | |
| devolify< T > | |
| devolify< T volatile > | |
| DoubleFloat | |
| Exception | < Invalid format type specified for a given actual data type |
| Float | |
| Integral | |
| isClassType< Type > | Declares a const member, value, which is either 0 or 1 depending on whether or not Type is a class object or not |
| StlString | |
| String | |
| typeDetector< 0 > | |
| typeDetector< 1 > | This template struct defines a nested type, type, which is a typedef for one of the following: |
| Unsigned | |
| UserDefined | |
| FunctionScope | The name and information associated with a function's scope |
| is_colon | |
| Is_Path_Separator | |
| is_pathsep | |
| POP3 | POP3 provides a class interface to a POP3 session. Basically it encapsulates in C++ classes the fundamental things you do with a connection to a POP3 server. Here's how you use an object of type POP3: |
| Attachment | |
| Body | |
| Header | |
| Impl | |
| Message | |
| User | Sets connect status to not_connected |
| popsession | |
| register_info_type | |
| ResizeHandler | This class implements the resize hander needed to repaint the display window when its size changes. Note that this class is needed because viewports are not used in this example program. If you were using viewports, their individual repaint handlers would do the trick -- of course you might need a ResizeHandler to inforce your own resize policy on the subwindows. The default one does nothing |
| ScopeBinder | A ScopeBinder object is created to save and restore the value of the variable, outer_scope. You save the old one at construction of the ScopeBinder object. On its destruction, the old value is restored |
| basic_streambuf | |
| SummaryData | |
| Impl | This class actually implements the text editor. The Viewer which holds this datastructure is just a mechanism for routing events to this class |
| CharCompare | |
| TextIterator | An iterator to the characters in a skiprope of EditLines |
| UndoOperation | A data structure that holds information needed to reverse a change to the file |
