Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

CTeuchos::AbstractFactory< T >	Simple, universal "Abstract Factory" interface for the dynamic creation of objects
CTeuchos::AbstractFactory< T_itfc >
CTeuchos::AbstractFactoryStd< T_itfc, T_impl, T_PostMod, T_Allocator >	Simple, templated concrete subclass of universal "Abstract Factory" interface for the creation of objects
CTeuchos::AnyNumberParameterEntryValidator::AcceptedTypes	Determines the types that are accepted
CTeuchos::ActiveRCPNodesSetup	Sets up node tracing and prints remaining RCPNodes on destruction
CTeuchos::MatrixMarket::Raw::Adder< Scalar, Ordinal >	To be used with Checker for "raw" sparse matrix input
CTeuchos::StackedTimer::AlignmentWidths	Stores the column widths for output alignment
CTeuchos::Details::AllocationLogger	Logging implementation used by Allocator (see below)
CTeuchos::Details::Allocator< T >	Optional tracking allocator for Teuchos Memory Management classes
CTeuchos::AllocatorNew< T_impl >	Default allocation policy class for AbstractFactoryStd which returns new T_impl()
CTeuchos::StringToIntMap::AlreadyExists
CTeuchos::any	Modified boost::any class, which is a container for a templated value
CTeuchos::Array< T >	Replacement for std::vector that is compatible with the Teuchos Memory Management classes
CTeuchos::ArrayRCP< T >	Reference-counted smart pointer for managing arrays
CTeuchos::ArrayRCP< const T >	Partial specialization of ArrayRCP for const T
CTeuchos::ArrayRCP< const void >	Dummy specialization of ArrayRCP<const void>
CTeuchos::ArrayRCP< void >	Full specialization of ArrayRCP for T = void
CTeuchos::ArrayView< T >	Nonowning array view
CTeuchos::Tuple< T, N >	Statically sized simple array (tuple) class
CTeuchos::ArrayView< const T >	Partial specialization of ArrayView for const T
CTeuchos::ArrayView< int >
CTeuchos::Tuple< int, numFieldTypes >
CTeuchos::asFunc< TypeTo >	Function object wrapper for as()
CTeuchos::bad_any_cast	Thrown if any_cast is attempted between two incompatable types
CTeuchos::BadParameterEntryXMLConverterTypeException	Thrown when a converter is being used to convert either and XML tag or ParameterEntry with an innappropriate type
CTeuchos::BadParameterListElementException	Thrown when an element inside a parameter list is bad
CTeuchos::BadTagException	Thrown when xml tag is encountered that is either unrecognized or inappropriate for a given context
CTeuchos::BadValidatorXMLConverterException	Thrown when a bad validator xml converter is used
CTeuchos::BadXMLParameterListRootElementException	Thrown when the root xml tag for a parameter list is incorrect
CTeuchos::MatrixMarket::Banner	Parse a Matrix Market banner line
CTeuchos::BaseTimer	Basic timer used elsewhere, uses MPI_Wtime for time
CTeuchos::StackedTimer::LevelTimer	Timer info at a given level and all the children
CTeuchos::basic_FancyOStream< CharT, Traits >	Std::ostream subclass that performs the magic of indenting data sent to an std::ostream object among other things
CTeuchos::basic_FancyOStream< char >
CTeuchos::basic_FancyOStream< CharT, std::char_traits< CharT > >
CTeuchos::basic_FancyOStream_buf< CharT, Traits >	Stream buffering class that performs the magic of indenting data sent to an std::ostream object
CTeuchos::basic_FancyOStream_buf< CharT, std::char_traits< CharT > >
CTeuchos::basic_oblackholestream< _CharT, _Traits >	basic_ostream<> subclass that does nothing but discard output
CTeuchos::basic_oblackholestream< char, std::char_traits< char > >
CTeuchos::basic_OSTab< CharT, Traits >	Tabbing class for helping to create formated, indented output for a basic_FancyOStream object
CTeuchos::BigUInt< n >	Arbitrary-precision unsigned integer class
CTeuchos::CantFindConditionConverterException	Thrown when an appropriate Condition Converter can't be found
CTeuchos::CantFindDependencyConverterException	Thrown when an appropriate Dependency Converter can't be found
CTeuchos::CantFindFunctionObjectConverterException	Thrown when an appropriate FunctionObject Converter can't be found
CTeuchos::CantFindParameterEntryConverterException	Thrown when an appropriate ParameterEntryXMLConverter can't be found
CTeuchos::CantFindValidatorConverterException	Thrown when the ValidatorXMLConverterDB can't find an appropriate converter
CTeuchos::MatrixMarket::Raw::Checker< Scalar, Ordinal >	Tool for debugging the syntax of a Matrix Market file containing a sparse matrix
CTeuchos::CommandLineProcessor	Class that helps parse command line input arguments from (argc,argv[]) and set options
CTeuchos::CommStatus< OrdinalType >	Encapsulation of the result of a receive (blocking or nonblocking)
CTeuchos::SerialCommStatus< OrdinalType >	Implementation of CommStatus for a serial communicator
CTeuchos::CompileTimeAssert< Test >	If instantiated (for Test!=0) then this should not compile!
CTeuchos::CompileTimeAssert< 0 >	If instantiated (i.e. Test==0) then this will compile!
CTeuchos::CompObject	Functionality and data that is common to all computational classes
CTeuchos::SerialBandDenseMatrix< OrdinalType, ScalarType >	This class creates and provides basic support for banded dense matrices of templated type
CTeuchos::SerialBandDenseSolver< OrdinalType, ScalarType >	A class for representing and solving banded dense linear systems
CTeuchos::SerialDenseMatrix< OrdinalType, ScalarType >	This class creates and provides basic support for dense rectangular matrix of templated type
CTeuchos::SerialDenseVector< OrdinalType, ScalarType >	This class creates and provides basic support for dense vectors of templated type as a specialization of Teuchos::SerialDenseMatrix. Additional methods for the SerialDenseVector class, like mathematical methods, can be found documented in SerialDenseMatrix
CTeuchos::SerialDenseSolver< OrdinalType, ScalarType >	A class for solving dense linear problems
CTeuchos::SerialQRDenseSolver< OrdinalType, ScalarType >	A class for solving dense linear problems
CTeuchos::SerialSpdDenseSolver< OrdinalType, ScalarType >	A class for constructing and using Hermitian positive definite dense matrices
CTeuchos::SerialSymDenseMatrix< OrdinalType, ScalarType >	This class creates and provides basic support for symmetric, positive-definite dense matrices of templated type
CTeuchos::SerialTriDiMatrix< OrdinalType, ScalarType >	This class creates and provides basic support for TriDi matrix of templated type
CTeuchos::ConditionXMLConverterDB	Provides ability to lookup ConditionXMLConverters
CTeuchos::ConstHandleable< Base >	Class ConstHandleable provides an abstract interface for polymorphic conversion from raw pointers to const smart pointers
CTeuchos::Handleable< Base >	Class Handleable provides an abstract interface for polymorphic conversion from raw pointers to smart pointers
CTeuchos::ConstNonconstObjectContainer< ObjType >	Simple class supporting the "runtime protection of const" idiom
CTeuchos::ConstReferenceTypeDeserializationBuffer< Ordinal, T >	Encapsulate how an array of onst objects with reference sematics is deserialized from a char[] array with memory being automatically freed at destruction time
CTeuchos::ConstReferenceTypeSerializationBuffer< Ordinal, T >	Encapsulate how an array of const objects with reference sematics is serialized into a char[] array
CTeuchos::ConstTypeTraits< T >	Traits class that strips 'const' off of a type
CTeuchos::ConstValueTypeDeserializationBufferImp< Ordinal, T, Serializer, direct >	Encapsulate how an array of non-const serialized objects with value sematics stored in a char[] array is deserialized to a T[] array and then serialized back again
CTeuchos::ConstValueTypeDeserializationBuffer< Ordinal, T, Serializer >	Encapsulate how an array of non-const serialized objects with value sematics stored in a char[] array is deserialized to a T[] array and then serialized back again
CTeuchos::ConstValueTypeDeserializationBufferImp< Ordinal, T, DefaultSerializer< Ordinal, T >::DefaultSerializerType >
CTeuchos::ConstValueTypeDeserializationBuffer< Ordinal, T, typename DefaultSerializer< Ordinal, T >::DefaultSerializerType >	Encapsulate how an array of non-const serialized objects with value sematics stored in a char[] array is deserialized to a T[] array and then serialized back again
CTeuchos::ConstValueTypeDeserializationBufferImp< Ordinal, T, Serializer, false >	Encapsulate how an array of non-const serialized objects with value sematics stored in a char[] array is deserialized to a T[] array and then serialized back again
CTeuchos::ConstValueTypeDeserializationBufferImp< Ordinal, T, Serializer, true >	Encapsulate how an array of non-const serialized objects with value sematics stored in a char[] array is deserialized to a T[] array and then serialized back again
CTeuchos::ConstValueTypeDeserializationBufferImp< Ordinal, T, typename DefaultSerializer< Ordinal, T >::DefaultSerializerType >
CTeuchos::ConstValueTypeDeserializationBuffer< Ordinal, T, typename DefaultSerializer< Ordinal, T >::DefaultSerializerType >	Encapsulate how an array of non-const serialized objects with value sematics stored in a char[] array is deserialized to a T[] array and then serialized back again
CTeuchos::ConstValueTypeSerializationBufferImp< Ordinal, T, Serializer, direct >	Encapsulate how an array of const objects with value sematics is serialized into a const char[] array
CTeuchos::ConstValueTypeSerializationBuffer< Ordinal, T, Serializer >	Encapsulate how an array of const objects with value sematics is serialized into a const char[] array
CTeuchos::ConstValueTypeSerializationBufferImp< Ordinal, T, DefaultSerializer< Ordinal, T >::DefaultSerializerType >
CTeuchos::ConstValueTypeSerializationBuffer< Ordinal, T, typename DefaultSerializer< Ordinal, T >::DefaultSerializerType >	Encapsulate how an array of const objects with value sematics is serialized into a const char[] array
CTeuchos::ConstValueTypeSerializationBufferImp< Ordinal, T, Serializer, false >	Encapsulate how an array of const objects with value sematics is serialized into a const char[] array
CTeuchos::ConstValueTypeSerializationBufferImp< Ordinal, T, Serializer, true >	Encapsulate how an array of const objects with value sematics is serialized into a const char[] array
CTeuchos::ConstValueTypeSerializationBufferImp< Ordinal, T, typename DefaultSerializer< Ordinal, T >::DefaultSerializerType >
CTeuchos::ConstValueTypeSerializationBuffer< Ordinal, T, typename DefaultSerializer< Ordinal, T >::DefaultSerializerType >	Encapsulate how an array of const objects with value sematics is serialized into a const char[] array
CTeuchos::MatrixMarket::CoordDataReaderBase< Callback, Ordinal >	Common functionality of a coordinate-format sparse matrix or graph data reader
CTeuchos::MatrixMarket::CoordDataReader< Callback, Ordinal, Scalar, isComplex >	Coordinate-format sparse matrix data reader
CTeuchos::MatrixMarket::CoordPatternReader< Callback, Ordinal >	Coordinate-format sparse graph data reader
CTeuchos::CWrapperErrorHandling	Static C Wrapper Error Handling Policy Class
CTeuchos::DeallocArrayDelete< T >	Deallocator class that uses delete [] to delete memory allocated uisng new []
CTeuchos::DeallocBoostSharedPtr< T >	Teuchos::RCP Deallocator class that wraps a boost::shared_ptr
CTeuchos::DeallocDelete< T >	Policy class for deallocator that uses delete to delete a pointer which is used by RCP
CTeuchos::DeallocFunctorDelete< T, DeleteFunctor >	Deallocator subclass that Allows any functor object (including a function pointer) to be used to free an object
CTeuchos::DeallocFunctorHandleDelete< T, DeleteHandleFunctor >	Deallocator subclass that Allows any functor object (including a function pointer) to be used to free a handle (i.e. pointer to pointer) to an object
CTeuchos::DeallocNull< T >	Policy class for deallocator for non-owned RCPs
CTeuchos::DeallocStdSharedPtr< T >	Teuchos::RCP Deallocator class that wraps a std::shared_ptr
CTeuchos::DefaultBLASImpl< OrdinalType, ScalarType >	Default implementation for BLAS routines
CTeuchos::BLAS< OrdinalType, ScalarType >	Templated BLAS wrapper
CTeuchos::SerialBandDenseMatrix< OrdinalType, ScalarType >	This class creates and provides basic support for banded dense matrices of templated type
CTeuchos::SerialBandDenseSolver< OrdinalType, ScalarType >	A class for representing and solving banded dense linear systems
CTeuchos::SerialDenseMatrix< OrdinalType, ScalarType >	This class creates and provides basic support for dense rectangular matrix of templated type
CTeuchos::SerialDenseSolver< OrdinalType, ScalarType >	A class for solving dense linear problems
CTeuchos::SerialQRDenseSolver< OrdinalType, ScalarType >	A class for solving dense linear problems
CTeuchos::SerialSpdDenseSolver< OrdinalType, ScalarType >	A class for constructing and using Hermitian positive definite dense matrices
CTeuchos::SerialSymDenseMatrix< OrdinalType, ScalarType >	This class creates and provides basic support for symmetric, positive-definite dense matrices of templated type
CTeuchos::SerialTriDiMatrix< OrdinalType, ScalarType >	This class creates and provides basic support for TriDi matrix of templated type
CTeuchos::DefaultComm< OrdinalType >	Return a default global communicator appropriate for the build
CTeuchos::DefaultSerializer< Ordinal, T >	A class for instantiating a default serialization object
CTeuchos::DependencySheet	A Dependency sheet keeps track of dependencies between various ParameterEntries
CTeuchos::DependencyXMLConverterDB	Provides ability to lookup DependencyXMLConverterDB
CTeuchos::DirectSerializationTraits< Ordinal, T >	Serialization traits for objects that support direct serialization
CTeuchos::DirectSerializationTraits< Ordinal, char >
CTeuchos::DirectSerializationTraits< Ordinal, double >
CTeuchos::DirectSerializationTraits< Ordinal, float >
CTeuchos::DirectSerializationTraits< Ordinal, int >
CTeuchos::DirectSerializationTraits< Ordinal, long int >
CTeuchos::DirectSerializationTraits< Ordinal, long long int >
CTeuchos::DirectSerializationTraits< Ordinal, long unsigned int >
CTeuchos::DirectSerializationTraits< Ordinal, short int >
CTeuchos::DirectSerializationTraits< Ordinal, signed char >
CTeuchos::DirectSerializationTraits< Ordinal, std::pair< P1, P2 > >
CTeuchos::DirectSerializationTraits< Ordinal, unsigned char >
CTeuchos::DirectSerializationTraits< Ordinal, unsigned int >
CTeuchos::DirectSerializationTraits< Ordinal, unsigned long long int >
CTeuchos::DirectSerializationTraits< Ordinal, unsigned short int >
CTeuchos::StringToIntMap::DoesNotExist
CTeuchos::DummyObjectGetter< T >	Class for retrieving a dummy object of type T
CTeuchos::DummyObjectGetter< AndCondition >	Specialized class for retrieving a dummy object of type AndCondition
CTeuchos::DummyObjectGetter< AnyNumberParameterEntryValidator >	Specialized class for retrieving a dummy object of type AnyNumberParameterEntryValidator
CTeuchos::DummyObjectGetter< ArrayValidator< ValidatorType, EntryType > >	Specialized class for retrieving a dummy object of type ArrayValidator
CTeuchos::DummyObjectGetter< BoolCondition >	Specialized class for retrieving a dummy object of type BoolCondition
CTeuchos::DummyObjectGetter< BoolValidatorDependency >	Specialized class for retrieving a dummy object of type BoolValidatorDependency
CTeuchos::DummyObjectGetter< BoolVisualDependency >	Specialized class for retrieving a dummy object of type BoolVisualDependency
CTeuchos::DummyObjectGetter< ConditionVisualDependency >	Specialized class for retrieving a dummy object of type ConditionVisualDependency
CTeuchos::DummyObjectGetter< EnhancedNumberValidator< T > >	Specialized class for retrieving a dummy object of type EnhancedNumberValidator<T>
CTeuchos::DummyObjectGetter< EqualsCondition >	Specialized class for retrieving a dummy object of type EqualsCondition
CTeuchos::DummyObjectGetter< FileNameValidator >	Specialized class for retrieving a dummy object of type FileNameValidator
CTeuchos::DummyObjectGetter< NotCondition >	Specialized class for retrieving a dummy object of type NotCondition
CTeuchos::DummyObjectGetter< NumberArrayLengthDependency< DependeeType, DependentType > >	Specialized class for retrieving a dummy object of type NumberArrayLengthDependency
CTeuchos::DummyObjectGetter< NumberCondition< T > >	Specialized class for retrieving a dummy object of type NumberCondition
CTeuchos::DummyObjectGetter< NumberVisualDependency< T > >	Specialized class for retrieving a dummy object of type NumberVisualDependency
CTeuchos::DummyObjectGetter< OrCondition >	Specialized class for retrieving a dummy object of type OrCondition
CTeuchos::DummyObjectGetter< RangeValidatorDependency< T > >	Specialized class for retrieving a dummy object of type RangeValidatorDependency
CTeuchos::DummyObjectGetter< StringCondition >	Specialized class for retrieving a dummy object of type StringCondition
CTeuchos::DummyObjectGetter< StringToIntegralParameterEntryValidator< IntegralType > >	Specialized class for retrieving a dummy object of type StringToIntegralParameterEntryValidator<IntegralType>
CTeuchos::DummyObjectGetter< StringValidator >	Specialized class for retrieving a dummy object of type StringValidator
CTeuchos::DummyObjectGetter< StringValidatorDependency >	Specialized class for retrieving a dummy object of type StringValidatorDependency
CTeuchos::DummyObjectGetter< StringVisualDependency >	Specialized class for retrieving a dummy object of type StringVisualDependency
CTeuchos::DummyObjectGetter< TwoDArrayValidator< ValidatorType, EntryType > >	Specialized class for retrieving a dummy object of type TwoDArrayValidator
CTeuchos::DummyObjectGetter< TwoDColDependency< DependeeType, DependentType > >	Specialized class for retrieving a dummy object of type TwoDColDependency
CTeuchos::DummyObjectGetter< TwoDRowDependency< DependeeType, DependentType > >	Specialized class for retrieving a dummy object of type TwoDRowDependency
CTeuchos::DuplicateParameterIDsException	Thrown when two parameters in an XML file have the same ID
CTeuchos::DuplicateValidatorIDsException	Constructs a CantFindParameterEntryConverterException
CTeuchos::MatrixMarket::Raw::Element< Scalar, Ordinal >	Stores one entry of a sparse matrix
CTeuchos::EmbeddedObjDealloc< T, Embedded, Dealloc >	A deallocator class that wraps a simple value object and delegates to another deallocator object
CTeuchos::EmptyXMLError	Thrown when attempting to parse an empty XML std::string
CTeuchos::EnhancedNumberTraits< T >	Class defining the traits of the number type being used in an EnhancedNumberValidator
CTeuchos::ExceptionBase	Base exception class for Teuchos
CTeuchos::DanglingReferenceError	Dangling reference error exception class
CTeuchos::DuplicateOwningRCPError	Thrown if a duplicate owning RCP is creatd the the same object
CTeuchos::DuplicateParameterEntryException	Thrown when a Parameter Entry that is already being tracked is attempted to be inserted again into the masterParameterEntryMap and masterIDMap
CTeuchos::DuplicateParameterEntryIDException	Thrown when a Parameter Entry ID that is already being used is attempted to be reused again
CTeuchos::DuplicateParameterSublist	Optionally thrown when a sublist is set twice by either updateParametersFromXmlFile(), updateParametersFromXmlFileAndUpdate() or updateParametersFromXmlString()
CTeuchos::DuplicateValidatorIDException	Thrown when a ParameterEntryValidatorID that is already being used is attempted to be reused again
CTeuchos::IncompatibleIteratorsError	Incompatiable iterators error exception class
CTeuchos::NonconstAccessError	Null reference error exception class
CTeuchos::NullReferenceError	Null reference error exception class
CTeuchos::RangeError	Range error exception class
CTeuchos::StringIndexedOrderedValueObjectContainerBase::InvalidKeyError	Thrown if an invalid string is passed in
CTeuchos::StringIndexedOrderedValueObjectContainerBase::InvalidOrdinalIndexError	Thrown if an invalid ordinal index is passed in
CTeuchos::TabularOutputter::InvalidFieldOutputError
CTeuchos::TabularOutputter::InvalidFieldSpecError
CTeuchos::TabularOutputter::MissingFieldsError
CTeuchos::TabularOutputter::MissingHeaderError
CTeuchos::FILEstream	Teuchos::FILEstream: Combined C FILE and C++ stream
CTeuchos::FilteredIterator< IteratorType, Predicate >	C++ Standard Library compatable filtered iterator
CTeuchos::Flops	The Teuchos Floating Point Operations Class
CTeuchos::FunctionObjectXMLConverterDB	Provides ability to lookup FunctionObjectXMLConverters
CTeuchos::GlobalMPISession	Initialize, finalize, and query the global MPI session
CTeuchos::MatrixMarket::Raw::GraphAdder< Ordinal >	To be used with Checker for "raw" sparse matrix input
CTeuchos::MatrixMarket::Raw::GraphElement< Ordinal >	Stores one entry of a sparse graph
CTeuchos::HashPair< Key, Value >	Helper class for Teuchos::Hashtable, representing a single <key, value> pair
CTeuchos::HashSet< Key >	Templated hashtable-based set
CTeuchos::Hashtable< Key, Value >	Templated hashtable class
CTeuchos::HashUtils	Utilities for generating hashcodes. This is not a true hash ! For all ints and types less than ints it returns the i/p typecasted as an int. For every type more than the size of int it is only slightly more smarter where it adds the bits into int size chunks and calls that an hash. Used with a capacity limited array this will lead to one of the simplest hashes. Ideally this should be deprecated and not used at all
CTeuchos::IDtoValidatorMap	Maps Validators to integers
CTeuchos::Exceptions::InvalidArgument
CTeuchos::InvalidArrayStringRepresentation
CTeuchos::InvalidConditionException
CTeuchos::InvalidDependencyException
CTeuchos::Exceptions::InvalidParameter
CTeuchos::Exceptions::InvalidParameterName
CTeuchos::Exceptions::InvalidParameterType
CTeuchos::Exceptions::InvalidParameterValue
CTeuchos::TypeTraits::is_same< T1, T2 >	Default is_equal traits class has value equal to false, indicating that T1 and T2 are not equal,
CTeuchos::TypeTraits::is_same< T, T >	Partial specialization of is_equal class for equal types, where value equal to true
CTeuchos::StringIndexedOrderedValueObjectContainerBase::KeyObjectPair< ObjType >	A simple aggregate type to bind a key string and and objects value
CTeuchos::LabeledObject	Base class for objects that contain a std::string label
CTeuchos::Describable	Base class for all objects that can describe themselves
CTeuchos::Comm< OrdinalType >
CTeuchos::Comm< int >
CTeuchos::ValueTypeReductionOp< Ordinal, Packet >
CTeuchos::ANDValueReductionOp< Ordinal, Packet >	Standard logical AND operator for booleans
CTeuchos::MaxValueReductionOp< Ordinal, Packet >	Standard Max operator for types with value semantics
CTeuchos::MinValueReductionOp< Ordinal, Packet >	Standard min operator for types with value semantics
CTeuchos::SumValueReductionOp< Ordinal, Packet >	Standard summation operator for types with value semantics
CTeuchos::ValueTypeReductionOp< Ordinal, char >
CTeuchos::CharToValueTypeReductionOpImp< Ordinal, T, typename DefaultSerializer< Ordinal, T >::DefaultSerializerType >
CTeuchos::CharToValueTypeReductionOp< Ordinal, T, typename DefaultSerializer< Ordinal, T >::DefaultSerializerType >	Decorator class that uses traits to convert to and from char[] to typed buffers for objects that use value semantics and then call a type-specific reduction object
CTeuchos::CharToValueTypeReductionOpImp< Ordinal, T, DefaultSerializer< Ordinal, T >::DefaultSerializerType >
CTeuchos::CharToValueTypeReductionOp< Ordinal, T, typename DefaultSerializer< Ordinal, T >::DefaultSerializerType >	Decorator class that uses traits to convert to and from char[] to typed buffers for objects that use value semantics and then call a type-specific reduction object
CTeuchos::CharToReferenceTypeReductionOp< Ordinal, T >	Decorator class that uses a strategy object to convert to and from char[] to typed buffers for objects that use reference semantics and then call a type-specific reduction object
CTeuchos::CharToValueTypeReductionOpImp< Ordinal, T, Serializer >	Decorator class that uses traits to convert to and from char[] to typed buffers for objects that use value semantics and then call a type-specific reduction object
CTeuchos::CharToValueTypeReductionOp< Ordinal, T, Serializer >	Decorator class that uses traits to convert to and from char[] to typed buffers for objects that use value semantics and then call a type-specific reduction object
CTeuchos::ValueTypeReductionOp< Ordinal, std::pair< ScalarType, IndexType > >
CTeuchos::MaxLoc< Ordinal, ScalarType, IndexType >	Teuchos version of MPI_MAXLOC
CTeuchos::MinLoc< Ordinal, ScalarType, IndexType >	Teuchos version of MPI_MINLOC
CTeuchos::MinLocNonzero< Ordinal, ScalarType, IndexType >	Same as MinLoc, but don't allow zero
CTeuchos::ValueTypeReductionOp< Ordinal, std::pair< double, int > >
CTeuchos::Comm< Ordinal >	Abstract interface for distributed-memory communication
CTeuchos::SerialComm< Ordinal >	Concrete serial communicator subclass
CTeuchos::CommRequest< OrdinalType >	Encapsulation of a pending nonblocking communication operation
CTeuchos::Condition	A Condition determines whether or not a particular set of conditions are currently occuring
CTeuchos::BoolLogicCondition	An abstract parent class for all Bool Logic Conditions
CTeuchos::AndCondition	A Bool Logic Condition that returns the result or perfroming a logical AND on the conditions
CTeuchos::EqualsCondition	A Bool Logic Condition that returns the result or perfroming a logical EQUALS on the conditions
CTeuchos::OrCondition	A Bool Logic Condition that returns the result or perfroming a logical OR on the conditions
CTeuchos::NotCondition	A Not condition returns the result of performing a logical NOT on a given condition
CTeuchos::ParameterCondition	An Abstract Base class for all ParameterConditions
CTeuchos::BoolCondition	A Bool Condition is a Parameter Condition that evaluates whether or not a Boolean parameter is ture
CTeuchos::NumberCondition< T >	A Number Condition is a Parameter Condition that evaluates whether or not a number parameter is greater than 0 (or some other number based on a given function). If the parameter is greater than 0 this is interperted as the condition being "true". Otherwise the condition is interperted as false
CTeuchos::StringCondition	A String Condition is a Parameter Condition that evaluates whether or not a string parameter has taken on a particular value or set of values
CTeuchos::ConditionXMLConverter	An abstract base class for converting Dependencies to and from XML
CTeuchos::BoolLogicConditionConverter	An xml converter for BoolLogicConditions
CTeuchos::AndConditionConverter	An xml converter for AndConditions
CTeuchos::EqualsConditionConverter	An xml converter for EqualsConditions
CTeuchos::OrConditionConverter	An xml converter for OrConditions
CTeuchos::NotConditionConverter	An xml converter for NotConditions
CTeuchos::ParameterConditionConverter	An xml converter for ParameterConditions
CTeuchos::BoolConditionConverter	An xml converter for BoolConditions
CTeuchos::NumberConditionConverter< T >	An xml converter for NumberConditions The valid XML represntation for a NumberCondition is:
CTeuchos::StringConditionConverter	An xml converter for StringConditions The valid XML represntation for a StringCondition is:
CTeuchos::ConstHandle< PointerType >	Templated handle class with strong const protection
CTeuchos::Handle< PointerType >	Generic templated handle class
CTeuchos::Dependency	This class represents a depndency between elements in a Parameter List
CTeuchos::ArrayModifierDependency< DependeeType, DependentType >	An abstract base class for all dependencies which modify the dimensional attributes of an Array parameter
CTeuchos::NumberArrayLengthDependency< DependeeType, DependentType >	A NumberArrayLengthDependency says the following about the relationship between two parameters: The length of the dependent's array depends on the value of the dependee
CTeuchos::TwoDArrayModifierDependency< DependeeType, DependentType >	A dependency in which some attribute of a TwoDArray in a parameter depends on the value of another parameter
CTeuchos::TwoDColDependency< DependeeType, DependentType >	A dependency in which the number of rows in a parameter with a TwoDArray depends on the value of another parameter
CTeuchos::TwoDRowDependency< DependeeType, DependentType >	A dependency in which the number of rows in a parameter with a TwoDArray depends on the value of another parameter
CTeuchos::ValidatorDependency	An abstract base class for all validator dependencies
CTeuchos::BoolValidatorDependency	A BoolValidatorDependency says the following about the relationship between two parameters: Dependening on the value of the dependee, the dependent should use a particular validator from a given set of validators
CTeuchos::RangeValidatorDependency< T >	A RangeValidatorDependency says the following about the relationship between two parameters: Dependening on the value of the dependee, the dependent should use a particular validator from a given set of validators
CTeuchos::StringValidatorDependency	A StringValidatorDependency says the following about the relationship between two parameters: Dependening on the value of the dependee, the dependent should use a particular validator from a given set of validators
CTeuchos::VisualDependency	An abstract parent class for all visual dependencies
CTeuchos::BoolVisualDependency	A bool visual dependency says the following about the relationship between two elements in a Parameter List: Depending on whether or not the dependee is true or false, the dependent may or may not be displayed to the user in a GUI
CTeuchos::ConditionVisualDependency	A condition visual dependency says the following about the relationship between elements in a Parameter List: Depending on whether or not the dependee(s) statisfy a particual condition, the dependent may or may not be displayed to the user in a UI
CTeuchos::NumberVisualDependency< T >	A number visual dependency says the following about the relationship between two elements in a Parameter List: Depending on whether or not the dependee has a certain value, the dependent may or may not be displayed to the user in a UI
CTeuchos::StringVisualDependency	A string visual depdencies says the following about the relationship between two elements in a Parameter List: Depending on whether or not the dependee has a particular value, the dependent may or may not be displayed to the user in a UI
CTeuchos::DependencyXMLConverter	An abstract base class for converting Dependencies to and from XML
CTeuchos::ArrayModifierDependencyXMLConverter< DependeeType, DependentType >	A converter used to convert ArrayModifierDepdencies to and from xml
CTeuchos::NumberArrayLengthDependencyXMLConverter< DependeeType, DependentType >	An xml converter for NumberArrayLengthDependencies
CTeuchos::TwoDColDependencyXMLConverter< DependeeType, DependentType >	A class for converting TwoDColDependencies to and from XML
CTeuchos::TwoDRowDependencyXMLConverter< DependeeType, DependentType >	A class for converting TwoDRowDependencies to and from XML
CTeuchos::ValidatorDependencyXMLConverter	An xml converter for ValidatorDependencies
CTeuchos::BoolValidatorDependencyXMLConverter	An xml converter for BoolValidatorDependencies
CTeuchos::RangeValidatorDependencyXMLConverter< T >	An xml converter for RangeValidatorDependencies
CTeuchos::StringValidatorDependencyXMLConverter	An xml converter for StringValidatorDependencies
CTeuchos::VisualDependencyXMLConverter	An xml converter for VisualDepenencies
CTeuchos::BoolVisualDependencyXMLConverter	An xml converter for BoolVisualDepenencies
CTeuchos::ConditionVisualDependencyXMLConverter	An xml converter for ConditionVisualDependencies
CTeuchos::NumberVisualDependencyXMLConverter< T >	An xml converter for NumberVisualDependencies
CTeuchos::StringVisualDependencyXMLConverter	An xml converter for StringVisualDepenencies
CTeuchos::FunctionObject	A function object represents an arbitrary function
CTeuchos::SimpleFunctionObject< DependeeType >
CTeuchos::SimpleFunctionObject< OperandType >	A simple function object that applies a given operand to a spcified arguement using a specific operator
CTeuchos::AdditionFunction< OperandType >	A simple function object that adds a specififed value from the given arguement in the runFunction function
CTeuchos::DivisionFunction< OperandType >	A simple function object that divides a specififed value from the given arguement in the runFunction function
CTeuchos::MultiplicationFunction< OperandType >	A simple function object that multiplys a specififed value from the given arguement in the runFunction function
CTeuchos::SubtractionFunction< OperandType >	A simple function object that subtracts a specififed value from the given arguement in the runFunction function
CTeuchos::FunctionObjectXMLConverter	An abstract base class for converting FunctionObjects to and from XML
CTeuchos::SimpleFunctionXMLConverter< OperandType >	An xml converter for SimpleFunctionObjects
CTeuchos::AdditionFunctionXMLConverter< OperandType >	Class for converting AdditionFunction objects to and from XML
CTeuchos::DivisionFunctionXMLConverter< OperandType >	Class for converting DivisionFunction objects to and from XML
CTeuchos::MultiplicationFunctionXMLConverter< OperandType >	Class for converting MultiplicationFunction objects to and from XML
CTeuchos::SubtractionFunctionXMLConverter< OperandType >	Class for converting SubtractionFunction objects to and from XML
CTeuchos::ParameterEntryValidator	Abstract interface for an object that can validate a ParameterEntry's value
CTeuchos::AbstractArrayValidator< FileNameValidator, std::string >
CTeuchos::ArrayValidator< FileNameValidator, std::string >
CTeuchos::ArrayFileNameValidator	Convience class for FileNameValidators that are to be applied to arrays
CTeuchos::TwoDArrayValidator< FileNameValidator, std::string >
CTeuchos::TwoDArrayFileNameValidator	Convience class for FileNameValidators that are to be applied to TwoDArrays
CTeuchos::AbstractArrayValidator< EnhancedNumberValidator< T >, T >
CTeuchos::ArrayValidator< EnhancedNumberValidator< T >, T >
CTeuchos::ArrayNumberValidator< T >	Convience class for EnhancedNumberValidators that are to be applied to arrays
CTeuchos::TwoDArrayValidator< EnhancedNumberValidator< T >, T >
CTeuchos::TwoDArrayNumberValidator< T >	Convience class for EnhancedNumberValidators that are to be applied to TwoDArray
CTeuchos::AbstractArrayValidator< StringValidator, std::string >
CTeuchos::ArrayValidator< StringValidator, std::string >
CTeuchos::ArrayStringValidator	Convience class for StringValidators that are to be applied to arrays
CTeuchos::TwoDArrayValidator< StringValidator, std::string >
CTeuchos::TwoDArrayStringValidator	Convience class for StringValidators that are to be applied to TwoDArrays
CTeuchos::StringToIntegralParameterEntryValidator< int >
CTeuchos::AbstractArrayValidator< ValidatorType, EntryType >	An abstract base class for all ArrayValidators
CTeuchos::ArrayValidator< ValidatorType, EntryType >	Takes a validator, wraps it, and applies it to an array
CTeuchos::TwoDArrayValidator< ValidatorType, EntryType >	Takes a validator, wraps it, and applies it to a TwoDArray
CTeuchos::AnyNumberParameterEntryValidator	Standard implementation of a ParameterEntryValidator that accepts numbers from a number of different formats and converts them to numbers in another format
CTeuchos::BoolParameterEntryValidator	Standard implementation of a BoolParameterEntryValidator that accepts bool values (true/false) or string values for bool ("true"/"false")
CTeuchos::EnhancedNumberValidator< T >	Class uesd to validate a particular type of number
CTeuchos::FileNameValidator	Validate a file name entry
CTeuchos::StringToIntegralParameterEntryValidator< IntegralType >	Standard implementation of a ParameterEntryValidator that maps from a list of strings to an enum or integer value
CTeuchos::StringValidator	A simple validator that only allows certain string values to be choosen or simply enforces that a particular parameter have a std::string for a value
CTeuchos::ParameterEntryXMLConverter	A class used to convert parameter entries to xml and vice versa
CTeuchos::AnyParameterEntryConverter	A last resort converter for when no others will do
CTeuchos::StandardTemplatedParameterConverter< T >	A standard ParameterEntryXMLConverter for most data types
CTeuchos::ParameterListModifier	Abstract interface for an object that can modify both a parameter list and the parameter list being used during the validation stage
CTeuchos::Polynomial< CoeffT >	Lightweight container class to represent a simple polynomial
CTeuchos::ReferenceTypeReductionOp< Ordinal, T >	Base interface class for user-defined reduction operations for objects that use reference semantics
CTeuchos::UnitTestBase	Unit test base class
CTeuchos::ValidatorXMLConverter	An abstract base class for converting ParameterEntryValidators to and from XML
CTeuchos::AnyNumberValidatorXMLConverter	Converts AnyNumberParameterEntryValidators to and from XML
CTeuchos::BoolValidatorXMLConverter	Converts BoolParameterEntryValidators to and from XML
CTeuchos::EnhancedNumberValidatorXMLConverter< T >	Converts EnhancedNumberValidators to and from XML
CTeuchos::FileNameValidatorXMLConverter	Converts FileNameValidators to and from XML
CTeuchos::StringToIntegralValidatorXMLConverter< IntegralType >	Convert a StringToIntegralParameterEntryValidator to and from XML
CTeuchos::StringValidatorXMLConverter	Converts StringValidators to and from XML
CTeuchos::ValueTypeReductionOp< Ordinal, T >	Base interface class for user-defined reduction operations for objects that use value semantics
CTeuchos::Language	The main class for users to define a language using TeuchosParser
CTeuchos::LAPACK< OrdinalType, ScalarType >	The Templated LAPACK Wrapper Class
CTeuchos::SerialBandDenseSolver< OrdinalType, ScalarType >	A class for representing and solving banded dense linear systems
CTeuchos::SerialDenseSolver< OrdinalType, ScalarType >	A class for solving dense linear problems
CTeuchos::SerialQRDenseSolver< OrdinalType, ScalarType >	A class for solving dense linear problems
CTeuchos::SerialSpdDenseSolver< OrdinalType, ScalarType >	A class for constructing and using Hermitian positive definite dense matrices
CTrilinos::Details::LinearSolver< MV, OP, NormType >	Interface for a method for solving linear system(s) AX=B
CTrilinos::Details::LinearSolverFactory< MV, OP, NormType >	Interface for a "factory" that creates solvers
CTrilinos::Details::Impl::LinearSolverFactoryRepository< MV, OP, NormType >	Repository of solver factories
CTrilinos::LinearSolverSetupFailure	Exception reporting failure in setting up a linear solver
CTeuchos::m_bad_cast	Exception class for bad cast
Cmap	This class creates a basic std::map object for platforms where the std::map is deficient, otherwise the std::map is injected into the Teuchos namespace
CTeuchos::MissingConditionTagException	Thrown when no condtion tag is found when converting a ConditionVisualDependency from XML
CTeuchos::MissingDependeeException	Thrown when no dependes of a dependency can't be found when converting the dependency to or from XML
CTeuchos::MissingDependeesException	Thrown when no dependess of a dependency are specified when converting the dependency from XML
CTeuchos::MissingDependentException	Thrown when a dependent of a dependency cant be found when converting the dependency to or from XML
CTeuchos::MissingDependentsException	Thrown when no dependents of a dependency are specified when converting the dependency from XML
CTeuchos::MissingParameterEntryDefinitionException	Thrown when a referenced ParameterEntry can't be found
CTeuchos::MissingRangesAndValidatorsTagException	Thrown when the rangesAndValidators tag for the RangeValidatorDepencyConverter can't be found
CTeuchos::MissingValidatorDefinitionException	Thrown when a referenced validator can't be found
CTeuchos::MissingValidatorException	Thrown when converting a dependency that has validaotrs to and from XML. This excetpion indicates that a specified validator could not be found
CTeuchos::MissingValuesAndValidatorsTagException	Thrown when converting a StrinvValidatorDependcny from XML and no valuesAndValidators tag is found
CTeuchos::MissingValuesTagException	Thrown when a StringConditon is missing it's Value tag
CTeuchos::Details::MpiCommRequest	MPI implementation of CommRequest<int>
CTeuchos::NoNameAttributeExecption	Thrown when a parameter entry tag is missing it's name attribute
CTeuchos::NoTypeAttributeExecption	Thrown when a parameter entry tag is missing it's type attribute
CTeuchos::NoValueAttributeExecption	Thrown when a parameter entry tag is missing it's value attribute
CTeuchos::NullIteratorTraits< Iter >	Base traits class for getting a properly initialized null pointer
CTeuchos::NullIteratorTraits< ArrayRCP< T > >	Traits specialization for ArrayRCP
CTeuchos::NullIteratorTraits< RCP< T > >	Traits specialization for RCP
CTeuchos::NullIteratorTraits< std::reverse_iterator< Iter > >	Partial specialization for std::reverse_iterator
CTeuchos::Object	The base Teuchos class
CTeuchos::SerialBandDenseSolver< OrdinalType, ScalarType >	A class for representing and solving banded dense linear systems
CTeuchos::SerialDenseSolver< OrdinalType, ScalarType >	A class for solving dense linear problems
CTeuchos::SerialQRDenseSolver< OrdinalType, ScalarType >	A class for solving dense linear problems
CTeuchos::SerialSpdDenseSolver< OrdinalType, ScalarType >	A class for constructing and using Hermitian positive definite dense matrices
CTeuchos::SerialTriDiMatrix< OrdinalType, ScalarType >	This class creates and provides basic support for TriDi matrix of templated type
CTeuchos::OpaqueWrapper< Opaque >	Base class for wrapped opaque objects
CTeuchos::OpaqueWrapperWithFree< Opaque, OpaqueFree >	Subclass for wrapped opaque objects with a free function
CTeuchos::StringIndexedOrderedValueObjectContainerBase::OrdinalIndex	A safe ordinal index type that default initializes to a special value
CTeuchos::OrdinalTraits< T >	This structure defines some basic traits for the ordinal field type
CTeuchos::StackedTimer::OutputOptions
CTeuchos::ParameterEntry	This object is held as the "value" in the Teuchos::ParameterList std::map
CTeuchos::ParameterEntryXMLConverterDB	Provides ability to lookup ParameterEntryXMLConverters
CTeuchos::ParameterList	A list of parameters of arbitrary type
CTeuchos::ParameterListAcceptor	Interface for objects that can accept a ParameterList
CTeuchos::ObjectBuilder< ObjectType >	Generic parameterlist driven bulider class
CTeuchos::ParameterListAcceptorDefaultBase	Intermediate node base class for objects that accept parameter lists that implements some of the needed behavior automatically
CTeuchos::ParameterListNonAcceptor	Mix-in implementation subclass to be inherited by concrete subclasses who's interface says that they take a parameter list but do not have any parameters yet
CTeuchos::ParameterXMLFileReader
CTeuchos::CommandLineProcessor::ParseError	Thrown if a parse std::exception occurs and throwExceptions==true
CTeuchos::CommandLineProcessor::HelpPrinted	Thrown if –help was specified and throwExceptions==true
CTeuchos::CommandLineProcessor::UnrecognizedOption	Thrown if an unrecognized option was found and throwExceptions==true
CTeuchos::ParserFail	Tries to create LALR(1) parser tables for a given grammar
CTeuchos::PerformanceMonitorBase< T >	Common capabilities for collecting and reporting performance data across processors
CTeuchos::PerformanceMonitorBase< Time >
CTeuchos::TimeMonitor	Scope guard for Time, that can compute MPI collective timer statistics
CTeuchos::SyncTimeMonitor	A TimeMonitor that waits at a MPI barrier before destruction
CTeuchos::PolynomialTraits< Scalar >	Traits class for polynomial coefficients in Teuchos::Polynomial
CTeuchos::PostModNothing< T_impl >	Default post-modification policy class for AbstractFactorStd which does nothing!
CTeuchos::ParameterList::PrintOptions	Utility class for setting and passing in print options
CTeuchos::Ptr< T >	Simple wrapper class for raw pointers to single objects where no persisting relationship exists
CTeuchos::Range1D	Subregion Index Range Class
CTeuchos::RawWorkspace	Encapulsation object for raw temporary workspace that has been allocated. These objects can only be created on the stack and should not be included as the member of any other classes
CTeuchos::RCP< T >	Smart reference counting pointer class for automatic garbage collection
CTeuchos::RCPComp	Struct for comparing two RCPs. Simply compares the raw pointers contained within the RCPs
CTeuchos::RCPConstComp	Struct for comparing two RCPs. Simply compares the raw pointers contained within the RCPs
CTeuchos::RCPDeleter< T >	boost::shared_ptr deleter class that wraps a Teuchos::RCP
CTeuchos::RCPNode	Node class to keep track of address and the reference count for a reference-counted utility class and delete the object
CTeuchos::RCPNodeTmpl< T, Dealloc_T >	Templated implementation class of RCPNode that has the responsibility for deleting the reference-counted object
CTeuchos::RCPNodeHandle	Handle class that manages the RCPNode's reference counting
CTeuchos::RCPNodeTracer::RCPNodeStatistics	RCP statistics struct
CTeuchos::RCPNodeThrowDeleter	Deletes a (non-owning) RCPNode but not it's underlying object in case of a throw
CTeuchos::RCPNodeTracer	Debug-mode RCPNode tracing class
CTeuchos::MatrixMarket::Raw::Reader< Scalar, Ordinal >	Read a sparse matrix from a Matrix Market file into raw CSR (compressed sparse row) storage
CTeuchos::Reader	The main class for users to read text using TeuchosParser
CTeuchos::ReaderTables	Parser and lexer tables specifying how to read a Language
CTeuchos::Details::Allocator< T >::rebind< U >	Mapping to an Allocator for a different type U
CTeuchos::ReferenceTypeDeserializationBuffer< Ordinal, T >	Encapsulate how an array of non-const objects with reference sematics is deserialized from a char[] array and then serialized back into the char[] buffer again
CTeuchos::ReferenceTypeSerializationBuffer< Ordinal, T >	Encapsulate how an array of non-const objects with reference sematics is serialized into a char[] array and deserialized again
CTeuchos::RelErrSmallNumber< hasMachineParameters, Scalar >
CTeuchos::RelErrSmallNumber< false, Scalar >
CTeuchos::RelErrSmallNumber< true, Scalar >
CTeuchos::MatrixMarket::details::ScalarAssigner< Scalar, isComplex >	Implementation detail of assignScalar()
CTeuchos::ScalarTraits< T >	This structure defines some basic traits for a scalar field type
CTeuchos::ScopedThreadLock< T >	Stack-based object for locking a thread
CTeuchos::StringIndexedOrderedValueObjectContainerBase::SelectActive< ObjType >	Predicate for selecting active object entries in filtered iterator
CTeuchos::SerialBandDenseMatrixPrinter< OrdinalType, ScalarType >	Ostream manipulator for SerialBandDenseMatrix
CTeuchos::SerialDenseMatrixPrinter< OrdinalType, ScalarType >	Ostream manipulator for SerialDenseMatrix
CTeuchos::SerialDenseVectorPrinter< OrdinalType, ScalarType >	Ostream manipulator for SerialDenseVector
CTeuchos::SerializationTraits< Ordinal, T >	Serialization traits class for types T that use value semantics
CTeuchos::ValueTypeSerializer< Ordinal, T >	Serialization class for types T that use value semantics
CTeuchos::Serializer< Ordinal, T >	Strategy interface for the indirect serializing and deserializing objects of a given type handled using reference semantics
CTeuchos::SerialSymDenseMatrixPrinter< OrdinalType, ScalarType >	Ostream manipulator for SerialSymDenseMatrix
CTeuchos::MatrixMarket::details::SetScientific< Scalar, isFloatingPoint >	Temporarily make an output stream use scientific notation with sufficient precision
CTeuchos::SetScientific< Scalar, isFloatingPoint >	Temporarily make an output stream use scientific notation with sufficient precision
CTeuchos::SetScientific< Scalar, false >	Partial specialization of SetScientific for non-floating-point types
CTeuchos::SharedAccessPolicy	Single policy class defining an approach for sharing an integral object across threads as well as a general heavy-weight locking policy
CTeuchos::SimpleObjectDB< T >	Simple object object database
CTeuchos::SimpleObjectTable< T >	This class provides a central place to store objects
CTeuchos::StackedTimer	This class allows one to push and pop timers on and off a stack
CTeuchos::StdSharedPtrRCPDeleter< T >	std::shared_ptr deleter class that wraps a Teuchos::RCP
CTeuchos::StringIndexedOrderedValueObjectContainerBase	Base types for StringIndexedOrderedValueObjectContainer
CTeuchos::StringIndexedOrderedValueObjectContainer< ParameterEntry >
CTeuchos::StringIndexedOrderedValueObjectContainer< ObjType >	String indexed ordered value-type object container class
CTeuchos::StringToIntMap	Map a std::string to an enumeration
CTeuchos::StrUtils	Provides std::string manipulation utilities that are not provided in the standard C++ std::string class
CTeuchos::MatrixMarket::SymmetrizingAdder< AdderType >	Adds entries with optional symmetry to a sparse matrix
CTeuchos::MatrixMarket::SymmetrizingGraphAdder< AdderType >	Adds entries with optional symmetry to a sparse graph
CTeuchos::TableColumn
CTeuchos::TableEntry	An entry, perhaps compound, to be written into a table
CTeuchos::CompoundEntryWithParentheses	An entry containing two subentries, with the second to be written in parentheses after the first. For example,
CTeuchos::DoubleEntry	A table entry that is a simple double-precision number
CTeuchos::IntEntry	A table entry that is a simple integer
CTeuchos::StringEntry	A table entry that is a simple std::string
CTeuchos::TableFormat	Encapsulation of formatting specifications for writing data in a clean tabular form
CTeuchos::TabularOutputter	Utility class that makes it easy to create formatted tables of output
CTeuchos::TestRelErr< T1, T2, Enabled >	Compute, check and optionally print the relative error in two scalars
CTeuchos::ThreadLock	Basic portable thread lock primative class
CTeuchos::Time	Wall-clock timer
CTeuchos::CommandLineProcessor::TimeMonitorSurrogate	Interface by which CommandLineProcessor may use TimeMonitor
CTeuchos::TimeMonitorSurrogateImpl	Implementation of TimeMonitorSurrogate that invokes TimeMonitor
CTeuchos::TimeMonitorSurrogateImplInserter	Injects run-time dependency of a class on TimeMonitor
CTeuchos::TooManyDependeesException	Thrown when a Dependency has too many dependees specified in its XML
CTeuchos::ToStringTraits< T >	Default traits class for converting objects into strings
CTeuchos::ToStringTraits< bool >	Specialization for bool
CTeuchos::ToStringTraits< double >	Specialization for double
CTeuchos::ToStringTraits< ERCPStrength >	Traits class specialization for toString(...) function for converting from ERCPStrength to std::string
CTeuchos::ToStringTraits< float >	Specialization for float
CTeuchos::ToStringTraits< std::pair< T1, T2 > >	Partial specialization for std::pair<T1, T2>
CTeuchos::ToStringTraits< std::string >	Specialization for std::string
CTeuchos::TreeBuildingXMLHandler	TreeBuildingXMLHandler assembles a XMLObject from your XML input
CTeuchos::TwoDArray< T >	A thin wrapper around the Array class which causes it to be interpreted as a 2D Array
CTeuchos::TypeNameTraits< T >	Default traits class that just returns typeid(T).name()
CTeuchos::TypeNameTraits< Array< T > >	TypeNameTraits specialization for Array
CTeuchos::TypeNameTraits< ParameterList >	Traits specialization
CTeuchos::TypeNameTraits< TwoDArray< T > >	TypeNameTraits specialization for Array
CTeuchos::UndefinedEnhancedNumberTraits< T >	Default structure used by EnhancedNumberTraits<T> to produce a compile time error when the specialization does not exist for type T
CTeuchos::UndefinedSerializationTraits< T >	Report an error if a specialization of SerializationTraits is missing
CTeuchos::UnitTestRepository	Singleton unit testing repository
CTeuchos::Utils	This class provides some basic std::string and floating-point utilities for Teuchos
CTeuchos::ValidatorFactory	Factory for ParameterEntryValidator objects
CTeuchos::ValidatortoIDMap	A class for mapping validators to integers
CTeuchos::ValidatorXMLConverterDB	Provides ability to lookup ValidatorXMLConverterDB
CTeuchos::ValuesTagMissingException	Thrown when a StringVisualDependency is being converted from XML and no Values tag is found
CTeuchos::ValueTolerance	ValueTolerance is a struct to keep a tuple of value and a tolerance. The tolerance can be either expressed as a relative or through an upper and lower bound
CTeuchos::ValueTypeConversionTraits< TypeTo, TypeFrom >	Default traits class for all conversions between value types
CTeuchos::ValueTypeConversionTraits< double, long double >	Convert from long double to double
CTeuchos::ValueTypeConversionTraits< double, std::string >	Convert an std::string to a double
CTeuchos::ValueTypeConversionTraits< float, double >	Convert from double to float
CTeuchos::ValueTypeConversionTraits< float, long double >	Convert from long double to float
CTeuchos::ValueTypeConversionTraits< float, long long >	Convert from long long to float
CTeuchos::ValueTypeConversionTraits< float, std::string >	Convert an std::string to a float
CTeuchos::ValueTypeConversionTraits< float, unsigned long long >	Convert from unsigned long long to float
CTeuchos::ValueTypeConversionTraits< int, double >	Convert from double to int
CTeuchos::ValueTypeConversionTraits< int, float >	Convert from float to int
CTeuchos::ValueTypeConversionTraits< int, long >	Convert from long to int
CTeuchos::ValueTypeConversionTraits< int, long long >	Convert from long long to int
CTeuchos::ValueTypeConversionTraits< int, std::string >	Convert an std::string to an int
CTeuchos::ValueTypeConversionTraits< int, unsigned int >	Convert from unsigned int to int
CTeuchos::ValueTypeConversionTraits< int, unsigned long >	Convert from unsigned long to int
CTeuchos::ValueTypeConversionTraits< int, unsigned long long >	Convert from unsigned long long to int
CTeuchos::ValueTypeConversionTraits< long double, std::string >	Convert an std::string to a long double
CTeuchos::ValueTypeConversionTraits< long long, double >	Convert from double to long long
CTeuchos::ValueTypeConversionTraits< long long, float >	Convert from float to long long
CTeuchos::ValueTypeConversionTraits< long long, std::string >	Convert an std::string to a long long
CTeuchos::ValueTypeConversionTraits< long long, unsigned long long >	Convert from unsigned long long to long long
CTeuchos::ValueTypeConversionTraits< long, double >	Convert from double to long
CTeuchos::ValueTypeConversionTraits< long, float >	Convert from float to long
CTeuchos::ValueTypeConversionTraits< long, std::string >	Convert an std::string to a long
CTeuchos::ValueTypeConversionTraits< long, unsigned int >	Convert from unsigned int to long
CTeuchos::ValueTypeConversionTraits< long, unsigned long >	Convert from unsigned long to long
CTeuchos::ValueTypeConversionTraits< OutType, std::string >	Convert an std::string to a type OutType
CTeuchos::ValueTypeConversionTraits< short, double >	Convert from double to short
CTeuchos::ValueTypeConversionTraits< short, float >	Convert from float to short
CTeuchos::ValueTypeConversionTraits< short, int >	Convert from int to short
CTeuchos::ValueTypeConversionTraits< short, long >	Convert from long to short
CTeuchos::ValueTypeConversionTraits< short, std::string >	Convert an std::string to a short
CTeuchos::ValueTypeConversionTraits< short, unsigned short >	Convert from unsigned short to short
CTeuchos::ValueTypeConversionTraits< std::string, char[N]>	Convert raw C string to std::string
CTeuchos::ValueTypeConversionTraits< unsigned int, double >	Convert from double to unsigned int
CTeuchos::ValueTypeConversionTraits< unsigned int, float >	Convert from float to unsigned int
CTeuchos::ValueTypeConversionTraits< unsigned int, int >	Convert from int to unsigned int
CTeuchos::ValueTypeConversionTraits< unsigned int, long >	Convert from long to unsigned int
CTeuchos::ValueTypeConversionTraits< unsigned int, long long >	Convert from long long to unsigned int
CTeuchos::ValueTypeConversionTraits< unsigned int, std::string >	Convert an std::string to an unsigned int
CTeuchos::ValueTypeConversionTraits< unsigned int, unsigned long >	Convert from unsigned long to unsigned int
CTeuchos::ValueTypeConversionTraits< unsigned int, unsigned long long >	Convert from unsigned long long to unsigned int
CTeuchos::ValueTypeConversionTraits< unsigned long long, double >	Convert from double to unsigned long long
CTeuchos::ValueTypeConversionTraits< unsigned long long, float >	Convert from float to unsigned long long
CTeuchos::ValueTypeConversionTraits< unsigned long long, long long >	Convert from long long to unsigned long long
CTeuchos::ValueTypeConversionTraits< unsigned long long, std::string >	Convert an std::string to an unsigned long long
CTeuchos::ValueTypeConversionTraits< unsigned long, double >	Convert from double to unsigned long
CTeuchos::ValueTypeConversionTraits< unsigned long, float >	Convert from float to unsigned long
CTeuchos::ValueTypeConversionTraits< unsigned long, long >	Convert from long to unsigned long
CTeuchos::ValueTypeConversionTraits< unsigned long, std::string >	Convert an std::string to an unsigned long
CTeuchos::ValueTypeConversionTraits< unsigned short, double >	Convert from double to unsigned short
CTeuchos::ValueTypeConversionTraits< unsigned short, float >	Convert from float to unsigned short
CTeuchos::ValueTypeConversionTraits< unsigned short, short >	Convert from short to unsigned short
CTeuchos::ValueTypeConversionTraits< unsigned short, std::string >	Convert an std::string to an unsigned short
CTeuchos::ValueTypeConversionTraits< unsigned short, unsigned long >	Convert from unsigned long to unsigned short
CTeuchos::ValueTypeDeserializationBufferImp< Ordinal, T, Serializer, direct >	Encapsulate how an array of non-const serialized objects with value sematics stored in a char[] array is deserialized to a T[] array and then serialized back again
CTeuchos::ValueTypeDeserializationBuffer< Ordinal, T, Serializer >	Encapsulate how an array of non-const serialized objects with value sematics stored in a char[] array is deserialized to a T[] array and then serialized back again
CTeuchos::ValueTypeDeserializationBufferImp< Ordinal, T, DefaultSerializer< Ordinal, T >::DefaultSerializerType >
CTeuchos::ValueTypeDeserializationBuffer< Ordinal, T, typename DefaultSerializer< Ordinal, T >::DefaultSerializerType >	Encapsulate how an array of non-const serialized objects with value sematics stored in a char[] array is deserialized to a T[] array and then serialized back again
CTeuchos::ValueTypeDeserializationBufferImp< Ordinal, T, Serializer, false >	Encapsulate how an array of non-const serialized objects with value sematics stored in a char[] array is deserialized to a T[] array and then serialized back again
CTeuchos::ValueTypeDeserializationBufferImp< Ordinal, T, Serializer, true >	Encapsulate how an array of non-const serialized objects with value sematics stored in a char[] array is deserialized to a T[] array and then serialized back again
CTeuchos::ValueTypeDeserializationBufferImp< Ordinal, T, typename DefaultSerializer< Ordinal, T >::DefaultSerializerType >
CTeuchos::ValueTypeDeserializationBuffer< Ordinal, T, typename DefaultSerializer< Ordinal, T >::DefaultSerializerType >	Encapsulate how an array of non-const serialized objects with value sematics stored in a char[] array is deserialized to a T[] array and then serialized back again
CTeuchos::ValueTypeSerializationBufferImp< Ordinal, T, Serializer, direct >	Encapsulate how an array of non-const objects with value sematics is serialized into a char[] array
CTeuchos::ValueTypeSerializationBuffer< Ordinal, T, Serializer >	Encapsulate how an array of non-const objects with value sematics is serialized into a char[] array
CTeuchos::ValueTypeSerializationBufferImp< Ordinal, T, DefaultSerializer< Ordinal, T >::DefaultSerializerType >
CTeuchos::ValueTypeSerializationBuffer< Ordinal, T, typename DefaultSerializer< Ordinal, T >::DefaultSerializerType >	Encapsulate how an array of non-const objects with value sematics is serialized into a char[] array
CTeuchos::ValueTypeSerializationBufferImp< Ordinal, T, Serializer, false >	Encapsulate how an array of non-const objects with value sematics is serialized into a char[] array
CTeuchos::ValueTypeSerializationBufferImp< Ordinal, T, Serializer, true >	Encapsulate how an array of non-const objects with value sematics is serialized into a char[] array
CTeuchos::ValueTypeSerializationBufferImp< Ordinal, T, typename DefaultSerializer< Ordinal, T >::DefaultSerializerType >
CTeuchos::ValueTypeSerializationBuffer< Ordinal, T, typename DefaultSerializer< Ordinal, T >::DefaultSerializerType >	Encapsulate how an array of non-const objects with value sematics is serialized into a char[] array
CTeuchos::VerboseObjectBase	Non-templated base class for objects that can print their activities to a stream
CTeuchos::VerboseObject< ObjectType >	Templated base class for objects that can print their activities to a stream and have a verbosity level
CTeuchos::VerboseObjectTempState< ObjectType >	Set and release a stream and verbosity level
CTeuchos::Workspace< T >	Templated class for workspace creation
CTeuchos::WorkspaceStore	Workspace encapsulation class
CTeuchos::WorkspaceStoreInitializeable	WorkspaceStore class that can be used to actually reinitialize memory
CTeuchos::MatrixMarket::Raw::Writer< ScalarType, OrdinalType >	Write a sparse matrix from raw CSR (compressed sparse row) storage to a Matrix Market file
CTeuchos::XMLInputSource	XMLInputSource represents a source of XML input that can be parsed to produce an XMLObject
CTeuchos::FileInputSource	Instantiation of XMLInputSource class for reading XML from a file
CTeuchos::StringInputSource	Instantiation of XMLInputSource class for reading XML from a std::string
CTeuchos::XMLInputStream	XMLInputStream represents an XML input stream that can be used by a XMLInputSource
CTeuchos::FileInputStream	Instantiation of XMLInputStream class for reading an entire document from a file
CTeuchos::StringInputStream	Instantiation of XMLInputStream for reading an entire document from a std::string
CTeuchos::XMLObject	Representation of an XML data tree. XMLObject is a ref-counted handle to a XMLObjectImplem object, allowing storage by reference
CTeuchos::XMLTestNode	Subclass of XMLObject used by the performance archive
CTeuchos::XMLObjectImplem	Takes care of the low-level implementation details of XMLObject
CTeuchos::XMLParameterListReader	Writes an XML object to a parameter list
CTeuchos::XMLParameterListWriter	Writes a ParameterList to an XML object
CTeuchos::XMLParser	XMLParser consumes characters from an XMLInputStream object, parsing the XML and using a TreeBuildingXMLHandler to construct an XMLObject