| ▼Nmadara | Copyright (c) 2015 Carnegie Mellon University |
| ►Nexceptions | Provides exception classes for MADARA |
| CMemoryException | An exception for general memory errors like out-of-memory |
| CThreadException | An exception for general thread-related errors |
| ►Nexpression | Contains the KaRL expression tree interpreter and related classes |
| CAdd | Addition node of the parse tree |
| CAnd | Logically and node of the parse tree |
| CArrayRef | Leaf node for an array reference |
| CAssignment | Assign the value of an expression to a variable |
| CBoth | Evaluates both left and right children, regardless of values |
| CClearVariable | Clears a variable in the knowledge base |
| CComponentNode | An abstract base class defines a simple abstract implementation of an expression tree node |
| CCompositeAddNode | A composite node that encompasses addition of two expressions |
| CCompositeAndNode | A composite node that performs a logical and |
| CCompositeArrayReference | Defines a terminal node of that references the current value stored in a variable |
| CCompositeAssignmentNode | A composite node that allows for variable assignment |
| CCompositeBinaryNode | Defines a left and right node (via inheritance from CompositeUnaryNode) |
| CCompositeBothNode | A composite node that evaluates both left and right expressions regardless of their evaluations |
| CCompositeConstArray | A composite node that contains an array of values |
| CCompositeDivideNode | A composite node that divides a left expression by a right one |
| CCompositeEqualityNode | A composite node that compares left and right expressions for equality |
| CCompositeForLoop | A composite node that iterates until a condition is met |
| CCompositeFunctionNode | A composite node that calls a function |
| CCompositeGreaterThanEqualNode | A composite node that compares left and right expressions for greater than or equal to |
| CCompositeGreaterThanNode | A composite node that compares left and right children for greater than |
| CCompositeImpliesNode | A composite node that performs an implication (inference rule) |
| CCompositeInequalityNode | A composite node that compares left and right children for inequality |
| CCompositeLessThanEqualNode | A composite node that compares left and right children for less than or equal to |
| CCompositeLessThanNode | A composite node that compares left and right children for less than |
| CCompositeModulusNode | A composite node that divides a left expression by a right expression and returns the remainder of the division |
| CCompositeMultiplyNode | A composite node that multiplies a left expression by a right expression |
| CCompositeNegateNode | A composite node that integrally negates a right expression |
| CCompositeNotNode | A composite node that logically nots a right expression |
| CCompositeOrNode | A composite node that performs a logical or |
| CCompositePostdecrementNode | A composite node that decrements a left expression |
| CCompositePostincrementNode | A composite node that increments a right expression |
| CCompositePredecrementNode | A composite node that decrements a right expression |
| CCompositePreincrementNode | A composite node that increments a right expression |
| CCompositeReturnRightNode | A composite node that evaluates both left and right expressions regardless of their evaluations |
| CCompositeSequentialNode | A composite node that evaluates both left and right expressions regardless of their evaluations |
| CCompositeSquareRootNode | A composite node that takes the square root of a term |
| CCompositeSubtractNode | A composite node that encompasses subtraction of a right expression from a left expression |
| CCompositeTernaryNode | |
| CCompositeUnaryNode | Encapsulates a single expression tree |
| CConstArray | A constant array that should not be changed |
| CCos | Returns the cosine of a term (radians) |
| CDeleteVariable | Deletes a variable from the knowledge base |
| CDivide | Division node of the parse tree |
| CEquality | Check and left and right arguments for equality |
| CEval | Evaluates a Knowledge Record and returns result |
| CExpandEnv | Expands a statement, e.g |
| CExpandStatement | Expands a statement, e.g |
| CExpressionTree | Encapsulates a MADARA KaRL expression into an evaluatable tree |
| CExpressionTreeConstIterator | Constant iterator over an expression tree |
| CExpressionTreeIterator | Non-const iterator for traversing an expression tree |
| CExpressionTreeIteratorFactory | Implementation of a factory pattern that dynamically allocates the appropriate ExpressionTreeIteratorImpl object |
| CExpressionTreeIteratorImpl | Implementation of the ExpressionTreeIterator pattern that is used to define the various iterations algorithms that can be performed to traverse the expression tree |
| CForLoop | Iterative looping node of the parse tree |
| CFragment | Fragment the Knowledge Record |
| CFunction | Function node of the parse tree |
| CGetClock | Returns the clock of the argument or the system clock |
| CGetTime | Returns the wall clock time |
| CGetTimeSeconds | Returns the wall clock time in seconds |
| CGreaterThan | Check and left and right arguments for greater than |
| CGreaterThanEqual | Check and left and right arguments for greater than or equal to |
| CImplies | Assign the value of an expression to a variable |
| CInequality | Check and left and right arguments for inequality |
| CInOrderIteratorImpl | Iterates through an ExpressionTree in in-order |
| CInterpreter | Parses incoming expression strings into a parse tree and generates an expression tree from the parse tree |
| CIsinf | Returns whether the first argument is an infinite number |
| CKarlException | An exception for unrecoverable KaRL compilation issues |
| CLeafNode | Defines a node that contains a madara::knowledge::KnowledgeRecord::Integer value |
| CLessThan | Check and left and right arguments for less than |
| CLessThanEqual | Check and left and right arguments for less than or equal to |
| CLevelOrderExpressionTreeIteratorImpl | Iterates through an ExpressionTree in level-order |
| CList | Parameter List |
| CListNode | Defines a terminal node that contains a list |
| CLogLevel | Reads or sets the MADARA log level |
| CModulus | Modulus node of the parse tree (10 % 4 == 2) |
| CMultiply | Multiplication node of the parse tree |
| CNegate | Negate node of the parse tree |
| CNot | Logically not the right node |
| CNumber | Leaf node of parse tree |
| COperator | Abstract base class for all parse tree node operators |
| COr | Logically or node of the parse tree |
| CPostdecrement | Postdecrement node of the parse tree |
| CPostincrement | Postincrement node of the parse tree |
| CPostOrderIteratorImpl | Iterates through an ExpressionTree in post-order |
| CPower | Returns a base term taken to a power (exponent) |
| CPredecrement | Predecrement node of the parse tree |
| CPreincrement | Preincrement node of the parse tree |
| CPreOrderIteratorImpl | Iterates through an ExpressionTree in level-order |
| CPrint | Prints a Knowledge Record to the stderr |
| CPrintSystemCalls | Prints a help menu for all system calls |
| CRandDouble | Generates a random double |
| CRandInt | Generates a random integer |
| CReadFile | Reads a file |
| CReturnRight | Evaluates both left and right children and returns right value |
| CSequence | Evaluates both left and right children, regardless of values |
| CSetClock | Sets the system or a variable clock |
| CSetFixed | Sets the output format to std::fixed |
| CSetPrecision | Sets the precision of doubles |
| CSetScientific | Sets the output to std::scientific |
| CSin | Returns the sin of a term (radians) |
| CSize | Returns the size of a record |
| CSleep | Sleeps for a certain amount of time |
| CSquareRoot | Returns the square root of a term |
| CSquareRootUnary | |
| CSubtract | Subtraction node of the parse tree |
| CSymbol | Abstract base class of all parse tree nodes |
| CSystemCall | Abstract base class for operators with 3+ potential subnodes |
| CSystemCallClearVariable | Attempts to clear a variable |
| CSystemCallCos | Returns the cosine of a term in radians |
| CSystemCallDeleteVariable | Attempts to delete a variable |
| CSystemCallEval | Evaluates a knowledge::KnowledgeRecord and returns the evaluation result |
| CSystemCallExpandEnv | Returns the expansion of a statement with environment vars |
| CSystemCallExpandStatement | Returns the expansion of a statement |
| CSystemCallFragment | Returns a fragment of the knowledge record |
| CSystemCallGetClock | Returns the system clock or a variable clock |
| CSystemCallGetTime | Returns the time in nanoseconds since epoch |
| CSystemCallGetTimeSeconds | Returns the current time in seconds since epoch |
| CSystemCallIsinf | Returns the type of a specified knowledge record |
| CSystemCallLogLevel | Sets or returns the current MADARA logging level |
| CSystemCallNode | Interface for a MADARA system call |
| CSystemCallPow | Calculates a base term taken to a power |
| CSystemCallPrint | Prints a Knowledge Record |
| CSystemCallPrintSystemCalls | Prints all supported system calls |
| CSystemCallRandDouble | Returns a random double |
| CSystemCallRandInt | Returns a random integer |
| CSystemCallReadFile | Reads a file from an user-provided file name |
| CSystemCallSetClock | Sets the system clock or a variable clock |
| CSystemCallSetFixed | Sets the output format to use std::fixed |
| CSystemCallSetPrecision | Sets the double precision for converting doubles to a string and for printing |
| CSystemCallSetScientific | Sets the output format to use std::scientific |
| CSystemCallSin | Returns the sin of a term in radians |
| CSystemCallSize | Returns the size of a specified knowledge record |
| CSystemCallSleep | Sleeps for a certain amount of time |
| CSystemCallSqrt | Returns the square root of a term |
| CSystemCallTan | Returns the tangent of a term in radians |
| CSystemCallToBuffer | Converts an argument into an unsigned char buffer |
| CSystemCallToDouble | Converts an argument to a double |
| CSystemCallToDoubles | Converts an argument to an array of doubles |
| CSystemCallToHostDirs | Ensures the directory delimiters are appropriate for the host operating system (e.g., on Windows, '\' and Linux, '/') |
| CSystemCallToInteger | Converts an argument to an integer |
| CSystemCallToIntegers | Converts an argument to an array of integers |
| CSystemCallToString | Converts an argument to a string |
| CSystemCallType | Returns the type of a specified knowledge record |
| CSystemCallWriteFile | Writes a knowledge record to an user-specified file name |
| CTan | Returns the tangent of a term (radians) |
| CTernaryOperator | Abstract base class for operators with 3+ potential subnodes |
| CToBuffer | Returns a buffer |
| CToDouble | Returns a double |
| CToDoubles | Returns a double array |
| CToHostDirs | Returns a version that has a directory structure appropriate to the OS |
| CToInteger | Returns an integer |
| CToIntegers | Returns an integers |
| CToString | Returns a string |
| CType | Returns the type of a record |
| CUnaryOperator | Abstract base class for all parse tree node operators |
| CVariable | Leaf node of parse tree |
| CVariableCompare | Increment a variable by a certain amount |
| CVariableCompareNode | Defines a terminal node of that references the current value stored in a variable |
| CVariableDecrement | Decrement a variable by a certain amount |
| CVariableDecrementNode | Composite node that subtracts a variable by some right hand side |
| CVariableDivide | Divide a variable by a certain amount |
| CVariableDivideNode | Composite node that divides a variable by some right hand side |
| CVariableExpander | A convenience class for |
| CVariableIncrement | Increment a variable by a certain amount |
| CVariableIncrementNode | Defines a terminal node of that references the current value stored in a variable |
| CVariableMultiply | Multiply a variable by a certain amount |
| CVariableMultiplyNode | Composite node that multiplies a variable by some right hand side |
| CVariableNode | Defines a terminal node of that references the current value stored in a variable |
| CVisitor | Abstract base class for all visitors to all classes that derive from ComponentNode |
| CWriteFile | Writes a file |
| ►Nfilters | Provides filtering for the MADARA transport layer |
| CAESBufferFilter | Encrypts a buffer with 256 bit AES via OpenSSL |
| CAggregateFilter | Abstract base class for implementing aggregate record filters via a functor interface |
| CBufferFilter | Abstract base class for implementing buffer filters via a functor interface |
| CClearRecords | Filter for clearing records from a filter |
| CCounterFilter | Filter for discovering neighboring peers |
| CEndpointClear | Filter for deleting endpoints, usually when new endpoints have been discovered |
| CEndpointDiscovery | Filter for discovering remote hosts that have sent messages |
| CJavaBufferFilter | Filters a buffer in Java |
| CPeerDiscovery | Filter for discovering neighboring peers |
| CRecordFilter | Abstract base class for implementing individual record filters via a functor interface |
| ►Nknowledge | Provides functions and classes for the distributed knowledge base |
| ►Ncontainers | Provides container classes for fast knowledge base access and mutation |
| CBarrier | This class stores an integer within a variable context |
| CBaseContainer | This class is an abstract base class for all containers |
| CBufferVector | This class stores a vector of character buffers |
| CCollection | A collection of MADARA containers that can be used for aggregate operations on all containers in the collection |
| CCounter | This class stores an integer within a variable context |
| CDouble | This class stores a double within a variable context |
| CDoubleStaged | Stages an integer value to and from the knowledge base |
| CDoubleVector | This class stores a vector of doubles inside of KaRL |
| ►CDoubleVector2D | Manages a 2D array of doubles as a virtual overlay in the KnowledgeBase |
| CIndices | Two dimensional indexing |
| ►CDoubleVector3D | Manages a 3D array of doubles as a virtual overlay in the KnowledgeBase |
| CIndices | Two dimensional indexing |
| ►CDoubleVectorVector | This class stores a vector of NativeDoubleVectors |
| CIndices | Two dimensional indexing |
| CFlexMap | This class stores a flexible map of strings and ints to KaRL variables FlexMap differs from Map in three distinct ways |
| CInteger | This class stores an integer within a variable context |
| CIntegerStaged | Stages an integer value to and from the knowledge base |
| CIntegerVector | This class stores a vector of integers inside of KaRL |
| ►CIntegerVector2D | Manages a 2D array of integers as a virtual overlay in the KnowledgeBase |
| CIndices | Two dimensional indexing |
| ►CIntegerVector3D | Manages a 3D array of doubles as a virtual overlay in the KnowledgeBase |
| CIndices | Three dimensional indexing |
| ►CIntegerVectorVector | This class stores a vector of NativeIntegerVectors |
| CIndices | Two dimensional indexing |
| CMap | This class stores a map of strings to KaRL variables |
| CNativeDoubleVector | This class stores a vector of doubles inside of KaRL |
| CNativeDoubleVectorStaged | This class stores a vector of doubles inside of KaRL |
| CNativeIntegerVector | This class stores a vector of doubles inside of KaRL |
| CNativeIntegerVectorStaged | This class stores a vector of doubles inside of KaRL |
| CQueue | This class stores thread-safe queue within the knowledge base |
| CString | This class stores a string within a variable context |
| CStringStaged | Stages a string value to and from the knowledge base |
| CStringVector | This class stores a vector of strings inside of KaRL |
| CVector | This class stores a vector of KaRL variables |
| ►Nrcw | Namespace holding Read-Compute-Write based abstractions for knowledge base access |
| CBaseTracker | Base type for Trackers |
| CPrefixTracker | Tracker that puts values into a multiple prefixed KnowledgeRecord |
| CPrefixTracker< T, R, false, false, void > | If trying to create a tracker that is read-only, and write-only, give error |
| CPrefixTracker< T, VariableReference, RD, WR, typename std::enable_if< supports_get_value< T >::value &&supports_indexed_get_value< T >::value &&supports_size< T >::value &&supports_is_dirty< T >::value &&supports_is_all_dirty< T >::value &&supports_is_size_dirty< T >::value &&supports_indexed_is_dirty< T >::value >::type > | Tracker that puts values into a multiple prefixed KnowledgeRecord |
| CTracked | Tracks the modification status of a wrapped object of the given type |
| CTracked< std::vector< T > > | Implement functionality specific to std::vectors |
| CTrackedCollection | Used internally by Tracked |
| CTrackedExtra | Provides default versions of methods below |
| CTrackedExtra< std::basic_string< Char >, Impl > | Adds functionality specific to std::basic_string |
| CTracker | Tracker which puts variable values into a single KnowledgeRecord |
| CTracker< T, R, false, false, void > | If trying to create a tracker that is read-only, and write-only, give error |
| CTracker< T, VariableReference, false, true, typename std::enable_if< supports_get_value< T >::value &&supports_knowledge_cast< T >::value &&supports_is_dirty< T >::value &&!supports_indexed_is_dirty< T >::value >::type > | Tracker specialization for types that track their own modification status and that can only write |
| CTracker< T, VariableReference, false, true, typename std::enable_if< supports_get_value< T >::value &&supports_knowledge_cast< T >::value &&supports_self_eq< T >::value &&!supports_is_dirty< T >::value >::type > | Tracker specialization for types that don't track modification status, and that can only write |
| CTracker< T, VariableReference, RD, WR, typename std::enable_if< supports_get_value< T >::value &&supports_indexed_get_value< T >::value &&supports_size< T >::value &&supports_knowledge_cast< T >::value &&supports_is_dirty< T >::value &&supports_is_all_dirty< T >::value &&supports_is_size_dirty< T >::value &&supports_indexed_is_dirty< T >::value >::type > | Tracker specialization for types that have individual indexed elements, and track their modification status individually |
| CTracker< T, VariableReference, RD, WR, typename std::enable_if< supports_indexed_get_value< T >::value &&supports_size< T >::value &&!supports_is_all_dirty< T >::value &&!supports_is_size_dirty< T >::value &&supports_indexed_is_dirty< T >::value >::type > | Tracker specialization for types with individual elements that each track their own modification status |
| CTracker< T, VariableReference, true, false, typename std::enable_if< supports_get_value< T >::value &&supports_knowledge_cast< T >::value >::type > | Tracker specialization for types that can only read |
| CTracker< T, VariableReference, true, true, typename std::enable_if< supports_get_value< T >::value &&supports_knowledge_cast< T >::value &&supports_is_dirty< T >::value &&!supports_indexed_is_dirty< T >::value >::type > | Tracker specialization for types that track their own modification status and that can both read and write |
| CTracker< T, VariableReference, true, true, typename std::enable_if< supports_get_value< T >::value &&supports_knowledge_cast< T >::value &&supports_self_eq< T >::value &&!supports_is_dirty< T >::value >::type > | Tracker specialization for types that don't track modification status, and that can both read and write |
| ►CTransaction | Manages a Read-Compute-Write cycle for registered variables |
| CBuilder | Builder object returned by build() |
| CInitHandler | Helper type to enable initialization using initializer_list Fallback implementation for types which do not support initializer_list |
| CInitHandler< B, I, T, typename std::enable_if< supports_get_value< T >::value &&supports_indexed_get_value< T >::value &&supports_size< T >::value >::type > | Helper type to enable initialization using initializer_list Specialization for types which do support initializer_list |
| ►Ntags | Tags to specify what type to construct in KnowledgeRecord forwarding constructors |
| Cbinary_t | |
| Cdoubles_t | |
| Cintegers_t | |
| Cshared_t | |
| Cstring_t | |
| CAggregateFilter | This class stores a function definition |
| CCheckpointSettings | Holds settings for checkpoints to load or save |
| CCompiledExpression | Compiled, optimized KaRL logic |
| CContextGuard | A thread-safe guard for a context or knowledge base |
| CEvalSettings | Encapsulates settings for an evaluation statement |
| CFileHeader | Defines a file header which is the default for KaRL checkpointing |
| CFileSettings | This class provides an interface into the KnowledgeEngine that governs how files are prioritized, modified, and handled |
| CFunction | This class stores a function definition |
| CKnowledgeBase | This class provides a distributed knowledge base to users |
| CKnowledgeBaseImpl | This class provides a distributed knowledge base implementation |
| CKnowledgeRecord | This class encapsulates an entry in a KnowledgeBase |
| CKnowledgeRecordFilters | Provides map of data types to a filter chain to apply to the data |
| CKnowledgeReferenceSettings | Settings for applying knowledge updates |
| ►CKnowledgeRequirements | Holds settings requirements for knowledge, usually in copying |
| CMatchPredicate | A helper class for matching prefixes and suffixes |
| CKnowledgeUpdateSettings | Settings for applying knowledge updates |
| CThreadSafeContext | This class stores variables and their values for use by any entity needing state information in a thread safe way |
| Ctype | Helper type for specifying template type parameters using a function argument instead of inside explicit "<...>" |
| CVariableReference | Optimized reference to a variable within the knowledge base |
| CVariableReferenceMapCompare | |
| CVariables | Provides an interface for external functions into the MADARA KaRL variable settings |
| CWaitSettings | Encapsulates settings for a wait statement |
| ►Nlogger | Provides knowledge logging services to files and terminals |
| CLogger | A multi-threaded logger for logging to one or more destinations |
| ►Npython | |
| CAcquire_GIL | This class encapsulates accessing the global interpreter lock |
| ►Nthreads | Provides a quality-of-service-enabled threading library |
| CBaseThread | Abstract base class for implementing threads |
| CJavaThread | A facade for a user-defined Java thread class |
| CRCWThread | Abstract base class for implementing RCW threads |
| CThreader | Starts threads with first class support of MADARA contexts |
| CWorkerThread | A thread that executes BaseThread logic |
| CWorkUnit | Abstract base class for implementing base threads |
| ►Ntransport | Provides the network transport layer for knowledge bases to communicate within and across agents |
| CBandwidthMonitor | Provides monitoring capability of a transport's bandwidth |
| CBase | Base class from which all transports must be derived |
| CBasicASIOTransport | |
| CBroadcastTransport | Broadcast-based transport for knowledge |
| CFragmentMessageHeader | Defines a fragmentation header which allows for multi-part messages that are only applied once all fragments are received |
| CMessageHeader | Defines a robust message header which is the default for KaRL messages |
| CMulticastTransport | Multicast-based transport for knowledge |
| CMulticastTransportReadThread | Thread for reading knowledge updates through a Multicast datagram socket |
| CNddsListener | Container for NDDS callbacks |
| CNddsTransport | This class provides an interface into the NDDS dissemination transport |
| CPacketScheduler | Provides scheduler for dropping packets |
| CQoSTransportSettings | Container for quality-of-service settings |
| CReducedMessageHeader | Defines a simple, smaller message header of 29 bytes that supports less QoS |
| CSpliceDataReaderListener | Container for DDS-related callbacks (deprecated and unused) |
| CSpliceDDSTransport | This class provides an interface into the Open Splice dissemination transport |
| CSpliceReadThread | Thread for reading knowledge updates via waitsets |
| CSpliceSubscriberListener | Container for subscriber callbacks (deprecated and unused) |
| CTransportContext | Provides context about the transport |
| CTransportSettings | Holds basic transport settings |
| CUdpRegistryClient | UDP-based transport for knowledge |
| CUdpRegistryServer | UDP-based server that handles a registry of UDP endpoints, which makes it ideal for any NAT-protected agents |
| CUdpTransport | UDP-based transport for knowledge |
| CUdpTransportReadThread | Thread for reading knowledge updates through a UDP socket |
| CZMQContext | A class that manages a ZMQ context |
| CZMQTransport | ZMQ-based transport for knowledge |
| CZMQTransportReadThread | Thread for reading knowledge updates through a ZMQ datagram socket |
| ►Nutility | Provides utility functions and classes for common tasks and needs |
| ►Njava | Provides utility functions and classes for common Java tasks and needs |
| CAcquire_VM | This class encapsulates attaching and detaching to a VM |
| CEpochEnforcer | Enforces a periodic epoch |
| ►CLQueue | Defines a generic "first-in/first-out" (FIFO) Abstract Data Type (ADT) using a circular linked list |
| COverflow | Exception thrown by methods in this class when an overflow condition occurs |
| CUnderflow | Exception thrown by methods in this class when an underflow condition occurs |
| CLQueueConstIterator | Implements a forward iterator for LQueue type classes |
| CLQueueIterator | Implements a forward iterator for LQueue type classes |
| CLQueueNode | Defines a node in the LQueue that's implemented as a circular linked list |
| ►CLStack | Defines a generic "last-in/first-out" (LIFO) Abstract Data Type (ADT) using a stack that's implemented as a linked list |
| COverflow | Exception thrown by methods in this class when an overflow condition occurs |
| CUnderflow | Exception thrown by methods in this class when an underflow condition occurs |
| CLStackConstIterator | Implements a forward iterator for LStack type classes |
| CLStackIterator | Implements a forward iterator for LStack type classes |
| CLStackNode | Defines a node in the LStack that's implemented as a linked list |
| ►CRefcounter | This template class provides transparent reference counting of its template parameter T |
| CShim | A shim class that keeps track of the reference count and a pointer to the type T that's reference counted |
| ►CScopedArray | This template class provides transparent reference counting of its template parameter T |
| CShim | A shim class that keeps track of the reference count and a pointer to the type T that's reference counted |
| CThreadSafeVector | Manages a thread safe STL vector |
| CTimer | Manages a timer for duration testing |
| CDeepIterator | The iterator type returned by deep_iterate |
| CFunctionMap | This class stores external functions |
| CIteratorTraits | Specialize this template to support various kinds of iterators |
| CIteratorTraits< T, typename TypeHelper< typename T::value_type >::type, typename TypeHelper< typename T::value_type::second_type >::type > | Specialization for map-style pair iterators, where we want to deep-copy the value, but not the key |
| CIteratorTraits< T, typename TypeHelper< typename T::value_type >::type, V > | Specialization for plain iterators, where we can call deep_copy directly on the iterator |
| CStrideTask | INTERNAL USE: Task that can be added to a Stride scheduler |
| CTernaryNode | An abstract base class defines a simple abstract implementation of an expression tree node |
| CTypeHelper | Helper class for type inference |
1.8.11 
