Itasca C++ Interface
Loading...
Searching...
No Matches
Namespaces | Classes | Macros | Typedefs | Enumerations | Functions | Variables | Friends
Base interface specification

Namespaces

namespace  AVector2Util
 2D Angular vector class.
 
namespace  itasca
 namespace Itasca
 

Classes

class  AVector2< T >
 2D Angular vector class. More...
 
class  AVector3< T >
 3D Angular vector class. More...
 
class  Axes2D
 Class for specifying a particular 2D cartesian axes system, and converting to and from it. More...
 
class  Axes3D
 Class for specifying a particular 3D cartesian axes system, and converting to and from it. More...
 
struct  QStringCILess2
 
struct  QStringLocalLess2
 
struct  QStringCIEqual2
 
struct  QStringCIHash2
 
struct  fmt::formatter< QString >
 
class  StringList
 
class  Buffer
 
struct  StringCILess
 
struct  StringCIEqual
 
struct  StringCIHash
 
class  ItascaTextStream
 
class  CAxes2D
 Class for specifying a particular 2D cartesian axes system, and converting to and from it. More...
 
class  CAxes3D
 Class for specifying a particular 3D cartesian axes system, and converting to and from it. More...
 
class  Cube< T >
 A Class representing a cartesian extent in 3D. More...
 
class  Extent2< T >
 2D cartesian region in space. More...
 
class  Extent3< T >
 A Class representing a cartesian extent in 3D. More...
 
class  FArray< T, S >
 An array class that attempts to minimize unnecessary heap access. More...
 
class  FArray< T, 0 >
 
class  limits< T >
 debug checked shorthand for std::numeric_limits<T>:: More...
 
class  Matrix< T, SX, SY >
 A template-based matrix class, size fixed at compile time. Defaults to symmetric sized matrix. More...
 
class  Matrix< T, SX, 1 >
 A specialization of the Matrix class for the case when SY=1. More...
 
class  SymMatrix< T, SX >
 A template-based symmetric matrix class, size fixed at compile time. This primitive template-based matrix class should be used where the matrix size is fixed at compile time. More...
 
class  innerLoopMS< T, SX, SY, I, J, K >
 
class  innerLoopMS< T, SX, SY, I, J, 1 >
 
class  loop2MultiplyMS< T, SX, SY, I, J >
 
class  loop2MultiplyMS< T, SX, SY, I, 1 >
 
class  loopMultiplyMS< T, SX, SY, I >
 
class  loopMultiplyMS< T, SX, SY, 1 >
 
class  VMatrix< T, S >
 A 1-Dimensional version of Matrix, to represent a vector. More...
 
class  DMatrix< SX, SY >
 DMatrix is a Matrix that defaults to type double... More...
 
class  DSymMatrix< SX >
 DSymMatrix is a SymMatrix that defaults to type double... More...
 
class  DVMatrix< S >
 DVMatrix is a double version of VMatrix. More...
 
class  Orientation2
 Class for storing an "orientation", or a direction in 2D or 3D space. More...
 
class  Orientation3
 Class for storing an "orientation", or a direction in 2D or 3D space. More...
 
class  SymTensor
 A symmetric 2nd order tensor. More...
 
class  SymTensorInfo
 SymTensor eigenvalue and direction helper class. More...
 
class  Variant
 A simpler (and slightly faster) version of a QVariant, added for interfaces that do not use Qt. More...
 
class  Variant::VUserType< T >
 This is a helper class, designed to make it possible to allow user-defined types to be encoded in a Variant.
. More...
 
class  Variant::VUserType< void * >
 Template specialization for void pointers; this should probably never be used, except to determine the size of VUserType for type_selector. More...
 
class  Vector2< T >
 2D vector utility class. More...
 
class  Vector3< T >
 3D vector utility class. More...
 
struct  fmt::formatter< Vector2< T > >
 
struct  fmt::formatter< Vector3< T > >
 

Macros

#define BASE_EXPORT   IMPORT_TAG
 
#define OSVAL(x, y)   x
 
#define FOR(x, y)   for (auto x=(y).begin();x!=(y).end();++x)
 
#define filesystem   ERROR_USE_SHARED_FILESTORE_INSTEAD
 
#define NEW   new
 
#define NEWN(x)   new
 
#define FMT_HEADER_ONLY
 
#define DOPRAGMA(x)   _Pragma(#x)
 
#define INTELWARNING(x)
 
#define INTELLLVMWARNING(x)
 
#define GNUWARNING(x)
 
#define CLANGWARNING(x)
 
#define VSWARNING(x)
 
#define TEMPLATE   template
 
#define _PI_DEFINED
 Define pi and pi/180.
 

Typedefs

typedef AVector2< double > DAVect2
 
typedef AVector2< float > FAVect2
 
typedef AVector2< int32 > IAVect2
 
typedef AVector2< uint32 > UAVect2
 
typedef AVector3< double > DAVect3
 
typedef AVector3< float > FAVect3
 
typedef AVector3< int32 > IAVect3
 
typedef AVector3< uint32 > UAVect3
 
typedef std::basic_string< char8 > String
 std::string of type Char
 
using char16 = char16_t
 
using char8 = char
 
using int8 = int8_t
 
using uint8 = uint8_t
 
using int16 = int16_t
 
using uint16 = uint16_t
 
using int32 = int32_t
 
using uint32 = uint32_t
 
using int64 = int64_t
 
using uint64 = uint64_t
 
using TType = uint32
 class type indicator
 
template<typename T >
using QStringMap = std::map<QString, T, QStringCILess2>
 
template<typename T >
using QStringHashMap = std::unordered_map<QString, T, QStringCIHash2, QStringCIEqual2>
 
using QStringSet = std::set<QString,QStringCILess2>
 
using QStringHashSet = std::unordered_set<QString, QStringCIHash2, QStringCIEqual2>
 
using wstring = std::wstring
 
using string = std::string
 
using string_view = std::string_view
 
template<typename T >
using StringMap = std::map<string, T, StringCILess>
 
template<typename T >
using StringMultiMap = std::multimap<string, T, StringCILess>
 
template<typename T >
using StringHashMap = std::unordered_map<string, T, StringCIHash, StringCIEqual>
 
using StringSet = std::set<string, StringCILess>
 
using StringHashSet = std::unordered_set<string, StringCIHash, StringCIEqual>
 
typedef Cube< double > DCube
 
typedef Cube< float > FCube
 
typedef Cube< int32 > ICube
 
typedef Cube< uint32 > UCube
 
typedef Extent2< double > DExtent2
 
typedef Extent2< float > FExtent2
 
typedef Extent2< int32 > IExtent2
 
typedef Extent2< uint32 > UExtent2
 
typedef Extent2< int64 > I64Extent2
 
typedef Extent2< uint64 > U64Extent2
 
typedef Extent3< double > DExtent3
 
typedef Extent3< float > FExtent3
 
typedef Extent3< int32 > IExtent3
 
typedef Extent3< uint32 > UExtent3
 
typedef Extent3< int64 > I64Extent3
 
typedef Extent3< uint64 > U64Extent3
 
typedef Vector2< float > FVect2
 
typedef Vector2< int32 > IVect2
 
typedef Vector2< uint32 > UVect2
 
typedef Vector2< int64 > I64Vect2
 
typedef Vector2< uint64 > U64Vect2
 
typedef Vector3< double > DVect3
 
typedef Vector3< float > FVect3
 
typedef Vector3< int32 > IVect3
 
typedef Vector3< uint32 > UVect3
 
typedef Vector3< int64 > I64Vect3
 
typedef Vector3< uint64 > U64Vect3
 

Enumerations

enum class  Empty { Keep , Skip }
 
enum class  Variant::Type {
  Variant::Type::Byte = 1 , Variant::Type::UByte , Variant::Type::Short , Variant::Type::UShort ,
  Variant::Type::Int , Variant::Type::UInt , Variant::Type::Long , Variant::Type::ULong ,
  Variant::Type::Float , Variant::Type::Double , Variant::Type::Void , Variant::Type::Bool ,
  Variant::Type::IVect2 , Variant::Type::DVect2 , Variant::Type::IVect3 , Variant::Type::DVect3 ,
  Variant::Type::RawData , Variant::Type::String = 100 , Variant::Type::User
}
 Indicates the type of the variant. 18 types are predefined. More...
 

Functions

template<typename T , typename U >
constexpr const T & osval (const T &wval, const U &)
 
BASE_EXPORT QString toQString (const QString &s, int width=0, char fill=' ')
 Converts from a base type to a QString, using the width and fill character specified.
 
BASE_EXPORT QString toQString (const char *str, int width=0, char fill=' ')
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QString toQString (const qint8 &v, int width=0, char fill=' ')
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QString toQString (const quint8 &v, int width=0, char fill=' ')
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QString toQString (const qint16 &v, int width=0, char fill=' ')
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QString toQString (const quint16 &v, int width=0, char fill=' ')
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QString toQString (const qint32 &v, int width=0, char fill=' ')
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QString toQString (const quint32 &v, int width=0, char fill=' ')
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QString toQString (const qint64 &v, int width=0, char fill=' ')
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QString toQString (const quint64 &v, int width=0, char fill=' ')
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QString toQString (const wstring &v, int width, char fill=' ')
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QString toQString (const string &v, int width, char fill=' ')
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QString toQString (const float &v, int width=0, char format='g', int precision=-1, char fill=' ')
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QString toQString (const double &v, int width=0, char format='g', int precision=-1, char fill=' ')
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QString toQString (const SymTensor &v, int width=0, char format='g', int precision=-1, char fill=' ')
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QString toQString (const QVariant &v, int width=0, char fill=' ', char format='g', int precision=-1)
 
BASE_EXPORT QString toQString (const void *v, int width=0, char fill=' ')
 Outputs a pointer in 0x0000 format.
 
BASE_EXPORT QString toQString (bool b, const QString &out="on,off", int width=0, char fill=' ')
 
template<class T >
QString toQStringT (const T &t, int width=0, char fill=' ', char format='g', int precision=-1)
 
template<>
QString toQStringT (const float &t, int width, char fill, char format, int precision)
 
template<>
QString toQStringT (const double &t, int width, char fill, char format, int precision)
 
template<>
QString toQStringT (const QVariant &t, int width, char fill, char format, int precision)
 
template<>
QString toQStringT (const bool &b, int width, char fill, char format, int precision)
 
template<class T >
QString toQString (const Vector2< T > &v, int width=0, char fmt='g', int prec=-1, char fill=' ')
 
template<class T >
QString toQString (const Vector3< T > &v, int width=0, char fmt='g', int prec=-1, char fill=' ')
 
template<class T >
QString toQString (const AVector2< T > &v, int width=0, char fmt='g', int prec=-1, char fill=' ')
 
template<class T >
QString toQString (const AVector3< T > &v, int width=0, char fmt='g', int prec=-1, char fill=' ')
 
BASE_EXPORT QString toBytes (const quint64 &ul)
 Converts number ul into a memory size string.
 
string tostring (const QString &s)
 
StringList toStringList (const QStringList &sl)
 
QStringList toQStringList (const StringList &sl)
 
StringList fromQStringList (const QStringList &sl)
 
Buffer toBuffer (const QByteArray &ba)
 
BASE_EXPORT QString readLine (QDataStream &ds, qint64 maxlen=0)
 Reads a single QString line from a QDataStream (since QTextStream is bugged), uses '\n' as an end-of-line marker.
 
BASE_EXPORT QString readWord (QDataStream &ds, qint64 maxlen=0, const QString &separators=" \t\r\n")
 Reads a single whitespace delimited word from the QDataStream (since QTextStream is bugged), using the given separator list.
 
BASE_EXPORT QString enquoteString (const QString &s, QChar quote='"')
 
BASE_EXPORT bool isInt (const QString &in, int *i=0)
 
BASE_EXPORT bool isUInt (const QString &in, uint *u=0)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT bool isLong (const QString &in, qint64 *l=0)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT bool isULong (const QString &in, quint64 *ul=0)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT bool isDouble (const QString &in, double *d=0)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT bool isBool (const QString &in, bool *b=0, const QString &out="on,off,true,false,yes,no")
 
BASE_EXPORT bool toBool (const QString &in, bool *ok=0, const QString &out="on,off,true,false,yes,no")
 
QString toQString (const std::wstring &in)
 converts a QString into a base string.
 
QString toQString (const string &in)
 converts a string into a QString
 
BASE_EXPORT std::tuple< int32, bool > isInt32 (const string_view &in)
 
BASE_EXPORT std::tuple< uint32, bool > isUInt32 (const string_view &in)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT std::tuple< int64, bool > isInt64 (const string_view &in)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT std::tuple< uint64, bool > isUInt64 (const string_view &in)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT std::tuple< double, bool > isDouble (const string_view &in)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT std::tuple< bool, bool > isBool (const string_view &in, const string_view &out="on,off,true,false,yes,no")
 
std::tuple< int32, bool > isInt32 (const string &in)
 
std::tuple< uint32, bool > isUInt32 (const string &in)
 
std::tuple< int64, bool > isInt64 (const string &in)
 
std::tuple< uint64, bool > isUInt64 (const string &in)
 
std::tuple< double, bool > isDouble (const string &in)
 
std::tuple< bool, bool > isBool (const string &in, const string_view &out="on,off,true,false,yes,no")
 
std::tuple< int32, bool > isInt32v (const string_view &in)
 
std::tuple< uint32, bool > isUInt32v (const string_view &in)
 
std::tuple< int64, bool > isInt64v (const string_view &in)
 
std::tuple< uint64, bool > isUInt64v (const string_view &in)
 
std::tuple< double, bool > isDoublev (const string_view &in)
 
std::tuple< bool, bool > isBoolv (const string_view &in, const string_view &out="on,off,true,false,yes,no")
 
template<typename T , typename ... Args>
toStringConv (const string_view &in, Args...args, bool te, std::tuple< T, bool >(*f)(const string_view &, Args...))
 
int32 toInt32 (const string_view &in, bool throwException=false)
 
uint32 toUInt32 (const string_view &in, bool throwException=false)
 
int64 toInt64 (const string_view &in, bool throwException=false)
 
uint64 toUInt64 (const string_view &in, bool throwException=false)
 
double toDouble (const string_view &in, bool throwException=false)
 
bool toBool (const string_view &in, const string_view &out="on,off,true,false,yes,no", bool throwException=false)
 
 StringList::StringList (std::initializer_list< string > list)
 
 StringList::StringList (const StringList &s)
 
 StringList::StringList (const std::vector< string > &v)
 
 StringList::StringList (StringList &&v) noexcept
 
 StringList::StringList (std::vector< string > &&v) noexcept
 
const StringListStringList::operator= (const StringList &in)
 
const StringListStringList::operator+= (const string &s)
 
const StringListStringList::operator+= (const std::vector< string > &v)
 
const StringListStringList::operator<< (const string &s)
 
const StringListStringList::operator<< (const StringList &s)
 
StringList StringList::operator+ (const StringList &s) const
 
BASE_EXPORT std::vector< string > toStringList (const std::vector< string_view > &v)
 
BASE_EXPORT bool contains (const std::vector< string > &all, const string &s2, bool caseSensitivity=false)
 
BASE_EXPORT string tostring (const std::wstring &s)
 
BASE_EXPORT string tostring (const std::u16string &s)
 
BASE_EXPORT string tostring (const std::u32string &s)
 
string tostring (const string_view &s)
 
BASE_EXPORT std::wstring towstring (const string &s)
 
BASE_EXPORT std::wstring towstring (const std::u16string &s)
 
BASE_EXPORT std::u16string tou16string (const string &s)
 
BASE_EXPORT std::u16string tou16string (const std::wstring &s)
 
BASE_EXPORT std::u16string tou16string (const string_view &s)
 
BASE_EXPORT std::u32string tou32string (const string &s)
 
BASE_EXPORT std::u32string tou32string (const string_view &s)
 
BASE_EXPORT string toUpper (const string_view &s)
 
BASE_EXPORT string toLower (const string_view &s)
 
BASE_EXPORT string capitalizeFirstLetter (const string_view &s)
 
template<typename T , typename U >
join (const std::vector< T > &s, const U &sep)
 
BASE_EXPORT std::vector< string_view > splitView (const string_view &s, const string_view &sep, bool keepEmptyParts=false)
 
std::vector< string > split (const string_view &s, const string_view &sep, bool keepEmptyParts=false)
 
BASE_EXPORT std::vector< string_view > splitViewRegex (const string_view &s, const string_view &regex, bool keepEmptyParts=false)
 
std::vector< string > splitRegex (const string_view &s, const string_view &regex, bool keepEmptyParts=false)
 
BASE_EXPORT string_view matchViewRegex (const string_view &s, const string_view &regex, string::size_type start=0)
 
string matchRegex (const string_view &s, const string_view &regex, string::size_type start=0)
 
BASE_EXPORT string replaceRegex (const string &s, const string_view &regex, const string &after)
 
BASE_EXPORT string::size_type find (const string_view &s1, const string_view &s2, string::size_type start=0, bool caseSensitive=false)
 
BASE_EXPORT string::size_type findRegex (const string_view &s, const string_view &regex, string::size_type start=0)
 
BASE_EXPORT bool exactMatchRegex (const string_view &s, const string_view &regex)
 
BASE_EXPORT string_view trimmed_view (const string_view &s)
 
string trimmed (const string_view &s)
 
BASE_EXPORT string simplified (const string_view &s)
 
BASE_EXPORT string replace (string s, const string_view &sub, const string_view &newsub, bool caseSensitive=false)
 
BASE_EXPORT string toBase64 (const std::vector< char > &in)
 
BASE_EXPORT std::vector< char > fromBase64 (const string &in)
 
BASE_EXPORT bool startsWith (const string_view &in, const string_view &check, bool caseSensitive=false)
 
BASE_EXPORT bool endsWith (const string_view &in, const string_view &check, bool caseSensitive=false)
 
BASE_EXPORT bool contains (const string_view &in, const string_view &check, bool caseSensitive=false)
 
BASE_EXPORT string clipLen (string in, string::size_type length)
 
BASE_EXPORT string cleanupTypename (const char *name)
 
BASE_EXPORT string convertPercentToBracket (const string_view &s)
 
BASE_EXPORT string remove (string s, char c)
 
string remove (string s, const string_view &sub, bool caseSensitive=false)
 
BASE_EXPORT int32 compare (const string_view &s1, const string_view &s2, bool caseSensitive=false)
 
BASE_EXPORT uint64 caseInsensitiveHash (const string_view &s)
 
BASE_EXPORT uint64 firstNonBlankCharacter (const string_view &s)
 
BASE_EXPORT bool wildcardMatch (const string_view &patter, const string_view &test)
 
BASE_EXPORT string formatBytes (uint64 bytes, uint32 precision=3)
 
 Buffer::Buffer (const std::vector< char > &v)
 
 Buffer::Buffer (std::vector< char > &&v)
 
 Buffer::Buffer (const char *c, size_t len)
 
 Buffer::Buffer (const string &s)
 
const BufferBuffer::operator= (const std::vector< char > &v)
 
const BufferBuffer::operator= (std::vector< char > &&v)
 
void Buffer::append (const char *data, uint64 len)
 
void Buffer::operator+= (const string &s)
 
string Buffer::toString () const
 
const char * Buffer::constData () const
 
BASE_EXPORT bool checkLeft (const string_view &s, const string_view &c)
 
bool equal (const string_view &s, const string_view &c, bool caseSensitive=false)
 
BASE_EXPORT bool match (const string &keyword, const string &token)
 ‍**
 
BASE_EXPORT void matchSynonymsAllowed (bool b)
 
BASE_EXPORT bool matchSynonymsAllowed ()
 
BASE_EXPORT string buildFormat (int64 width, char notation='\0', int precision=-1, char fill=' ')
 
template<class T >
string base::ts (const T &t, int width=0, char notation='\0', int precision=-1, char fill=' ')
 
template<typename T >
std::tuple< T, bool > base::fsTest (const string &)
 
template<>
std::tuple< int32, bool > base::fsTest (const string &in)
 
template<typename T >
base::fs (const string &, bool throwException=false)
 
template<>
int32 base::fs (const string &in, bool throwException)
 
bool StringCILess::operator() (const string &left, const string &right) const
 
bool StringCIEqual::operator() (const string &left, const string &right) const
 
uint64 StringCIHash::operator() (const string &in) const
 
BASE_EXPORT void initializeQtToBase ()
 
template<class T >
QDataStream & operator<< (QDataStream &ds, const Vector2< T > &v)
 Allows a Base type to be written to, or read from, a QDataStream.
 
template<class T >
QDataStream & operator>> (QDataStream &ds, Vector2< T > &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
QDataStream & operator<< (QDataStream &ds, const Vector3< T > &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
QDataStream & operator>> (QDataStream &ds, Vector3< T > &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
QDataStream & operator<< (QDataStream &ds, const AVector2< T > &av)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
QDataStream & operator>> (QDataStream &ds, AVector2< T > &av)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
QDataStream & operator<< (QDataStream &ds, const AVector3< T > &av)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
QDataStream & operator>> (QDataStream &ds, AVector3< T > &av)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
QDataStream & operator<< (QDataStream &ds, const Extent2< T > &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
QDataStream & operator>> (QDataStream &ds, Extent2< T > &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
QDataStream & operator<< (QDataStream &ds, const Extent3< T > &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
QDataStream & operator>> (QDataStream &ds, Extent3< T > &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator<< (QDataStream &ds, const Orientation2 &o)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator>> (QDataStream &ds, Orientation2 &o)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator<< (QDataStream &ds, const Orientation3 &o)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator>> (QDataStream &ds, Orientation3 &o)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator<< (QDataStream &ds, const Axes2D &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator>> (QDataStream &ds, Axes2D &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator<< (QDataStream &ds, const Axes3D &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator>> (QDataStream &ds, Axes3D &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator<< (QDataStream &ds, const CAxes2D &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator>> (QDataStream &ds, CAxes2D &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator<< (QDataStream &ds, const CAxes3D &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator>> (QDataStream &ds, CAxes3D &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator<< (QDataStream &ds, const Variant &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator>> (QDataStream &ds, Variant &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator<< (QDataStream &ds, const std::wstring &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator>> (QDataStream &ds, std::wstring &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator<< (QDataStream &ds, const string &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator>> (QDataStream &ds, string &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator<< (QDataStream &ds, const SymTensor &s)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator>> (QDataStream &ds, SymTensor &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator<< (QDataStream &ds, const Quat2 &o)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator>> (QDataStream &ds, Quat2 &o)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator<< (QDataStream &ds, const Quat3 &o)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator>> (QDataStream &ds, Quat3 &o)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator<< (QDataStream &ds, const itasca::Mat &o)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT QDataStream & operator>> (QDataStream &ds, itasca::Mat &o)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
template<class T >
QTextStream & operator<< (QTextStream &ds, const Vector2< T > &v)
 
template<class T >
QTextStream & operator<< (QTextStream &ds, const Vector3< T > &v)
 
template<class T >
QTextStream & operator<< (QTextStream &ds, const AVector2< T > &v)
 Writes an AVector2 to formatted text, as a scalar basically.
 
template<class T >
QPoint toQPoint (const Vector2< T > &v)
 Convert a Vector2 to a QPoint.
 
template<class T >
QPointF toQPointF (const Vector2< T > &v)
 Convert a Vector2 to a QPointF.
 
DVect2 toDVect2 (const QPoint &p)
 Convert a QPoint to a DVect2.
 
DVect2 toDVect2 (const QSize &p)
 Convert a QSize to a DVect2.
 
FVect2 toFVect2 (const QPoint &p)
 Convert a QPoint to an FVect2.
 
IVect2 toIVect2 (const QPoint &p)
 Convert a QPoint to an IVect2.
 
I64Vect2 toI64Vect2 (const QPoint &p)
 
UVect2 toUVect2 (const QPoint &p)
 Convert a QPoint to a UVect2.
 
DVect2 toDVect2 (const QPointF &p)
 Convert a QPointF to an DVect2.
 
FVect2 toFVect2 (const QPointF &p)
 Convert a QPointF to an FVect2.
 
IVect2 toIVect2 (const QPointF &p)
 Convert a QPointF to an IVect2.
 
UVect2 toUVect2 (const QPointF &p)
 Convert a QPointF to an UVect2.
 
bool checkQVariantTypes (const QVariant &v1, const QVariant &v2)
 returns true if Variants have the same type
 
template<typename T >
QVariant toQVariant (const T &t)
 
template<>
BASE_EXPORT QVariant toQVariant< Variant > (const Variant &v)
 
template<>
BASE_EXPORT QVariant toQVariant< base::Property > (const base::Property &prop)
 
BASE_EXPORT Variant toVariant (const QVariant &v)
 
BASE_EXPORT base::Property toProperty (const QVariant &v)
 
BASE_EXPORT bool isDirectoryProtected (const QDir &dir, const QString &registryString)
 
BASE_EXPORT QString getInstallDirectory (const QString &registryString)
 
BASE_EXPORT QString convertFilePath (const QString &filePath, const QDir &previousDir, const QDir &newDir)
 
BASE_EXPORT bool setCurrentDirectory (const IString &dir)
 
BASE_EXPORT QString getCurrentDirectory ()
 
BASE_EXPORT QDir getCurrentDirectoryObject ()
 
template<class T >
const Cube< T > & toCube (const Cube< T > &t)
 Returns a cube.
 
template<class T >
Cube< T > toCube (const Extent2< T > &t)
 Returns a cube coverted from a rectangle, the length of the third dimension is zero.
 
template<class T >
const Extent3< T > & toExtent3 (const Extent3< T > &t)
 Returns a Extent3.
 
template<class T >
Extent3< T > toExtent3 (const Extent2< T > &t)
 Returns a Extent3 coverted from a Extent2, the length of the third dimension is zero.
 
template<class T >
constexpr T initVal ()
 
template<>
constexpr double initVal< double > ()
 
template<>
constexpr float initVal< float > ()
 
template<class T , unsigned SX, unsigned SY>
Matrix< T, SX, SY > operator* (const Matrix< T, SX, SY > &m, const SymMatrix< T, SY > &s)
 
template<class T , unsigned S>
double innerProduct (const VMatrix< T, S > &v1, const VMatrix< T, S > &v2)
 
template<class T >
double innerProduct (const VMatrix< T, 3 > &v1, const DVect3 &v2)
 
template<class T >
double innerProduct (const VMatrix< T, 2 > &v1, const DVect2 &v2)
 
template<class T , unsigned S>
Matrix< T, S, S > outerProduct (const VMatrix< T, S > &v1, const VMatrix< T, S > &v2)
 
template<class T >
constexpr std::tuple< Matrix< T, 3, 3 >, double > inverseDet (const Matrix< T, 3, 3 > &mat)
 
template<class T , unsigned SX>
constexpr VMatrix< T, SX > toVMatrix (const Vector2< T > &v, unsigned start=0)
 Converts a Vector2 into a VMatrix of arbitrary size, at an arbitrary starting index.
 
template<unsigned SX>
constexpr DVMatrix< SX > toDVMatrix (const DVect2 &v, unsigned start=0)
 
template<class T , unsigned SX>
constexpr VMatrix< T, SX > toVMatrix (const Vector3< T > &v, unsigned start=0)
 Converts a Vector3 into a VMatrix of arbitrary size, at an arbitrary starting index.
 
template<unsigned SX>
DVMatrix< SX > constexpr toDVMatrix (const DVect3 &v, unsigned start=0)
 
BASE_EXPORT DMatrix< 2, 2 > toMatrix2 (const SymTensor &s)
 
BASE_EXPORT DSymMatrix< 2 > toSymMatrix2 (const SymTensor &s)
 
SymTensor toSymTensor (const DMatrix< 2, 2 > &m)
 
template<class T , unsigned SX>
Vector2< T > toVector2 (const VMatrix< T, SX > &m, unsigned start=0)
 Converts a VMatrix to a Vector2, using two elements starting at index start.
 
template<class T , unsigned SX>
Vector3< T > toVector3 (const VMatrix< T, SX > &m, unsigned start=0)
 Converts a VMatrix to a Vector3, using three elements starting at index start.
 
template<class T >
Vector2< T > toVector (const VMatrix< T, 2 > &m)
 Converts a VMatrix to a Vector3, using three elements starting at index start.
 
template<class T >
Vector3< T > toVector (const VMatrix< T, 3 > &m)
 Converts a VMatrix to a Vector3, using three elements starting at index start.
 
template<class T , unsigned SY>
Vector2< T > columnToVector (const Matrix< T, 2, SY > &m, unsigned col)
 returns in a Vector2<t> the column col from matrix Matrix<T,SX,2>
 
template<class T , unsigned SY>
Vector3< T > columnToVector (const Matrix< T, 3, SY > &m, unsigned col)
 returns in a Vector3<t> the column col from a matrix Matrix<T,SX,3>
 
template<class T , unsigned SX>
Vector2< T > rowToVector (const Matrix< T, SX, 2 > &m, unsigned row)
 returns in a Vector2<t> the row row from matrix Matrix<T,SX,2>
 
template<class T , unsigned SX>
Vector3< T > rowToVector (const Matrix< T, SX, 3 > &m, unsigned row)
 returns in a Vector3<t> the row row from matrix Matrix<T,SX,3>
 
template<class T , unsigned SY>
constexpr void vectorToColumn (Matrix< T, 2, SY > &m, const DVect2 &v, unsigned col)
 
template<class T , unsigned SY>
constexpr void vectorToColumn (Matrix< T, 3, SY > &m, const DVect3 &v, unsigned col)
 
template<class T , unsigned SX, unsigned SY>
constexpr void vectorToColumn (Matrix< T, SX, SY > &m, const VMatrix< T, SX > &v, unsigned col)
 
template<class T , unsigned SX>
void vectorToRow (Matrix< T, SX, 2 > &m, const DVect2 &v, unsigned row)
 
template<class T , unsigned SX>
void vectorToRow (Matrix< T, SX, 3 > &m, const DVect3 &v, unsigned row)
 
template<class T , unsigned SX, unsigned SY>
constexpr void vectorToRow (Matrix< T, SX, SY > &m, const VMatrix< T, SY > &v, unsigned row)
 
template<class T , unsigned SX, unsigned SY>
VMatrix< T, SX > column (const Matrix< T, SX, SY > &m, unsigned c)
 
DVMatrix< 3 > operator* (const SymTensor &s, const DVMatrix< 3 > &v)
 
DVMatrix< 2 > operator* (const SymTensor &s, const DVMatrix< 2 > &v)
 
template<class D , class T >
constexpr D to (const T &t)
 This template function serves as an alternative to static_cast<T>().
 
template<>
constexpr float to (const double &t)
 
template<class D >
constexpr D to (const double &d)
 
template<class D >
D constexpr to (const float &d)
 
template<>
constexpr double to (const float &d)
 
template<class D , class T >
D * check_cast (T *t)
 This template function serves as a fast alternative to dynamic_cast, when you know the base offset is the same.
 
template<class D , class T >
const D * check_cast (const T *t)
 This template function serves as a fast alternative to dynamic_cast, when you know the base offset is the same.
 
template<class T >
constexpr const T safeDiv (const T num, const T denom)
 This function provids "safe" division operation, checks explicitly for zero.
 
 Variant::UserTypeBase::UserTypeBase ()
 Default constructor, no data initialization.
 
virtual Variant::UserTypeBase::~UserTypeBase ()
 Deconstructor.
 
virtual UserTypeBaseVariant::UserTypeBase::clone (char *data) const =0
 Clone function.
 
virtual void Variant::UserTypeBase::copy (const UserTypeBase *base)=0
 Copy from base pointer.
 
BASE_EXPORT Variant::Variant (const Variant &mv)
 Copy constructor.
 
BASE_EXPORT Variant::Variant (const int32 &v=0)
 
BASE_EXPORT Variant::Variant (const bool &v)
 
BASE_EXPORT Variant::Variant (const int8 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT Variant::Variant (const uint8 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT Variant::Variant (const int16 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT Variant::Variant (const uint16 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT Variant::Variant (const uint32 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT Variant::Variant (const int64 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT Variant::Variant (const uint64 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT Variant::Variant (const float &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT Variant::Variant (const double &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT Variant::Variant (void *v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT Variant::Variant (const void *v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT Variant::Variant (const IVect2 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT Variant::Variant (const DVect2 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT Variant::Variant (const IVect3 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT Variant::Variant (const DVect3 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT Variant::Variant (const string &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT Variant::Variant (const char *v)
 
BASE_EXPORT Variant::~Variant ()
 Destructor.
 
BASE_EXPORT const VariantVariant::operator= (const Variant &mv)
 Equality operator.
 
BASE_EXPORT Type Variant::getType () const
 The type of the Variant. Note that this may be a user-defined value.
 
BASE_EXPORT string Variant::getTypeName () const
 A string indicating the Variant type.
 
BASE_EXPORT bool Variant::toBool (bool *success=0) const
 
BASE_EXPORT int8 Variant::toByte (bool *success=0) const
 
BASE_EXPORT uint8 Variant::toUByte (bool *success=0) const
 
BASE_EXPORT int16 Variant::toShort (bool *success=0) const
 
BASE_EXPORT uint16 Variant::toUShort (bool *success=0) const
 
BASE_EXPORT int32 Variant::toInt (bool *success=0) const
 
BASE_EXPORT uint32 Variant::toUInt (bool *success=0) const
 
BASE_EXPORT int64 Variant::toLong (bool *success=0) const
 
BASE_EXPORT uint64 Variant::toULong (bool *success=0) const
 
BASE_EXPORT float Variant::toFloat (bool *success=0) const
 
BASE_EXPORT double Variant::toDouble (bool *success=0) const
 
BASE_EXPORT string Variant::toString (bool *success=0) const
 
BASE_EXPORT void * Variant::toVoid (bool *success=0) const
 
BASE_EXPORT IVect2 Variant::toIVect2 (bool *success=0) const
 
BASE_EXPORT DVect2 Variant::toDVect2 (bool *success=0) const
 
BASE_EXPORT IVect3 Variant::toIVect3 (bool *success=0) const
 
BASE_EXPORT DVect3 Variant::toDVect3 (bool *success=0) const
 
BASE_EXPORT const int32 & Variant::fastToInt () const
 
BASE_EXPORT const bool & Variant::fastToBool () const
 
BASE_EXPORT const int64 & Variant::fastToLong () const
 
BASE_EXPORT const double & Variant::fastToDouble () const
 
BASE_EXPORT const DVect2Variant::fastToDVect2 () const
 
BASE_EXPORT const DVect3Variant::fastToDVect3 () const
 
BASE_EXPORT const string & Variant::fastToString () const
 
const VariantVariant::operator= (const bool &v)
 Assignment operator for a specific type, converts the Variant to the same type and value.
 
const VariantVariant::operator= (const int8 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
const VariantVariant::operator= (const uint8 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
const VariantVariant::operator= (const int16 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
const VariantVariant::operator= (const uint16 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
const VariantVariant::operator= (const int32 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
const VariantVariant::operator= (const uint32 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
const VariantVariant::operator= (const int64 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
const VariantVariant::operator= (const uint64 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
const VariantVariant::operator= (const float &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
const VariantVariant::operator= (const double &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
const VariantVariant::operator= (void *v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
const VariantVariant::operator= (const void *v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
const VariantVariant::operator= (const IVect2 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
const VariantVariant::operator= (const DVect2 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
const VariantVariant::operator= (const DAVect2 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
const VariantVariant::operator= (const IVect3 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
const VariantVariant::operator= (const DVect3 &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT const VariantVariant::operator= (const string &v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
const VariantVariant::operator= (const char *v)
 This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
 
BASE_EXPORT void Variant::setToRawData ()
 
char * Variant::getRawData ()
 
const char * Variant::getRawData () const
 
template<class T >
void Variant::setToUserType (const T &t)
 
template<class T >
void Variant::moveToUserType (T &&t)
 
template<class T >
T & Variant::convertToUserType ()
 
template<class T >
Variant::toUserType () const
 
template<class T >
T & Variant::fastToUserType ()
 
template<class T >
const T & Variant::fastToUserType () const
 
template<class T >
bool Variant::isUserType () const
 
static BASE_EXPORT string Variant::getTypeName (Type type)
 Returns the name associated with a given type value, of "UnKnown" if the type is not valid.
 
static BASE_EXPORT int Variant::getRawDataSize ()
 
static BASE_EXPORT bool Variant::getUserTypeClaimed (int type)
 
template<class T >
static bool Variant::registerType (int type, const string &name)
 This method allows user-defined types to be encoded in a variant.
 
 Variant::VUserType< void * >::VUserType ()
 Default constructor.
 
 Variant::VUserType< void * >::VUserType (void *const t)
 
 Variant::VUserType< void * >::~VUserType () override
 Destructor.
 
VUserType< void * > * Variant::VUserType< void * >::clone (char *data) const override
 in-place clone
 
void Variant::VUserType< void * >::copy (const UserTypeBase *base) override
 copy from base pointer, uses reinterpret_cast to upcast (careful!).
 
static bool Variant::VUserType< void * >::isValue ()
 Checks if the user type holds the literal value of T, or a pointer to it.
 
template<class T >
constexpr I64Vect2 toI64Vect2 (const Vector2< T > &v)
 
template<class T >
constexpr U64Vect2 toU64Vect2 (const Vector2< T > &v)
 
template<class T >
I64Vect3 toI64Vect3 (const Vector3< T > &v)
 
template<class T >
constexpr const Vector2< T > & toVect2 (const Vector2< T > &v)
 Conversion between vectors of different dimension.
 
template<class T >
constexpr Vector2< T > toVect2 (const Vector3< T > &v)
 Conversion between vectors of different dimension.
 
template<class T >
constexpr Vector3< T > toVect3 (const Vector2< T > &v, const T &t=0)
 Conversion between vectors of different dimension.
 
template<class T >
constexpr const Vector3< T > & toVect3 (const Vector3< T > &v)
 Conversion between vectors of different dimension.
 
template<class T >
I64Vect3 constexpr v64round (const Vector3< T > &v)
 
template<class T >
Vector2< T > operator& (const Vector2< T > &v, const AVector2< T > &av)
 
template<class T >
Vector3< T > operator& (const Vector3< T > &v, const AVector2< T > &av)
 
template<class T >
AVector2< T > operator& (const Vector2< T > &v1, const Vector2< T > &v2)
 
template<class T >
operator| (const Vector2< T > &, const AVector2< T > &)
 
template<class T >
DAVect2 toDAVect2 (const AVector2< T > &v)
 
template<class T >
FAVect2 toFAVect2 (const AVector2< T > &v)
 
template<class T >
IAVect2 toIAVect2 (const AVector2< T > &v)
 
template<class T >
UAVect2 toUAVect2 (const AVector2< T > &v)
 
template<class T >
DAVect3 toDAVect3 (const Vector3< T > &v)
 
template<class T >
FAVect3 toFAVect3 (const Vector3< T > &v)
 
template<class T >
IAVect3 toAIVect3 (const Vector3< T > &v)
 
template<class T >
UAVect3 toAUVect3 (const Vector3< T > &v)
 
template<class T >
Vector2< T > toVect2 (const AVector2< T > &)
 
template<class T >
Vector3< T > toVect3 (const AVector2< T > &v)
 
template<class T >
Vector2< T > toVect2 (const AVector3< T > &v)
 
template<class T >
const Vector3< T > & toVect3 (const AVector3< T > &v)
 
template<class T >
const AVector2< T > & toAVect2 (const AVector2< T > &v)
 
template<class T >
AVector2< T > toAVect2 (const AVector3< T > &v)
 
template<class T >
AVector3< T > toAVect3 (const AVector2< T > &v, const T &x=0, const T &y=0)
 
template<class T >
const AVector3< T > & toAVect3 (const AVector3< T > &v)
 
template<class T >
AVector3< T > vmax (const AVector3< T > &v1, const AVector3< T > &v2)
 
template<class T >
AVector3< T > vmin (const AVector3< T > &v1, const AVector3< T > &v2)
 
template<class T >
AVector3< T > vsign (const AVector3< T > &v1, const AVector3< T > &v2)
 
template<class T >
AVector3< T > vceil (const AVector3< T > &v)
 
template<class T >
AVector2< T > vmax (const AVector2< T > &v1, const AVector2< T > &v2)
 
template<class T >
AVector2< T > vmin (const AVector2< T > &v1, const AVector2< T > &v2)
 
template<class T >
AVector2< T > vsign (const AVector2< T > &v1, const AVector2< T > &v2)
 
template<class T >
AVector2< T > vceil (const AVector2< T > &v)
 
 FArray< T, S >::FArray (size_type s, const T &t=T())
 
 FArray< T, S >::FArray (std::initializer_list< T > l)
 
const FArray< T, S > & FArray< T, S >::operator= (const FArray< T, S > &f)
 
template<uint64 S2>
bool FArray< T, S >::operator== (const FArray< T, S2 > &f) const
 
template<uint64 S2>
const FArray< T, S > & FArray< T, S >::operator= (const FArray< T, S2 > &f)
 Assignment operator, valid for FArrays of the same data type but different stack lengths.
 
size_type FArray< T, S >::find (const T &t) const
 
T * FArray< T, S >::emplace_n_back (uint64 n)
 
void FArray< T, S >::resize (size_type i, const T &t=T())
 
iterator FArray< T, S >::insert (size_type i, const T &t)
 
void FArray< T, S >::put (size_type i, const T &t)
 Adds a value to the array, first making certain it is big enough to hold it.
 
template<class C >
void FArray< T, S >::append (const C &in)
 Appends the contents of one FArray onto another.
 
iterator FArray< T, S >::insert (iterator it, const T &t)
 
bool FArray< T, S >::remove (size_type i)
 
size_type FArray< T, S >::removeAll (const T &t)
 
void FArray< T, S >::clear ()
 
void FArray< T, S >::reset ()
 
template<class T >
Matrix< T, 3, 3 > outerProduct (const Vector3< T > &v1, const Vector3< T > &v2)
 Creates a 3X3 Matrix from the outer product of two Vector3 types.
 
template<class T >
Matrix< T, 2, 2 > outerProduct (const Vector2< T > &v1, const Vector2< T > &v2)
 Creates a 2X2 Matrix from the outer product of two Vector2 types.
 
template<class T >
constexpr T determinant (const Matrix< T, 3, 3 > &mat)
 Returns the determinant of a 3X3 Matrix.
 
template<class T >
constexpr T determinant (const Matrix< T, 2, 2 > &mat)
 Returns the determinant of a 2X2 Matrix.
 
template<class T >
constexpr Matrix< T, 3, 3 > inverse (const Matrix< T, 3, 3 > &mat)
 Returns the inverse of a 3X3 Matrix.
 
template<class T >
constexpr Matrix< T, 2, 2 > inverse (const Matrix< T, 2, 2 > &mat)
 Returns the inverse of a 2X2 Matrix.
 
template<class T >
constexpr VMatrix< T, 2 > toMatrix (const Vector2< T > &v)
 
template<class T >
constexpr VMatrix< T, 3 > toMatrix (const Vector3< T > &v)
 
template<class T >
constexpr Vector2< T > operator* (const Matrix< T, 2, 2 > &m, const Vector2< T > &v)
 
template<class T >
constexpr Vector2< T > operator* (const SymMatrix< T, 2 > &m, const Vector2< T > &v)
 
template<class T >
constexpr Vector3< T > operator* (const Matrix< T, 3, 3 > &m, const Vector3< T > &v)
 
template<class T >
Vector3< T > operator* (const SymMatrix< T, 3 > &m, const Vector3< T > &v)
 
BASE_EXPORT DMatrix< 3, 3 > toMatrix3 (const SymTensor &s)
 
BASE_EXPORT DMatrix< 2, 2 > toMatrix2 (const SymTensor &s)
 
BASE_EXPORT DSymMatrix< 3 > toSymMatrix3 (const SymTensor &s)
 
SymTensor toSymTensor (const DMatrix< 3, 3 > &m)
 
SymTensor toSymTensor (const DSymMatrix< 3 > &m)
 
const SymTensorSymTensor::operator= (const SymTensor &s)
 Assignment operator.
 
bool SymTensor::operator== (const SymTensor &s) const
 Equality operator.
 
const double & SymTensor::operator[] (unsigned int i) const
 Allows Index access to tensor components.
 
double & SymTensor::operator[] (unsigned int i)
 
double SymTensor::getTotalMeasure () const
 
DVect3 SymTensor::operator* (const DVect3 &input) const
 Performs the linear mapping represented by the tensor on the vector input.
 
DVect2 SymTensor::operator* (const DVect2 &input) const
 
SymTensor SymTensor::operator* (const double &mul) const
 
const SymTensorSymTensor::operator*= (const double &mul)
 
SymTensor SymTensor::operator/ (const double &mul) const
 
const SymTensorSymTensor::operator/= (const double &mul)
 
SymTensor SymTensor::operator+ (const SymTensor &s) const
 
SymTensor SymTensor::operator- (const SymTensor &s) const
 
bool SymTensor::isIsotropic (double tol=std::numeric_limits< double >::epsilon() *1000.0) const
 
void SymTensor::adjustTrace (const double &newTrace)
 
void SymTensor::rotate (const DVect3 &rot)
 
static uint32 SymTensor::doubleToSingleComponent (uint32 dof1, uint32 dof2)
 
template<class T >
constexpr DVect2 toDVect2 (const Vector2< T > &v)
 
template<class T >
constexpr FVect2 toFVect2 (const Vector2< T > &v)
 
template<class T >
constexpr IVect2 toIVect2 (const Vector2< T > &v)
 
template<class T >
constexpr UVect2 toUVect2 (const Vector2< T > &v)
 
template<class T >
constexpr DVect3 toDVect3 (const Vector3< T > &v)
 
template<class T >
constexpr FVect3 toFVect3 (const Vector3< T > &v)
 
template<class T >
constexpr IVect3 toIVect3 (const Vector3< T > &v)
 
template<class T >
constexpr U64Vect3 toU64Vect3 (const Vector3< T > &v)
 
template<class T >
constexpr Vector2< T > vmax (const Vector2< T > &v1, const Vector2< T > &v2)
 
template<class T >
constexpr Vector2< T > vmin (const Vector2< T > &v1, const Vector2< T > &v2)
 
template<class T >
constexpr Vector2< T > vsign (const Vector2< T > &v1, const Vector2< T > &v2)
 
template<class T >
constexpr Vector3< T > vmax (const Vector3< T > &v1, const Vector3< T > &v2)
 
template<class T >
constexpr Vector3< T > vmin (const Vector3< T > &v1, const Vector3< T > &v2)
 
template<class T >
constexpr Vector3< T > vsign (const Vector3< T > &v1, const Vector3< T > &v2)
 
template<class T >
Vector2< T > vceil (const Vector2< T > &v)
 
template<class T >
Vector3< T > vceil (const Vector3< T > &v)
 
template<class T >
Vector2< T > vfloor (const Vector2< T > &v)
 
template<class T >
Vector3< T > vfloor (const Vector3< T > &v)
 
template<class T >
IVect2 vround (const Vector2< T > &v)
 
template<class T >
IVect3 constexpr vround (const Vector3< T > &v)
 

Variables

POPWARNING typedef Vector2< double > DVect2
 
int8   Variant::byte_ 
 
uint8   Variant::ubyte_ 
 
int16   Variant::short_ 
 
uint16   Variant::ushort_ 
 
int32   Variant::int_ 
 
uint32   Variant::uint_ 
 
int64   Variant::long_ 
 
uint64   Variant::ulong_ 
 
float   Variant::float_ 
 
double   Variant::double_ 
 
void *   Variant::void_ 
 
bool   Variant::bool_ 
 
char   Variant::data_ [dataSize_] 
 
void * Variant::VUserType< void * >::t_
 The actual value being stored.
 
static int Variant::VUserType< void * >::typeNumber_
 The typeNumber_ used to uniquely identify the type.
 

Friends

template<class T >
class Variant::VUserType
 
BASE_EXPORT QDataStream & Variant::operator<< (QDataStream &, const Variant &)
 Allows writing a Variant to a QDataStream.
 

Detailed Description

NOTE: This should not be used in new code - we hope to use Property instead

Macro Definition Documentation

◆ BASE_EXPORT

#define BASE_EXPORT   IMPORT_TAG

Define BASE_LIB in project settings to export If not defined assumes using as import. This is a standard for headers in DLLs.

Enumeration Type Documentation

◆ Type

enum class Variant::Type
strong

Indicates the type of the variant. 18 types are predefined.

Enumerator
Byte 

signed 8 bit integer.

UByte 

unsigned 8 bit integer.

Short 

signed 16 bit integer.

UShort 

unsigned 16 bit integer.

Int 

signed 32 bit integer.

UInt 

unsigned 32 bit integer.

Long 

signed 64 bit integer.

ULong 

unsigned 64 bit integer.

Float 

32 bit floating point value.

Double 

64 bit floating point value.

Void 

A void pointer.

Bool 

A value of type bool.

IVect2 

A 2D vector of 32 bit signed integers.

DVect2 

A 2D vector of 64 bit floating point values.

IVect3 

A 3D vector of 32 bit signed integers.

DVect3 

A 3D vector of 64 bit floating point values.

RawData 

Raw binary data – see the Variant::setToRawData() and Variant::getRawData() methods.

String 

A String() class.

User 

A user-defined type. See the Variant::registerType() method.

Function Documentation

◆ check_cast() [1/2]

template<class D , class T >
const D * check_cast ( const T * t)

This template function serves as a fast alternative to dynamic_cast, when you know the base offset is the same.

In debug mode, it checks for a base offset change by comparing the result against an actual dynamic_cast.

◆ check_cast() [2/2]

template<class D , class T >
D * check_cast ( T * t)

This template function serves as a fast alternative to dynamic_cast, when you know the base offset is the same.

In debug mode, it checks for a base offset change by comparing the result against an actual dynamic_cast.

◆ clear()

template<typename T , uint64 S>
void FArray< T, S >::clear ( )

Resets the array size to zero, destroying all current elements. The allocated length is not changed.

◆ convertFilePath()

BASE_EXPORT QString convertFilePath ( const QString & filePath,
const QDir & previousDir,
const QDir & newDir )

Converts a filePath string from being relative to a previous directory, to being relative to a new directory. If the filePath is absolute, and the new directory references the same base system (drive letter or network path) it might become a relative path. This should work even if the relative file path is impossible (like a filePath of "../../../../../fred.dat" with a previousDir of "C:/one/"). If the new directory is not in the same system as the old directory, then filePath might become absolute. In that case, if the relative file path was impossible, the closest approximation is used (in the abolve example, "C:/fred.dat") and tree information might be lost.

◆ convertToUserType()

template<class T >
T & Variant::convertToUserType ( )

Converts the type of the variant to this user type (if necessary), and returns a reference to the type. This is for optimization purposes, to avoid temporary objects.

◆ determinant()

template<class T >
constexpr T determinant ( const Matrix< T, 3, 3 > & mat)
related

Returns the determinant of a 3X3 Matrix.

MOO NOTE: Eventually want to add specialization for SymMatrix.

◆ emplace_n_back()

template<typename T , uint64 S>
T * FArray< T, S >::emplace_n_back ( uint64 n)

emplace_n_back: make sure n new positions are allocated and return a pointer to the first of those positions; caller should create objects at those positions.

◆ FArray()

template<typename T , uint64 S>
FArray< T, S >::FArray ( size_type s,
const T & t = T() )
explicit

Constructs the array with size s, and each entry in the array has initial value t.

Parameters
sInitial size of the array.
tThe value each element is initialized with.

◆ fastToBool()

BASE_EXPORT const bool & Variant::fastToBool ( ) const
inline

Very fast converion of a Variant to a specific type. Used only where performance is critical, and where you are certain the Variant contains a value of exactly that type.

◆ fastToDouble()

BASE_EXPORT const double & Variant::fastToDouble ( ) const
inline

Very fast converion of a Variant to a specific type. Used only where performance is critical, and where you are certain the Variant contains a value of exactly that type.

◆ fastToDVect2()

BASE_EXPORT const DVect2 & Variant::fastToDVect2 ( ) const
inline

Very fast converion of a Variant to a specific type. Used only where performance is critical, and where you are certain the Variant contains a value of exactly that type.

◆ fastToDVect3()

BASE_EXPORT const DVect3 & Variant::fastToDVect3 ( ) const
inline

Very fast converion of a Variant to a specific type. Used only where performance is critical, and where you are certain the Variant contains a value of exactly that type.

◆ fastToInt()

BASE_EXPORT const int32 & Variant::fastToInt ( ) const
inline

Very fast converion of a Variant to a specific type. Used only where performance is critical, and where you are certain the Variant contains a value of exactly that type.

◆ fastToLong()

BASE_EXPORT const int64 & Variant::fastToLong ( ) const
inline

Very fast converion of a Variant to a specific type. Used only where performance is critical, and where you are certain the Variant contains a value of exactly that type.

◆ fastToString()

const string & Variant::fastToString ( ) const

Very fast converion of a Variant to a specific type. Used only where performance is critical, and where you are certain the Variant contains a value of exactly that type.

◆ fastToUserType() [1/2]

template<class T >
T & Variant::fastToUserType ( )
inline

Very fast converion of a Variant to a specific user-defined type. Used only where performance is critical, and where you are certain the Variant contains a value of exactly that type. If the Variant is not of that type the return value is undefined.

◆ fastToUserType() [2/2]

template<class T >
const T & Variant::fastToUserType ( ) const
inline

Very fast converion of a Variant to a specific user-defined type. Used only where performance is critical, and where you are certain the Variant contains a value of exactly that type. If the Variant is not of that type the return value is undefined.

◆ find()

template<typename T , uint64 S>
FArray< T, S >::size_type FArray< T, S >::find ( const T & t) const

Searches the array to find the first element matching t. Returns the index found, or limits<size_type>::max() if not found. This search is linear time.

◆ getCurrentDirectory()

BASE_EXPORT QString getCurrentDirectory ( )

Reentrant versions of setCurrentDirectory and QDir::getCurrent. Those functions are not re-entrant (even though they are documented as such).

◆ getCurrentDirectoryObject()

BASE_EXPORT QDir getCurrentDirectoryObject ( )

Reentrant versions of setCurrentDirectory and QDir::getCurrent. Those functions are not re-entrant (even though they are documented as such).

◆ getInstallDirectory()

BASE_EXPORT QString getInstallDirectory ( const QString & registryString)

Attempts to read the registry to find a variable set during installation indicating the install directory. This variable is named "installdir32" for a 32 bit exe, and "installdir64" for a 64 bit exe. The directory will be: HKEY_LOCAL_MACHINE\Software\Itasca\"registryString" in the entry "installdir". Note that a 32 bit process running under 64 bit windows is redirected to: HKEY_LOCAL_MACHINE\Software\Wow6432Node\Itasca\"registryString"

◆ getRawData() [1/2]

char * Variant::getRawData ( )
inline

Returns a pointer to the raw data used to store Variant contents.

Warning
If the variant is not currently setToRawData(), you could cause a fatal data corruption by overwring memory.
Any attempt to store more than getRawDataSize() bytes will result in overwriting of random memory!
See also
setToRawData() getRawDataSize()

◆ getRawData() [2/2]

const char * Variant::getRawData ( ) const
inline

Returns a pointer to the raw data used to store Variant contents.

Warning
If the variant is not currently setToRawData(), you could cause a fatal data corruption by overwring memory.
Any attempt to store more than getRawDataSize() bytes will result in overwriting of random memory!
See also
setToRawData() getRawDataSize()

◆ getRawDataSize()

static BASE_EXPORT int Variant::getRawDataSize ( )
inlinestatic

Returns the size of the raw data available for Variant storage, in bytes.

See also
setToRawData() getRawData()

◆ getTotalMeasure()

double SymTensor::getTotalMeasure ( ) const
inline

Total Measure now is defined as the distance of the stress/strain tensor point at the principal stress/strain space to the origin of the same space. Returns a scalar, (I1/sqrt(3), sqrt(2*J2))

◆ getUserTypeClaimed()

bool Variant::getUserTypeClaimed ( int type)
static

Returns true if the type value has already been claimed. This function can be used to find an unused valid type when calling registerType().

◆ initializeQtToBase()

BASE_EXPORT void initializeQtToBase ( )

Initialization routine, called automatically by system. This initializes various Base types with the QVariant system. It also adds the executable direcotory to the list of paths searched for libraries.

◆ insert() [1/2]

template<typename T , uint64 S>
FArray< T, S >::iterator FArray< T, S >::insert ( iterator it,
const T & t )

Inserts a value intot he array at position i (the new position it will occupy). If I is past the end of the array, adds to end.

◆ insert() [2/2]

template<typename T , uint64 S>
FArray< T, S >::iterator FArray< T, S >::insert ( size_type i,
const T & t )

Inserts a value into the array at position i (the new position it will occupy). If I is past the end of the array, adds to end.

◆ inverse() [1/2]

template<class T >
constexpr Matrix< T, 2, 2 > inverse ( const Matrix< T, 2, 2 > & mat)
related

Returns the inverse of a 2X2 Matrix.

MOO NOTE: Eventually want to add specialization for SymMatrix.

◆ inverse() [2/2]

template<class T >
constexpr Matrix< T, 3, 3 > inverse ( const Matrix< T, 3, 3 > & mat)
related

Returns the inverse of a 3X3 Matrix.

MOO NOTE: Eventually want to add specialization for SymMatrix.

◆ isBool()

BASE_EXPORT bool isBool ( const QString & in,
bool * b = 0,
const QString & out = "on,off,true,false,yes,no" )

This functions checks to see if the string can be converted into a boolean value.
The out string is used to match against pairs of values (true,false,...).
The default out string is "on,off,true,false,yes,no". The b argument is filled with the result. Returns true on a successful conversion, false otherwise.

◆ isDirectoryProtected()

BASE_EXPORT bool isDirectoryProtected ( const QDir & dir,
const QString & registryString )

Attempts to determine if the directory represented by dir is write protected for any reason. A directory is considered "protected" for one of three reasons: a) It is read-only, or an attempt to create and write to a file in that location fails. b) It contains "Program Files" at the start of the absolute directory path. c) It matches the installation path stored in the registry at HKEY_LOCAL_MACHINE\Software\Itasca\"registryString" in the entry "installdir". Note that a 32 bit process running under 64 bit windows is redirected to HKEY_LOCAL_MACHINE\Software\Wow6432Node\Itasca\"registryString"

◆ isInt()

BASE_EXPORT bool isInt ( const QString & in,
int * i = 0 )

These functions check if the contents of the string can be converted into another type.
They will return TRUE if so, and fill the pointer with the converted value if given.
These are basically alternative syntax forms of the QString::toXXX functions.

◆ isUserType()

template<class T >
bool Variant::isUserType ( ) const
inline

Returns TRUE if the Variant is of the user-defined type specified by T.

if (v.isUserType<MyType>()) { <do something> }

The type must have been registered using registerType().

See also
setToUserType() isUserType() registerType() moveToUserType()

◆ match()

BASE_EXPORT bool match ( const string & keyword,
const string & token )

‍**

Performs "itasca match" of this string (as keyword) to token.

◆ moveToUserType()

template<class T >
void Variant::moveToUserType ( T && t)

Moves the given value of a user-specified type T into the value. rvalue references wheee The type must have been previously registered with registerType().

See also
toUserType() setToUserType() isUserType() registerType()

◆ operator&() [1/3]

template<class T >
Vector2< T > operator& ( const Vector2< T > & v,
const AVector2< T > & av )
related

Cross product operator between a Vector2 and an AVector2, returns a Vector2.

◆ operator&() [2/3]

template<class T >
AVector2< T > operator& ( const Vector2< T > & v1,
const Vector2< T > & v2 )
related

Cross product operator between a Vector2 and an Vector2, returns an AVector2.

◆ operator&() [3/3]

template<class T >
Vector3< T > operator& ( const Vector3< T > & v,
const AVector2< T > & av )
related

Cross product operator between a Vector3 and an AVector2, returns a Vector3 (z=0).

◆ operator*() [1/5]

DVect3 SymTensor::operator* ( const DVect3 & input) const
inline

Performs the linear mapping represented by the tensor on the vector input.

In stress terms, finds the tractions in the given directions if input is a unit vector.

◆ operator*() [2/5]

template<class T >
constexpr Vector2< T > operator* ( const Matrix< T, 2, 2 > & m,
const Vector2< T > & v )
related

Multiplies a 2X2 Matrix by a Vector2, and returns the resulting Vector2.

◆ operator*() [3/5]

template<class T >
constexpr Vector3< T > operator* ( const Matrix< T, 3, 3 > & m,
const Vector3< T > & v )
related

Multiplies a 3X3 Matrix by a Vector3, and returns the resulting Vector3.

◆ operator*() [4/5]

template<class T >
constexpr Vector2< T > operator* ( const SymMatrix< T, 2 > & m,
const Vector2< T > & v )
related

Multiplies a 2X2 SymMatrix by a Vector2, and returns the resulting Vector2.

◆ operator*() [5/5]

template<class T >
Vector3< T > operator* ( const SymMatrix< T, 3 > & m,
const Vector3< T > & v )
related

Multiplies a 3X3 SymMatrix by a Vector3, and returns the resulting Vector3.

◆ operator<<() [1/3]

BASE_EXPORT QDataStream & operator<< ( QDataStream & ds,
const Variant & v )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Allows writing a Variant to a QDataStream.

◆ operator<<() [2/3]

template<class T >
QTextStream & operator<< ( QTextStream & ds,
const Vector2< T > & v )
inline

Writes a Vector2 to formatted text. The current qSetFieldWidth is used for the entire vector. Format is "(x,y)". This means each component gets a field width of (w-3)/2.

◆ operator<<() [3/3]

template<class T >
QTextStream & operator<< ( QTextStream & ds,
const Vector3< T > & v )
inline

Writes a Vector3 to formatted text. The current qSetFieldWidth is used for the entire vector. Format is "(x,y,z)". This means each component gets a field width of (w-4)/3.

◆ operator[]()

const double & SymTensor::operator[] ( unsigned int i) const
inline

Allows Index access to tensor components.

Order = xx, yy, zz, xy, xz, yz.... base 0

◆ operator|()

template<class T >
T operator| ( const Vector2< T > & ,
const AVector2< T > &  )
related

Dot product operator between a Vector2 and an AVector2, returns 0.

◆ registerType()

template<class T >
static bool Variant::registerType ( int type,
const string & name )
static

This method allows user-defined types to be encoded in a variant.

Two steps must be followed. First, a static instance of a VUserType<T>::typeNumber_ must be created and initialized to zero. Second, this static method must be called with a type number and a string used to indicate the type.

Returns
false if the type number in invalid or is already in use.
Here is an example:
void myInitializationRoutine()
{
Variant::registerType<MyType>(Variant::UserType+20,"My Type");
}
This is a helper class, designed to make it possible to allow user-defined types to be encoded in a V...
Definition variant.h:68

◆ remove()

template<typename T , uint64 S>
bool FArray< T, S >::remove ( size_type i)

Removes a value from the array at position i If i is past the end of the array, does nothing.

◆ removeAll()

template<typename T , uint64 S>
FArray< T, S >::size_type FArray< T, S >::removeAll ( const T & t)

Removes all values from the array matching t (operator==). Returns the number of objects removed

◆ reset()

template<typename T , uint64 S>
void FArray< T, S >::reset ( )

Resets the array size to zero, destroying all current elements. The allocated length is reset back to the stack length, and any heap memory is returned.

◆ resize()

template<typename T , uint64 S>
void FArray< T, S >::resize ( size_type i,
const T & t = T() )
Parameters
iThe new array length.
tThe value assigned to new array elements (if any). Changes the actual length (not the allocated length) of the array to i. May increase the allocated length, but will not decrease it.

◆ safeDiv()

template<class T >
constexpr const T safeDiv ( const T num,
const T denom )
constexpr

This function provids "safe" division operation, checks explicitly for zero.

Don't use when performance is important! (Could add overflow underflow checking here, but would have to find a way to do that without undue calculation burden)

◆ setCurrentDirectory()

BASE_EXPORT bool setCurrentDirectory ( const IString & dir)

Reentrant versions of setCurrentDirectory and QDir::getCurrent. Those functions are not re-entrant (even though they are documented as such).

◆ setToRawData()

void Variant::setToRawData ( )

Clears the current contents of the Variant, and indicates that this variant will now hold raw data installed in it's available memory. Use the getRawData() method to access a pointer to the start of this memory.

Warning
{ Any attempt to store more than getRawDataSize() bytes will result in overwriting of random memory! }
See also
getRawData() getRawDataSize()

◆ setToUserType()

template<class T >
void Variant::setToUserType ( const T & t)

Converts the variant to contain a copy of a user-specified type T. The type must have been previously registered with registerType().

See also
toUserType() isUserType() registerType() moveToUserType()

◆ to()

template<class D , class T >
constexpr D to ( const T & t)
constexpr

This template function serves as an alternative to static_cast<T>().

It is not as verbose, and it checks for out-of-range casting in debug mode. Note: This doesn't work if you are casting TO bool - but using to<> isn't necessary then in any case (range checking isn't an issue) so just use static cast. Template specialization for this case is awkward.

◆ toAIVect3()

template<class T >
IAVect3 toAIVect3 ( const Vector3< T > & v)
related

Converts a Vector3 to an int32 AVect3 (no loss of components)

◆ toAUVect3()

template<class T >
UAVect3 toAUVect3 ( const Vector3< T > & v)
related

Converts a Vector3 to a uint32 AVect3 (no loss of components)

◆ toAVect2() [1/2]

template<class T >
const AVector2< T > & toAVect2 ( const AVector2< T > & v)
related

Converts a AVector2 to an AVector2 ( Identity )

◆ toAVect2() [2/2]

template<class T >
AVector2< T > toAVect2 ( const AVector3< T > & v)
related

Converts a AVector3 to an AVector2 (x and y components are lost)

◆ toAVect3() [1/2]

template<class T >
AVector3< T > toAVect3 ( const AVector2< T > & v,
const T & x = 0,
const T & y = 0 )
related

Converts a AVector2 to an AVector3 (with optional additional x and y components)

◆ toAVect3() [2/2]

template<class T >
const AVector3< T > & toAVect3 ( const AVector3< T > & v)
related

Converts a AVector3 to an AVector3 ( Identity )

◆ toBool() [1/2]

bool Variant::toBool ( bool * success = 0) const

Attempts to convert the Variant type to the indicated type.
A failed conversion will return 0, or whatever the default constructed value is in general.

Parameters
successIf provided, is true if the conversion was successful and false otherwise.

◆ toBool() [2/2]

BASE_EXPORT bool toBool ( const QString & in,
bool * ok = 0,
const QString & out = "on,off,true,false,yes,no" )

Converts from a QString to a bool, using the same rules as isBool().
Returns the result of the conversion, while ok is filled with true on success, false otherwise.

◆ toByte()

int8 Variant::toByte ( bool * success = 0) const

Attempts to convert the Variant type to the indicated type.
A failed conversion will return 0, or whatever the default constructed value is in general.

Parameters
successIf provided, is true if the conversion was successful and false otherwise.

◆ toBytes()

BASE_EXPORT QString toBytes ( const quint64 & ul)

Converts number ul into a memory size string.

Uses units of Bytes, KBytes, or MBytes depending on size.

◆ toDAVect2()

template<class T >
DAVect2 toDAVect2 ( const AVector2< T > & v)
related

Converts an AVector2<T> to a double version.

◆ toDAVect3()

template<class T >
DAVect3 toDAVect3 ( const Vector3< T > & v)
related

Converts a Vector3 to a double AVect3 (no loss of components)

◆ toDouble()

double Variant::toDouble ( bool * success = 0) const

Attempts to convert the Variant type to the indicated type.
A failed conversion will return 0, or whatever the default constructed value is in general.

Parameters
successIf provided, is true if the conversion was successful and false otherwise.

◆ toDVect2() [1/2]

DVect2 Variant::toDVect2 ( bool * success = 0) const

Attempts to convert the Variant type to the indicated type.
A failed conversion will return 0, or whatever the default constructed value is in general.

Parameters
successIf provided, is true if the conversion was successful and false otherwise.

◆ toDVect2() [2/2]

template<class T >
constexpr DVect2 toDVect2 ( const Vector2< T > & v)
related

Conversion routines between various predefined types of Vector2.

◆ toDVect3() [1/2]

DVect3 Variant::toDVect3 ( bool * success = 0) const

Attempts to convert the Variant type to the indicated type.
A failed conversion will return 0, or whatever the default constructed value is in general.

Parameters
successIf provided, is true if the conversion was successful and false otherwise.

◆ toDVect3() [2/2]

template<class T >
constexpr DVect3 toDVect3 ( const Vector3< T > & v)
related

Conversion routines between various predefined types of Vector3.

◆ toDVMatrix() [1/2]

template<unsigned SX>
constexpr DVMatrix< SX > toDVMatrix ( const DVect2 & v,
unsigned start = 0 )
constexpr

Converts a DVect2 into a DVMatrix of arbitrary length, at an arbitrary starting index. Specialization of function toVMatrix, for convenience.

◆ toDVMatrix() [2/2]

template<unsigned SX>
DVMatrix< SX > constexpr toDVMatrix ( const DVect3 & v,
unsigned start = 0 )
constexpr

Converts a DVect3 into a DVMatrix of arbitrary length, at an arbitrary starting index. Specialization of function toVMatrix, for convenience.

◆ toFAVect2()

template<class T >
FAVect2 toFAVect2 ( const AVector2< T > & v)
related

Converts an AVector2<T> to a float version.

◆ toFAVect3()

template<class T >
FAVect3 toFAVect3 ( const Vector3< T > & v)
related

Converts a Vector3 to a float AVect3 (no loss of components)

◆ toFloat()

float Variant::toFloat ( bool * success = 0) const

Attempts to convert the Variant type to the indicated type.
A failed conversion will return 0, or whatever the default constructed value is in general.

Parameters
successIf provided, is true if the conversion was successful and false otherwise.

◆ toFVect2()

template<class T >
constexpr FVect2 toFVect2 ( const Vector2< T > & v)
related

Conversion routines between various predefined types of Vector2.

◆ toFVect3()

template<class T >
constexpr FVect3 toFVect3 ( const Vector3< T > & v)
related

Conversion routines between various predefined types of Vector3.

◆ toIAVect2()

template<class T >
IAVect2 toIAVect2 ( const AVector2< T > & v)
related

Converts an AVector2<T> to an int32 version

◆ toInt()

int32 Variant::toInt ( bool * success = 0) const

Attempts to convert the Variant type to the indicated type.
A failed conversion will return 0, or whatever the default constructed value is in general.

Parameters
successIf provided, is true if the conversion was successful and false otherwise.

◆ toIVect2() [1/2]

IVect2 Variant::toIVect2 ( bool * success = 0) const

Attempts to convert the Variant type to the indicated type.
A failed conversion will return 0, or whatever the default constructed value is in general.

Parameters
successIf provided, is true if the conversion was successful and false otherwise.

◆ toIVect2() [2/2]

template<class T >
constexpr IVect2 toIVect2 ( const Vector2< T > & v)
related

Conversion routines between various predefined types of Vector2.

◆ toIVect3() [1/2]

IVect3 Variant::toIVect3 ( bool * success = 0) const

Attempts to convert the Variant type to the indicated type.
A failed conversion will return 0, or whatever the default constructed value is in general.

Parameters
successIf provided, is true if the conversion was successful and false otherwise.

◆ toIVect3() [2/2]

template<class T >
constexpr IVect3 toIVect3 ( const Vector3< T > & v)
related

Conversion routines between various predefined types of Vector3.

◆ toLong()

int64 Variant::toLong ( bool * success = 0) const

Attempts to convert the Variant type to the indicated type.
A failed conversion will return 0, or whatever the default constructed value is in general.

Parameters
successIf provided, is true if the conversion was successful and false otherwise.

◆ toMatrix() [1/2]

template<class T >
constexpr VMatrix< T, 2 > toMatrix ( const Vector2< T > & v)
related

Converts a Vector2 into a VMatrix

◆ toMatrix() [2/2]

template<class T >
constexpr VMatrix< T, 3 > toMatrix ( const Vector3< T > & v)
related

Converts a Vector3 into a VMatrix

◆ toMatrix2()

template<unsigned SX, unsigned SY = SX>
BASE_EXPORT DMatrix< 2, 2 > toMatrix2 ( const SymTensor & s)
related

Converts a SymTensor into a Symmetrix 2x2 double matrix (DMatrix).

◆ toMatrix3()

template<unsigned SX, unsigned SY = SX>
BASE_EXPORT DMatrix< 3, 3 > toMatrix3 ( const SymTensor & s)
related

Converts a SymTensor into a Symmetrix 3x3 or 2x2 double matrix (DSymMatrix). Converts a SymTensor into a Symmetric 3x3 double matrix (DMatrix).

◆ toQString() [1/8]

BASE_EXPORT QString toQString ( bool b,
const QString & out = "on,off",
int width = 0,
char fill = ' ' )

Outputs a bool, using the out string (comma delimited) to determine the true of false output value. The default value of out is "on,off".

◆ toQString() [2/8]

template<class T >
QString toQString ( const AVector2< T > & v,
int width = 0,
char fmt = 'g',
int prec = -1,
char fill = ' ' )
inline

Converts a AVector2<T> to a string, using the save width, fmt, prec, and fill arguments as toQString(const double &,...). width indicates the total width, which is output in the format (x,y). This means each component gets (w-3)/2 characters width.

◆ toQString() [3/8]

template<class T >
QString toQString ( const AVector3< T > & v,
int width = 0,
char fmt = 'g',
int prec = -1,
char fill = ' ' )
inline

Converts a AVector3<T> to a string, using the save width, fmt, prec, and fill arguments as toQString(const double &,...). width indicates the total width, which is output in the format (x,y,z). This means each component gets (w-4)/3 characters width.

◆ toQString() [4/8]

BASE_EXPORT QString toQString ( const QString & s,
int width = 0,
char fill = ' ' )

Converts from a base type to a QString, using the width and fill character specified.

A positive width indicates right-aligned text, a negative width indicates left-aligned text.
For floating point values, the format specifications are:

  • 'e' format as [-]9.9e[+|-]99
  • 'E' format as [-]9.9E[+|-]99
  • 'f' format as [-]9.9
  • 'g' use e or f format, whichever is most concise.
  • 'G' use E or f format, whichever is most concise.

◆ toQString() [5/8]

BASE_EXPORT QString toQString ( const QVariant & v,
int width = 0,
char fill = ' ',
char format = 'g',
int precision = -1 )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

◆ toQString() [6/8]

QString toQString ( const std::wstring & in)
inline

converts a QString into a base string.

returns a copy of in converts a string to a wide character string converts a wide string into a QString

◆ toQString() [7/8]

template<class T >
QString toQString ( const Vector2< T > & v,
int width = 0,
char fmt = 'g',
int prec = -1,
char fill = ' ' )
inline

Converts a Vector2<T> to a string, using the save width, fmt, prec, and fill arguments as toQString(const double &,...). width indicates the total width, which is output in the format (x,y). This means each component gets (w-3)/2 characters width.

◆ toQString() [8/8]

template<class T >
QString toQString ( const Vector3< T > & v,
int width = 0,
char fmt = 'g',
int prec = -1,
char fill = ' ' )
inline

Converts a Vector3<T> to a string, using the save width, fmt, prec, and fill arguments as toQString(const double &,...). width indicates the total width, which is output in the format (x,y,z). This means each component gets (w-4)/3 characters width.

◆ toQVariant()

template<typename T >
QVariant toQVariant ( const T & t)

Convert a Variant to a QVariant. This works for any type, technically. For user-defined types, raw data, etc. the entire Variant is stored in the QVariant.

◆ toShort()

int16 Variant::toShort ( bool * success = 0) const

Attempts to convert the Variant type to the indicated type.
A failed conversion will return 0, or whatever the default constructed value is in general.

Parameters
successIf provided, is true if the conversion was successful and false otherwise.

◆ toString()

string Variant::toString ( bool * success = 0) const

Attempts to convert the Variant type to the indicated type.
A failed conversion will return 0, or whatever the default constructed value is in general.

Parameters
successIf provided, is true if the conversion was successful and false otherwise.

◆ toSymMatrix3()

template<unsigned SX, unsigned SY = SX>
BASE_EXPORT DSymMatrix< 3 > toSymMatrix3 ( const SymTensor & s)
related

Converts a SymTensor into a Symmetrix 3x3 double matrix (DSymMatrix).

◆ toSymTensor() [1/2]

template<unsigned SX, unsigned SY = SX>
SymTensor toSymTensor ( const DMatrix< 3, 3 > & m)
related

Converts a 3x3 DMatrix into a SymTensor. The diagonal components of m are averaged to create a Symmetric result.

◆ toSymTensor() [2/2]

template<unsigned SX>
SymTensor toSymTensor ( const DSymMatrix< 3 > & m)
related

Converts a 3x3 DSymMatrix into a SymTensor.

◆ toU64Vect3()

template<class T >
constexpr U64Vect3 toU64Vect3 ( const Vector3< T > & v)
related

Conversion routines between various predefined types of Vector3.

◆ toUAVect2()

template<class T >
UAVect2 toUAVect2 ( const AVector2< T > & v)
related

Converts an AVector2<T> to a uint32 version.

◆ toUByte()

uint8 Variant::toUByte ( bool * success = 0) const

Attempts to convert the Variant type to the indicated type.
A failed conversion will return 0, or whatever the default constructed value is in general.

Parameters
successIf provided, is true if the conversion was successful and false otherwise.

◆ toUInt()

uint32 Variant::toUInt ( bool * success = 0) const

Attempts to convert the Variant type to the indicated type.
A failed conversion will return 0, or whatever the default constructed value is in general.

Parameters
successIf provided, is true if the conversion was successful and false otherwise.

◆ toULong()

uint64 Variant::toULong ( bool * success = 0) const

Attempts to convert the Variant type to the indicated type.
A failed conversion will return 0, or whatever the default constructed value is in general.

Parameters
successIf provided, is true if the conversion was successful and false otherwise.

◆ toUserType()

template<class T >
T Variant::toUserType ( ) const

Attempts to convert the Variant to a specific user type. In general, conversion from different user-types is not possible, so this will only succeed if the Variant was set to exactly this type. Will return a default contructed value of type T if the conversion is not possible.

See also
setToUserType() isUserType() registerType() moveToUserType()

◆ toUShort()

uint16 Variant::toUShort ( bool * success = 0) const

Attempts to convert the Variant type to the indicated type.
A failed conversion will return 0, or whatever the default constructed value is in general.

Parameters
successIf provided, is true if the conversion was successful and false otherwise.

◆ toUVect2()

template<class T >
constexpr UVect2 toUVect2 ( const Vector2< T > & v)
related

Conversion routines between various predefined types of Vector2.

◆ toVariant()

BASE_EXPORT Variant toVariant ( const QVariant & v)

Convert a QVariant to a Variant. This does not work for user-defined types. If the QVariant type is not allowed by the Variant, an exception is thrown.

◆ toVect2() [1/3]

template<class T >
Vector2< T > toVect2 ( const AVector2< T > & )
related

Converts a AVector2 to an Vector2(0,0)

◆ toVect2() [2/3]

template<class T >
Vector2< T > toVect2 ( const AVector3< T > & v)
related

Converts a AVector3 to an Vector2(x,y) { the z component is lost }

◆ toVect2() [3/3]

template<class T >
constexpr Vector2< T > toVect2 ( const Vector3< T > & v)
inlineconstexpr

Conversion between vectors of different dimension.

◆ toVect3() [1/4]

template<class T >
Vector3< T > toVect3 ( const AVector2< T > & v)
related

Converts a AVector2 to an Vector3(0,0,z)

◆ toVect3() [2/4]

template<class T >
const Vector3< T > & toVect3 ( const AVector3< T > & v)
related

Converts a AVector3 to an Vector3 (no loss)

◆ toVect3() [3/4]

template<class T >
constexpr Vector3< T > toVect3 ( const Vector2< T > & v,
const T & t = 0 )
inlineconstexpr

Conversion between vectors of different dimension.

◆ toVect3() [4/4]

template<class T >
constexpr const Vector3< T > & toVect3 ( const Vector3< T > & v)
inlineconstexpr

Conversion between vectors of different dimension.

◆ toVoid()

void * Variant::toVoid ( bool * success = 0) const

Attempts to convert the Variant type to the indicated type.
A failed conversion will return 0, or whatever the default constructed value is in general.

Parameters
successIf provided, is true if the conversion was successful and false otherwise.

◆ Variant() [1/3]

BASE_EXPORT Variant::Variant ( const bool & v)
inline

Conversion contructor – this function and the ones like it allow automatic conversion of Variants from the built-in types.

◆ Variant() [2/3]

Variant::Variant ( const char * v)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

◆ Variant() [3/3]

BASE_EXPORT Variant::Variant ( const int32 & v = 0)
inline

Default constructor, also the int32 conversion constructor. Note that a default Variant is an integer of value 0.

◆ vceil() [1/4]

template<class T >
AVector2< T > vceil ( const AVector2< T > & v)
related

Returns the "ceil" of each component of the vector, only valid for double or float types.

◆ vceil() [2/4]

template<class T >
AVector3< T > vceil ( const AVector3< T > & v)
related

Returns the "ceil" of each component of the vector, only valid for double or float types.

◆ vceil() [3/4]

template<class T >
Vector2< T > vceil ( const Vector2< T > & v)
related

Returns the "ceil" of each component of the vector, only valid for double or float types.

◆ vceil() [4/4]

template<class T >
Vector3< T > vceil ( const Vector3< T > & v)
related

Returns the "ceil" of each component of the vector, only valid for double or float types.

◆ vfloor() [1/2]

template<class T >
Vector2< T > vfloor ( const Vector2< T > & v)
related

Returns the "floor" of each component of the vector, only valid for double or float types.

◆ vfloor() [2/2]

template<class T >
Vector3< T > vfloor ( const Vector3< T > & v)
related

Returns the "floor" of each component of the vector, only valid for double or float types.

◆ vmax() [1/4]

template<class T >
AVector2< T > vmax ( const AVector2< T > & v1,
const AVector2< T > & v2 )
related

Finds the "component" maximums, the return vector is the max of the respective components in v1,v2.

◆ vmax() [2/4]

template<class T >
AVector3< T > vmax ( const AVector3< T > & v1,
const AVector3< T > & v2 )
related

Finds the "component" maximums, the return vector is the max of the respective components in v1,v2.

◆ vmax() [3/4]

template<class T >
constexpr Vector2< T > vmax ( const Vector2< T > & v1,
const Vector2< T > & v2 )
related

Finds the "component" maximums, the return vector is the max of the respective components in v1,v2.

◆ vmax() [4/4]

template<class T >
constexpr Vector3< T > vmax ( const Vector3< T > & v1,
const Vector3< T > & v2 )
related

Finds the "component" maximums, the return vector is the max of the respective components in v1,v2.

◆ vmin() [1/4]

template<class T >
AVector2< T > vmin ( const AVector2< T > & v1,
const AVector2< T > & v2 )
related

Finds the "component" minimums, the return vector is the min of the respective components in v1,v2.

◆ vmin() [2/4]

template<class T >
AVector3< T > vmin ( const AVector3< T > & v1,
const AVector3< T > & v2 )
related

Finds the "component" minimums, the return vector is the min of the respective components in v1,v2.

◆ vmin() [3/4]

template<class T >
constexpr Vector2< T > vmin ( const Vector2< T > & v1,
const Vector2< T > & v2 )
related

Finds the "component" minimums, the return vector is the min of the respective components in v1,v2.

◆ vmin() [4/4]

template<class T >
constexpr Vector3< T > vmin ( const Vector3< T > & v1,
const Vector3< T > & v2 )
related

Finds the "component" minimums, the return vector is the min of the respective components in v1,v2.

◆ vround() [1/2]

template<class T >
IVect2 vround ( const Vector2< T > & v)
related

Returns the "round" of each component of the vector, only valid for double or float types.

◆ vround() [2/2]

template<class T >
IVect3 constexpr vround ( const Vector3< T > & v)
related

Returns the "round" of each component of the vector, only valid for double or float types.

◆ vsign() [1/4]

template<class T >
AVector2< T > vsign ( const AVector2< T > & v1,
const AVector2< T > & v2 )
related

This function returns the components of v1 with the same sign as the respective components in v2.

◆ vsign() [2/4]

template<class T >
AVector3< T > vsign ( const AVector3< T > & v1,
const AVector3< T > & v2 )
related

This function returns the components of v1 with the same sign as the respective components in v2.

◆ vsign() [3/4]

template<class T >
constexpr Vector2< T > vsign ( const Vector2< T > & v1,
const Vector2< T > & v2 )
related

This function returns the components of v1 with the same sign as the respective components in v2.

◆ vsign() [4/4]

template<class T >
constexpr Vector3< T > vsign ( const Vector3< T > & v1,
const Vector3< T > & v2 )
related

This function returns the components of v1 with the same sign as the respective components in v2.