Sierra Toolkit Version of the Day
sierra Namespace Reference

Namespaces

namespace  Env
 

Namespace Env contains the runtime environment bootstrap for the MPI, logging, command line argument parsing, runtime information and signal handling.


Classes

class  FArray
 Multidimensional array of contiguous memory. The memory is not owned by the array, but container access semantics are enforced, i.e. const Array<> elements cannot be assigned to. More...
class  FArrayContainer
 Extend FArray with deep copy assignment and resize operations. More...
class  MapvNode
class  MapvIterNext
class  MapvBase
class  SignalHandler
 Class SignalHandler ... More...
class  StringBase
class  char_simple_traits
class  char_label_traits
class  object_phrase
 Class object_phrase makes a pretty string for those annoying plural or singular noun/verb phrases. More...
struct  less_nocase
 Class less_nocase implements a case insensitive compare functor. More...
struct  less_nocase< String >
 Class specialization less_nocase for String. More...
struct  less_nocase< std::string >
 Class specialization less_nocase for std::string. More...
struct  less_nocase< const char * >
 Class specialization less_nocase for char const pointer. More...
struct  equal_nocase
 Class equal_nocase implements a case insensitive compare functor. More...
struct  equal_nocase< String >
 Class specialization equal_nocase for String. More...
struct  equal_nocase< std::string >
 Class specialization equal_nocase for std::string. More...
struct  equal_nocase< const char * >
 Class specialization equal_nocase for char const pointer. More...
struct  hash_nocase
 Class hash_nocase is a traits class for hash functions. More...
struct  hash_nocase< std::string >
 Class specialization hash_nocase for std::string. More...
struct  hash_nocase< String >
 Class specialization hash_nocase for String. More...
class  ParallelThrowRegistry
 Class ParallelThrowRegistry is a registry of known parallel exceptions. For the negotiation of parallel exceptions, each parallel exception must be registered. The class serves as the registry and registrar for the exceptions. More...
class  ExParallel
 Class ExParallel implements the features of a parallel exception. It is a std::string which stores the exception description. It also provides "put to" (operator;lt&;lt&) functions for appending the description with information. More...
class  ExTemp
 Template ExTemp takes a zero argument exception and makes it into a parallel throwable and put-to-able (<<) exception. This exception may be caught with either the base class T type or the template ExTemp<T> type. More...
class  runtime_user_error
 Class runtime_user_error ... More...
class  Array
 Multidimensional array view of contiguous memory. More...
class  ArrayContainer
 Extend Array with deep copy assignment and resize operations. More...
class  Callback< void >
 Class Callback ... More...
class  Callback
 Class Callback ... More...
class  TypeList
 Linked list of types. More...
struct  TypeListEnd
class  vecmap
 Vector-based std::map functionality. More...
class  vecset
 Vector-based std::set functionality. More...

Typedefs

typedef stk::diag::OptionMask OptionMask
typedef
stk::diag::OptionDescription 
OptionDescription
typedef stk::diag::Option Option
typedef stk::diag::OptionMaskName OptionMaskName
typedef
stk::diag::OptionMaskNameMap 
OptionMaskNameMap
typedef stk::diag::OptionMaskParser OptionMaskParser
typedef StringBase
< char_simple_traits
String
typedef StringBase
< char_label_traits
Identifier
typedef StringBase
< char_label_traits
ParamId
typedef ExTemp< std::exception > Exception
 Defined in
typedef ExTemp
< std::bad_exception > 
BadException
 Defined in
typedef ExTemp< std::bad_alloc > BadAlloc
 Defined in <new>
typedef ExTemp< std::bad_typeid > BadTypeid
 Defined in <typeinfo>
typedef ExTemp< std::bad_cast > BadCast
 Defined in <typeinfo>
typedef ExTemp1
< std::ios_base::failure > 
IosBaseFailure
 Defined in <ios>
typedef ExTemp1< std::logic_error > LogicError
 Defined in <stdexcept>
typedef ExTemp1
< std::domain_error > 
DomainError
 Defined in <stdexcept>
typedef ExTemp1
< std::invalid_argument > 
InvalidArgument
 Defined in <stdexcept>
typedef ExTemp1
< std::length_error > 
LengthError
 Defined in <stdexcept>
typedef ExTemp1
< std::out_of_range > 
OutOfRange
 Defined in <stdexcept>
typedef ExTemp1
< std::runtime_error > 
RuntimeError
 Defined in <stdexcept>
typedef ExTemp1< std::range_error > RangeError
 Defined in <stdexcept>
typedef ExTemp1
< std::overflow_error > 
OverflowError
 Defined in <stdexcept>
typedef ExTemp1
< std::underflow_error > 
UnderflowError
 Defined in <stdexcept>
typedef ExTemp1
< runtime_user_error
RuntimeUserError
typedef stk::MessageCode MessageCode
typedef stk::RuntimeWarningAdHoc RuntimeWarning
 Deprecated.
typedef
stk::RuntimeWarningSymmetric 
RuntimeWarningP0
 Deprecated.
typedef stk::RuntimeWarningAdHoc RuntimeWarningAdHoc
typedef
stk::RuntimeWarningSymmetric 
RuntimeWarningSymmetric
typedef stk::RuntimeWarningDeferred RuntimeWarningDeferred
typedef stk::RuntimeDoomedAdHoc RuntimeDoomed
 Deprecated.
typedef stk::RuntimeDoomedSymmetric RuntimeDoomedP0
 Deprecated.
typedef stk::RuntimeDoomedAdHoc RuntimeDoomedAdHoc
typedef stk::RuntimeDoomedSymmetric RuntimeDoomedSymmetric
typedef stk::RuntimeDoomedDeferred RuntimeDoomedDeferred
typedef Callback< void > CallbackBase
 Shorthand for Callback<void>

Enumerations

enum  LogMask {
  LOG_ALWAYS = stk::LOG_ALWAYS,
  LOG_TRACE = stk::LOG_TRACE,
  LOG_TRACE_STATS = stk::LOG_TRACE_STATS,
  LOG_TRACE_SUB_CALLS = stk::LOG_TRACE_SUB_CALLS,
  LOG_MEMBERS = stk::LOG_MEMBERS,
  LOG_STREAM_COMMON = stk::LOG_STREAM_COMMON,
  LOG_PARAMETERS = stk::LOG_PARAMETERS
}
enum  ErrorDieEnum {
  DIE_ON_WARN = 0,
  DIE_ON_ERROR = 1,
  DIE_ON_MESSAGE = 2
}

Functions

void array_dimension_error (const std::type_info &type, unsigned dimension, unsigned value, unsigned upper)
const char * demangle (const char *symbol)
 Function demangle returns the demangled C++ symbol from the mangled C++ symbol. The mangled named is obtained from the type_info name() function. From some compilers, the name is already demangled.
std::string CreateSubCycleInputFile (const std::string &ifile, bool debug)
bool CaseInSensitiveRegexInFile (const std::string &regExp, const std::string &file, bool debug=false)
std::vector< std::vector
< std::string > > 
ExtractCommandBlocksInFile (const std::string &beginRegExp, const std::string &file, bool debug=false)
int to_label (int c)
std::ostream & operator<< (std::ostream &os, const sierra::String &s)
std::istream & operator>> (std::istream &is, sierra::String &s)
template<class CT1 , class CT2 >
bool operator== (const StringBase< CT1 > &, const StringBase< CT2 > &)
template<class CT1 , class CT2 >
bool operator!= (const StringBase< CT1 > &, const StringBase< CT2 > &)
template<class CT1 , class CT2 >
bool operator< (const StringBase< CT1 > &, const StringBase< CT2 > &)
template<class CT1 , class CT2 >
bool operator> (const StringBase< CT1 > &, const StringBase< CT2 > &)
template<class CT1 , class CT2 >
bool operator<= (const StringBase< CT1 > &, const StringBase< CT2 > &)
template<class CT1 , class CT2 >
bool operator>= (const StringBase< CT1 > &, const StringBase< CT2 > &)
template<class CT1 >
bool operator== (const StringBase< CT1 > &, const std::string &)
template<class CT1 >
bool operator!= (const StringBase< CT1 > &, const std::string &)
template<class CT1 >
bool operator< (const StringBase< CT1 > &, const std::string &)
template<class CT1 >
bool operator> (const StringBase< CT1 > &, const std::string &)
template<class CT1 >
bool operator<= (const StringBase< CT1 > &, const std::string &)
template<class CT1 >
bool operator>= (const StringBase< CT1 > &, const std::string &)
template<class CT1 >
bool operator== (const StringBase< CT1 > &, const char *)
template<class CT1 >
bool operator!= (const StringBase< CT1 > &, const char *)
template<class CT1 >
bool operator< (const StringBase< CT1 > &, const char *)
template<class CT1 >
bool operator> (const StringBase< CT1 > &, const char *)
template<class CT1 >
bool operator<= (const StringBase< CT1 > &, const char *)
template<class CT1 >
bool operator>= (const StringBase< CT1 > &, const char *)
template<class CT1 >
bool operator== (const char *, const StringBase< CT1 > &)
template<class CT1 >
bool operator!= (const char *, const StringBase< CT1 > &)
template<class CT1 >
bool operator< (const char *, const StringBase< CT1 > &)
template<class CT1 >
bool operator> (const char *, const StringBase< CT1 > &)
template<class CT1 >
bool operator<= (const char *, const StringBase< CT1 > &)
template<class CT1 >
bool operator>= (const char *, const StringBase< CT1 > &)
template<class CT1 >
bool operator== (const std::string &, const StringBase< CT1 > &)
template<class CT1 >
bool operator!= (const std::string &, const StringBase< CT1 > &)
template<class CT1 >
bool operator< (const std::string &, const StringBase< CT1 > &)
template<class CT1 >
bool operator> (const std::string &, const StringBase< CT1 > &)
template<class CT1 >
bool operator<= (const std::string &, const StringBase< CT1 > &)
template<class CT1 >
bool operator>= (const std::string &, const StringBase< CT1 > &)
template<class CT , class CT2 >
bool operator== (const StringBase< CT > &lhs, const StringBase< CT2 > &rhs)
template<class CT , class CT2 >
bool operator!= (const StringBase< CT > &lhs, const StringBase< CT2 > &rhs)
template<class CT , class CT2 >
bool operator< (const StringBase< CT > &lhs, const StringBase< CT2 > &rhs)
template<class CT , class CT2 >
bool operator<= (const StringBase< CT > &lhs, const StringBase< CT2 > &rhs)
template<class CT , class CT2 >
bool operator> (const StringBase< CT > &lhs, const StringBase< CT2 > &rhs)
template<class CT , class CT2 >
bool operator>= (const StringBase< CT > &lhs, const StringBase< CT2 > &rhs)
template<class CT >
bool operator== (const StringBase< CT > &lhs, const std::string &rhs)
template<class CT >
bool operator!= (const StringBase< CT > &lhs, const std::string &rhs)
template<class CT >
bool operator< (const StringBase< CT > &lhs, const std::string &rhs)
template<class CT >
bool operator<= (const StringBase< CT > &lhs, const std::string &rhs)
template<class CT >
bool operator> (const StringBase< CT > &lhs, const std::string &rhs)
template<class CT >
bool operator>= (const StringBase< CT > &lhs, const std::string &rhs)
template<class CT >
bool operator== (const StringBase< CT > &lhs, const char *rhs)
template<class CT >
bool operator!= (const StringBase< CT > &lhs, const char *rhs)
template<class CT >
bool operator< (const StringBase< CT > &lhs, const char *rhs)
template<class CT >
bool operator<= (const StringBase< CT > &lhs, const char *rhs)
template<class CT >
bool operator> (const StringBase< CT > &lhs, const char *rhs)
template<class CT >
bool operator>= (const StringBase< CT > &lhs, const char *rhs)
template<class CT >
bool operator== (const std::string &lhs, const StringBase< CT > &rhs)
template<class CT >
bool operator!= (const std::string &lhs, const StringBase< CT > &rhs)
template<class CT >
bool operator< (const std::string &lhs, const StringBase< CT > &rhs)
template<class CT >
bool operator<= (const std::string &lhs, const StringBase< CT > &rhs)
template<class CT >
bool operator> (const std::string &lhs, const StringBase< CT > &rhs)
template<class CT >
bool operator>= (const std::string &lhs, const StringBase< CT > &rhs)
template<class CT >
bool operator== (const char *lhs, const StringBase< CT > &rhs)
template<class CT >
bool operator!= (const char *lhs, const StringBase< CT > &rhs)
template<class CT >
bool operator< (const char *lhs, const StringBase< CT > &rhs)
template<class CT >
bool operator<= (const char *lhs, const StringBase< CT > &rhs)
template<class CT >
bool operator> (const char *lhs, const StringBase< CT > &rhs)
template<class CT >
bool operator>= (const char *lhs, const StringBase< CT > &rhs)
template<class CT , class CT2 >
StringBase< CT > operator+ (const StringBase< CT > &cs1, const StringBase< CT2 > &cs2)
template<class CT >
StringBase< CT > operator+ (const StringBase< CT > &cs1, const char *cs2)
template<class CT >
StringBase< CT > operator+ (const StringBase< CT > &cs1, const std::string &cs2)
template<class CT >
StringBase< CT > operator+ (const char *cs1, const StringBase< CT > &cs2)
template<class CT >
std::string operator+ (const std::string &lhs, const StringBase< CT > &rhs)
std::istream & getline (std::istream &is, sierra::String &s, char eol= '\n')
 Function getline returns a string from the input stream which has been terminated by the newline character.
int case_strcmp (const char *c1, const char *c2)
 Function case_strcmp compares two null terminated strings case insenstively. It returns zero if they are case insensitively equal, a negative value if c1 is case insensitively less than c2, or a positive value if c1 is case insensitively greater than c2
int case_strncmp (const char *c1, const char *c2, size_t n)
const char * case_strstr (const char *s, const char *find)
std::string title (const std::string &s)
 Function title returns a first letter of each word capitalized of the string.
template<typename T >
std::string to_string (const T &t)
template std::string to_string< double > (const double &)
template std::string to_string< float > (const float &)
template std::string to_string< int > (const int &)
template std::string to_string< unsigned > (const unsigned &)
template std::string to_string< long > (const long &)
template std::string to_string< unsigned long > (const unsigned long &)
std::string to_string (const double &r, int precision=4)
 Function to_string returns a string representation of r.
std::string to_string (const float &r, int precision=4)
 Function to_string returns a string representation of r.
std::string format_time (double t, const char *format="%b %e %Y %H:%M:%S")
 Function format_time encodes the time using the format specified. The format is described in stdftime.
std::string word_wrap (const std::string &s, unsigned int line_length, const std::string &prefix, const std::string &prefix_first_line)
 Function word_wrap reformats a string into multiple lines, none longer that line_length, the first line prefixed with prefix_first_line and the remaining lines prefixed with prefix.
template<class T >
convert_cast (const String &s)
template double convert_cast< double > (const String &)
template float convert_cast< float > (const String &)
template int convert_cast< int > (const String &)
template unsigned convert_cast< unsigned > (const String &)
template long convert_cast< long > (const String &)
template unsigned long convert_cast< unsigned long > (const String &)
int case_strcmp (const std::string &s1, const std::string &s2)
 Function case_strcmp compares two null terminated strings case insenstively. It returns zero if they are case insensitively equal, a negative value if s1 is case insensitively less than s2, or a positive value if s1 is case insensitively greater than s2
int case_strcmp (const String &s1, const String &s2)
 Function case_strcmp compares two null terminated strings case insenstively. It returns zero if they are case insensitively equal, a negative value if s1 is case insensitively less than s2, or a positive value if s1 is case insensitively greater than s2
const char * case_strstr (const std::string &s1, const std::string &s2)
const char * case_strstr (const String &s1, const String &s2)
String undef_if_empty (const String &s)
int to_upper (int c)
 Function to_upper returns the value converted to upper case.
int to_lower (int c)
 Function to_lower returns the value converted to lower case.
int to_identifier_upper (int c)
 Function to_identifier_upper returns the value converted to underscore if it is a space or to upper case.
int to_identifier_lower (int c)
 Function to_identifier_lower returns the value converted to underscore if it is a space or to lower case.
template<class T >
T & make_upper (T &name)
 Function make_upper converts strgin name to upper case. The conversion happens in place.
template<class T >
T & make_lower (T &name)
 Function make_lower converts string name to lower case. The convertion happens in place.
template<class T >
T & make_identifier (T &name)
 Function make_identifier converts string name to an identifier case. The convertion happens in place.
template<class T >
T & make_lower_identifier (T &name)
 Function make_lower_identifier converts string name to a lower case identifier case. The convertion happens in place.
char * make_identifier (char *name)
 Function make_identifier converts string name to an identifier case. The convertion happens in place.
char * make_lower_identifier (char *name)
 Function make_lower_identifier converts string name to a lower case identifier case. The convertion happens in place.
template<class T >
T & trim (T &name)
 Function trim trims preceeding and trailing spaces from name. The convertion happens in place.
std::string title (const String &s)
String lower (const String &s)
 Function lower returns a lower case version of the string.
std::string word_wrap (const std::string &s, unsigned int line_length=72, const std::string &prefix="")
 Function word_wrap reformats a string into multiple lines, none longer that line_length and each line prefixed with prefix.
std::ostream & operator<< (std::ostream &os, const object_phrase &phrase)
 Function operator<< writes an object phrase to the output stream.
size_t hash_string_nocase (const char *p)
 Function hash_string_nocase hash a character string case insensitively.
std::ostream & out ()
 Normal output stream.
std::ostream & pout ()
 Per-processor output stream (See RuntimeDeferredx)
std::ostream & dout ()
 Diagnostic output stream.
std::ostream & tout ()
 Regression test textual output stream.
std::ostream & dwout ()
 Diagnostic writer stream.
const char * get_product_name ()
void register_product ()
void sierra_exception_throw ()
 Member function sierra_exception_throw is called whenever a parallel exception is constructed. This acn be used as a breakpoint in a debugger if finding the magic throw symbol is too tricky.
void throw_copy (const std::exception &x, const std::string &message)
 Function throw_copy throws a copy of the exception. The exception is located in the parallel exception registry. This exception is cloned and thrown using the parallel exception's throw_copy member function.
void set_exception ()
 Function set_exception is called on a single processor when an exception is caught. The next collective communication will propogate the exception to all processors. This flavor is called when an unknown exception (...) is caught.
void set_exception (std::exception &x)
 Function set_exception is called on a single processor when an exception is caught. The next collective communication will propogate the exception to all processors.
void set_exception (ExParallel &x)
 Function set_exception is called on a single processor when an exception is caught. The next collective communication will propogate the exception to all processors.
void register_stl_parallel_exceptions ()
 Member function register_stl_parallel_exceptions registers the stl exceptions with the parallel exception handler.
void parallel_throw (MPI_Comm mpi_comm)
 Function parallel_throw throws a consistant exception in parallel. parallel_throw is called after the exception has been propagated to all processors. parallel_throw will decide which exception to rethrow in parallel on all processors.
void test_error_messages_to_file_report_handler (const char *message, int type)
void set_test_error_messages_file (const std::string &test_error_messages_path)
std::ofstream * get_test_error_messages_file ()
void set_test_error_messages_die_on_first_message (std::vector< ErrorDieEnum > errorTypes)
bool get_test_error_messages_die_on_first_warning ()
bool get_test_error_messages_die_on_first_error ()
template<typename T >
CallbackBasecreate_callback (T &t, void(T::*f)())
 Member function create_callback creates a new callback object which calls the member function f on the object t.
template<class ElementType , class Tag0 , class Tag1 , class Tag2 , class Tag3 , class Tag4 , class Tag5 , class Tag6 , class Tag7 >
std::ostream & operator<< (std::ostream &os, const sierra::Array< ElementType, Tag0, Tag1, Tag2, Tag3, Tag4, Tag5, Tag6, Tag7 > &array)
template<class ElementType , class Tag0 , class Tag1 , class Tag2 , class Tag3 , class Tag4 , class Tag5 , class Tag6 , class Tag7 >
std::ostream & operator<< (std::ostream &os, const sierra::ArrayContainer< ElementType, Tag0, Tag1, Tag2, Tag3, Tag4, Tag5, Tag6, Tag7 > &array)
template<class ElementType , int Dimension>
std::ostream & operator<< (std::ostream &os, const sierra::FArray< ElementType, Dimension > &array)
template<class ElementType , int Dimension>
std::ostream & operator<< (std::ostream &os, const sierra::FArrayContainer< ElementType, Dimension > &array)

Detailed Description

------------------------------------------------------------ Copyright 2001 - 2010 Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive license for use of this work by or on behalf of the U.S. Government. Export of this program may require a license from the United States Government. ------------------------------------------------------------

------------------------------------------------------------ Copyright 1998-2007 Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive license for use of this work by or on behalf of the U.S. Government. Export of this program may require a license from the United States Government. ------------------------------------------------------------

------------------------------------------------------------ Copyright 2005-2009, 2011 Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive license for use of this work by or on behalf of the U.S. Government. Export of this program may require a license from the United States Government. ------------------------------------------------------------

------------------------------------------------------------ Copyright 2006-2007, 2009 Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive license for use of this work by or on behalf of the U.S. Government. Export of this program may require a license from the United States Government. ------------------------------------------------------------

------------------------------------------------------------ Copyright 2002-2009 Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive license for use of this work by or on behalf of the U.S. Government. Export of this program may require a license from the United States Government. ------------------------------------------------------------

------------------------------------------------------------ Copyright 2004-2009 Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive license for use of this work by or on behalf of the U.S. Government. Export of this program may require a license from the United States Government. ------------------------------------------------------------

------------------------------------------------------------ Copyright 2003 - 2009 Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive license for use of this work by or on behalf of the U.S. Government. Export of this program may require a license from the United States Government. ------------------------------------------------------------

------------------------------------------------------------ Copyright 2003-2009 Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive license for use of this work by or on behalf of the U.S. Government. Export of this program may require a license from the United States Government. ------------------------------------------------------------

------------------------------------------------------------ Copyright 2005 - 2009 Sandia Corporation. Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive license for use of this work by or on behalf of the U.S. Government. Export of this program may require a license from the United States Government. ------------------------------------------------------------


Function Documentation

template<typename T >
CallbackBase* sierra::create_callback ( T &  t,
void(T::*)()  f 
)

Member function create_callback creates a new callback object which calls the member function f on the object t.

Parameters:
ta T reference to the object that wishes to be called back.
Returns:
a CallbackBase pointer to the newly created callback object.

Definition at line 107 of file Callback.hpp.

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines