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...

class	StringList

class	Buffer

struct	StringCILess

struct	StringCIEqual

struct	StringCIHash

struct	FormatCheck< Args >

struct	std::formatter< StringList >

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, I >
	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	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...

struct	set_constness_of< T >

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	std::formatter< Vector2< T > >

struct	std::formatter< Vector3< T > >

Macros
#define	BASE_EXPORT IMPORT_TAG

#define	OSVAL(x, y) x

#define	filesystem ERROR_USE_SHARED_FILESTORE_INSTEAD

#define	FOR(x, y) for (auto x=(y).begin();x!=(y).end();++x)

#define	NEW new

#define	NEWN(x) new

#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
using	DAVect2 = AVector2<double>

using	FAVect2 = AVector2<float>

using	IAVect2 = AVector2<int32>

using	UAVect2 = AVector2<uint32>

using	DAVect3 = AVector3<double>

using	FAVect3 = AVector3<float>

using	IAVect3 = AVector3<int32>

using	UAVect3 = AVector3<uint32>

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

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>

using	StateInfoOutput = StringMap<StringList>

typedef Cube< double >	DCube

typedef Cube< float >	FCube

typedef Cube< int32 >	ICube

typedef Cube< uint32 >	UCube

using	DExtent2 = Extent2<double>

using	FExtent2 = Extent2<float>

using	IExtent2 = Extent2<int32>

using	UExtent2 = Extent2<uint32>

using	I64Extent2 = Extent2<int64>

using	U64Extent2 = Extent2<uint64>

using	DExtent3 = Extent3<double>

using	FExtent3 = Extent3<float>

using	IExtent3 = Extent3<int32>

using	UExtent3 = Extent3<uint32>

using	I64Extent3 = Extent3<int64>

using	U64Extent3 = Extent3<uint64>

template<unsigned SX, unsigned SY = SX>
using	DMatrix = Matrix<double,SX,SY>
	DMatrix is a Matrix that defaults to type double...

template<unsigned SX>
using	DSymMatrix = SymMatrix<double,SX>
	DSymMatrix is a SymMatrix that defaults to type double...

template<unsigned S>
using	DVMatrix = VMatrix<double,S>
	DVMatrix is a double version of VMatrix.

using	DVect2 = Vector2<double>

using	FVect2 = Vector2<float>

using	IVect2 = Vector2<int32>

using	UVect2 = Vector2<uint32>

using	I64Vect2 = Vector2<int64>

using	U64Vect2 = Vector2<uint64>

using	DVect3 = Vector3<double>

using	FVect3 = Vector3<float>

using	IVect3 = Vector3<int32>

using	UVect3 = Vector3<uint32>

using	I64Vect3 = Vector3<int64>

using	U64Vect3 = Vector3<uint64>

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 >
constexpr T	safeMag2 (const AVector2< T > &v)

template<typename T >
constexpr T	safeMag (const AVector2< T > &v)

template<typename T >
constexpr AVector2< T >	safeUnit (const AVector2< T > &v)

template<typename T >
constexpr const AVector2< T >	safeDiv (const AVector2< T > &a, const AVector2< T > &b, const AVector2< T > &safe=AVector2< T >(0))

template<typename T >
constexpr const AVector2< T >	safeDiv (const AVector2< T > &a, const T &v, const AVector2< T > &safe=AVector2< T >(0))

template<typename T >
constexpr bool	isFinite (const AVector2< T > &a)

template<typename T , typename U >
constexpr const T &	osval (const T &wval, const U &)

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>
T	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)

template<typename ... Args>
string	rformat (const string &s, Args...args)

	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

	StringList::StringList (const string_view &s)

const StringList &	StringList::operator= (const StringList &in)

const StringList &	StringList::operator+= (const string &s)

const StringList &	StringList::operator+= (const std::vector< string > &v)

const StringList &	StringList::operator<< (const string &s)

const StringList &	StringList::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 size_t	find (const StringList &s, const string &s2, bool caseSensitive=false)

BASE_EXPORT size_t	remove (StringList *s, const string_view &s2, bool caseSensitive=false)

BASE_EXPORT string::size_type	findRegex (const StringList &s, const string_view &regex, string::size_type start=0)

BASE_EXPORT StringList	removeDuplicates (const StringList &s)

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)

string	tostring (const char *s)

string	tostring (const string &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	toBase64 (const std::vector< char > &in)

BASE_EXPORT std::vector< char >	fromBase64 (const string &in)

BASE_EXPORT string	toUpper (const string_view &s)

BASE_EXPORT string	toLower (const string_view &s)

BASE_EXPORT string	capitalizeFirstLetter (const string_view &s)

BASE_EXPORT uint64	caseInsensitiveHash (const string_view &s)

template<typename T , typename U >
T	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	cleanupTypename (const char *name)

BASE_EXPORT string	remove (string s, char c)

string	remove (string s, const string_view &sub, bool caseSensitive=false)

BASE_EXPORT string	remove (string s, string::size_type start, string::size_type len)

string_view	chopped (const string_view &s, string::size_type i)

BASE_EXPORT string	clip (const string_view &s, string::size_type n)

BASE_EXPORT string	enquoteString (const string &s, char quote='"')

BASE_EXPORT string_view	substr (const string_view &s, string::size_type pos, string::size_type count=string::npos)

string_view	right (const string_view &s, string::size_type num)

BASE_EXPORT string	buildRandom (string::size_type length)

BASE_EXPORT int32	compare (const string_view &s1, const string_view &s2, bool caseSensitive=false)

bool	equal (const string_view &s, const string_view &c, bool caseSensitive=false)

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)

bool	containsRegex (const string_view &in, const string_view &regex)

BASE_EXPORT bool	wildcardMatch (const string_view &patter, const string_view &test)

BASE_EXPORT uint64	firstNonBlankCharacter (const string_view &s)

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 Buffer &	Buffer::operator= (const std::vector< char > &v)

const Buffer &	Buffer::operator= (std::vector< char > &&v)

void	Buffer::append (const char *data, uint64 len)

void	Buffer::operator+= (const string &s)

void	Buffer::operator+= (const Buffer &s)

string	Buffer::toString () const

string_view	Buffer::toStringView () const

const char *	Buffer::constData () const

BASE_EXPORT bool	match (const string &keyword, const string &token, bool forceAbbreviationsAllowed=false)
	‍**

BASE_EXPORT uint32	match (const StringList &keywords, const string &token, bool forceAbbreviationsAllowed=false)

BASE_EXPORT void	matchSynonymsAllowed (bool b)

BASE_EXPORT bool	matchSynonymsAllowed ()

BASE_EXPORT string	getKeyword (const StringList &keywords, const uint64 index, const string &def={})

string	getKeyword (const string &keywords, const uint64 index, const string &def={})

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_view &)

template<>
std::tuple< int32, bool >	base::fsTest (const string_view &in)

template<typename T >
T	base::fs (const string_view &, bool throwException=false)

template<>
int32	base::fs (const string_view &in, bool throwException)

bool	StringCILess::operator() (const string_view &left, const string_view &right) const

bool	StringCIEqual::operator() (const string_view &left, const string_view &right) const

uint64	StringCIHash::operator() (const string_view &in) const

template<unsigned N>
consteval	FormatCheck< Args >::FormatCheck (const char(&s)[N])

template<typename ParseContext >
constexpr auto	std::formatter< StringList >::parse (ParseContext &ctx)

template<typename FormatContext >
constexpr auto	std::formatter< StringList >::format (StringList const &val, FormatContext &ctx) const

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 >
PUSHWARNING constexpr const T	safeDiv (const T num, const T denom, const T safeVal=0)
	This function provids "safe" division operation, checks explicitly for zero.

	Variant::UserTypeBase::UserTypeBase ()
	Default constructor, no data initialization.

virtual	Variant::UserTypeBase::~UserTypeBase ()
	Deconstructor.

virtual UserTypeBase *	Variant::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 Variant &	Variant::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 DVect2 &	Variant::fastToDVect2 () const

BASE_EXPORT const DVect3 &	Variant::fastToDVect3 () const

BASE_EXPORT const string &	Variant::fastToString () const

const Variant &	Variant::operator= (const bool &v)
	Assignment operator for a specific type, converts the Variant to the same type and value.

const Variant &	Variant::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 Variant &	Variant::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 Variant &	Variant::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 Variant &	Variant::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 Variant &	Variant::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 Variant &	Variant::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 Variant &	Variant::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 Variant &	Variant::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 Variant &	Variant::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 Variant &	Variant::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 Variant &	Variant::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 Variant &	Variant::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 Variant &	Variant::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 Variant &	Variant::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 Variant &	Variant::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 Variant &	Variant::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 Variant &	Variant::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 Variant &	Variant::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 Variant &	Variant::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 >
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<typename T >
constexpr T	safeMag2 (const Vector2< T > &v)

template<typename T >
constexpr T	safeMag (const Vector2< T > &v)

template<typename T >
constexpr const Vector2< T >	safeDiv (const Vector2< T > &a, const Vector2< T > &b, const Vector2< T > &safe=Vector2< T >(0))
	"Safe" division operation - checks for zero and overflow.

template<typename T >
constexpr const Vector2< T >	safeDiv (const Vector2< T > &a, const T &v, const Vector2< T > &safe=Vector2< T >(0))

template<typename T >
constexpr Vector2< T >	safeUnit (const Vector2< T > &v)

template<typename T >
constexpr bool	isFinite (const Vector2< T > &a)

template<typename T >
constexpr T	safeMag2 (const Vector3< T > &v)

template<typename T >
constexpr T	safeMag (const Vector3< T > &v)

template<typename T >
constexpr const Vector3< T >	safeDiv (const Vector3< T > &a, const Vector3< T > &b, const Vector3< T > &safe=Vector3< T >(0))
	"Safe" division operation - checks for zero and overflow.

template<typename T >
constexpr const Vector3< T >	safeDiv (const Vector3< T > &a, const T &v, const Vector3< T > &safe=Vector3< T >(0))

template<typename T >
constexpr Vector3< T >	safeUnit (const Vector3< T > &v)

template<typename T >
constexpr bool	isFinite (const Vector3< T > &a)

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 >
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, I >::FArray (size_type s, const T &t=T())

	FArray< T, S, I >::FArray (std::initializer_list< T > l)

constexpr const FArray< T, S, I > &	FArray< T, S, I >::operator= (const FArray< T, S, I > &f)

template<uint64 S2>
bool	FArray< T, S, I >::operator== (const FArray< T, S2, I > &f) const

template<uint64 S2>
constexpr const FArray< T, S, I > &	FArray< T, S, I >::operator= (const FArray< T, S2, I > &f)
	Assignment operator, valid for FArrays of the same data type but different stack lengths.

I	FArray< T, S, I >::find (const T &t) const

T *	FArray< T, S, I >::emplace_n_back (size_type n)

void	FArray< T, S, I >::resize (I i, const T &t=T())

iterator	FArray< T, S, I >::insert (I i, const T &t)

void	FArray< T, S, I >::put (I 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, I >::append (const C &in)
	Appends the contents of one FArray onto another.

iterator	FArray< T, S, I >::insert (iterator it, const T &t)

bool	FArray< T, S, I >::remove (I i)

size_type	FArray< T, S, I >::removeAll (const T &t)

void	FArray< T, S, I >::clear ()

void	FArray< T, S, I >::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)

bool	SymTensor::operator== (const SymTensor &s) const
	Equality operator.

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 SymTensor &	*SymTensor::operator=** (const double &mul)

SymTensor	SymTensor::operator/ (const double &mul) const

const SymTensor &	SymTensor::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
BASE_EXPORT bool	isConsoleVersion

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

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, typename I >

void FArray< T, S, I >::clear ( )

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

◆ 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 )

MOO NOTE: Eventually want to add specialization for SymMatrix.

◆ emplace_n_back()

template<typename T , uint64 S, typename I >

T * FArray< T, S, I >::emplace_n_back ( size_type 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, typename I >

FArray< T, S, I >::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

s	Initial size of the array.
t	The 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, typename I >

I FArray< T, S, I >::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.

◆ 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().

◆ insert() [1/2]

template<typename T , uint64 S, typename I >

FArray< T, S, I >::iterator FArray< T, S, I >::insert	(	I	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.

◆ insert() [2/2]

template<typename T , uint64 S, typename I >

FArray< T, S, I >::iterator FArray< T, S, I >::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.

◆ inverse() [1/2]

template<class T >

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

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 )

MOO NOTE: Eventually want to add specialization for SymMatrix.

◆ 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,
		bool	forceAbbreviationsAllowed = false )

‍**

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 )

◆ operator&() [2/3]

template<class T >

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

◆ operator&() [3/3]

template<class T >

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

◆ 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 )

◆ operator*() [3/5]

template<class T >

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

◆ operator*() [4/5]

template<class T >

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

◆ operator*() [5/5]

template<class T >

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

◆ operator[]()

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 > &	)

◆ 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:
qint32 VUserType<MyType>::typeNumber_(0);

void myInitializationRoutine()

{

Variant::registerType<MyType>(Variant::UserType+20,"My Type");

}

Variant::VUserType
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, typename I >

bool FArray< T, S, I >::remove ( I 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, typename I >

FArray< T, S, I >::size_type FArray< T, S, I >::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, typename I >

void FArray< T, S, I >::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, typename I >

void FArray< T, S, I >::resize	(	I	i,
		const T &	t = T() )

Parameters

i	The new array length.
t	The 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 >

PUSHWARNING constexpr const T safeDiv	(	const T	num,
		const T	denom,
		const T	safeVal = 0 )

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)

◆ 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 )

◆ toAUVect3()

template<class T >

UAVect3 toAUVect3 ( const Vector3< T > & v )

◆ toAVect2() [1/2]

template<class T >

const AVector2< T > & toAVect2 ( const AVector2< T > & v )

◆ toAVect2() [2/2]

template<class T >

AVector2< T > toAVect2 ( const AVector3< T > & v )

◆ toAVect3() [1/2]

template<class T >

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

◆ toAVect3() [2/2]

template<class T >

const AVector3< T > & toAVect3 ( const AVector3< T > & v )

◆ toBool()

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

success If provided, is true if the conversion was successful and 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

success If provided, is true if the conversion was successful and false otherwise.

◆ toDAVect2()

template<class T >

DAVect2 toDAVect2 ( const AVector2< T > & v )

◆ toDAVect3()

template<class T >

DAVect3 toDAVect3 ( const Vector3< T > & v )

◆ 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

success If 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

success If provided, is true if the conversion was successful and false otherwise.

◆ toDVect2() [2/2]

template<class T >

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

◆ 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

success If provided, is true if the conversion was successful and false otherwise.

◆ toDVect3() [2/2]

template<class T >

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

◆ 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 )

◆ toFAVect3()

template<class T >

FAVect3 toFAVect3 ( const Vector3< T > & v )

◆ 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

success If provided, is true if the conversion was successful and false otherwise.

◆ toFVect2()

template<class T >

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

◆ toFVect3()

template<class T >

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

◆ toIAVect2()

template<class T >

IAVect2 toIAVect2 ( const AVector2< T > & v )

◆ 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

success If 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

success If provided, is true if the conversion was successful and false otherwise.

◆ toIVect2() [2/2]

template<class T >

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

◆ 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

success If provided, is true if the conversion was successful and false otherwise.

◆ toIVect3() [2/2]

template<class T >

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

◆ 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

success If 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 )

◆ toMatrix() [2/2]

template<class T >

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

◆ 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

success If 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

success If provided, is true if the conversion was successful and false otherwise.

◆ toU64Vect3()

template<class T >

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

◆ toUAVect2()

template<class T >

UAVect2 toUAVect2 ( const AVector2< T > & v )

◆ 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

success If 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

success If 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

success If 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

success If provided, is true if the conversion was successful and false otherwise.

◆ toUVect2()

template<class T >

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

◆ toVect2() [1/3]

template<class T >

Vector2< T > toVect2 ( const AVector2< T > & )

◆ toVect2() [2/3]

template<class T >

Vector2< T > toVect2 ( const AVector3< T > & v )

◆ 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 )

◆ toVect3() [2/4]

template<class T >

const Vector3< T > & toVect3 ( const AVector3< T > & v )

◆ 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

success If 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 )

◆ vceil() [2/4]

template<class T >

AVector3< T > vceil ( const AVector3< T > & v )

◆ vceil() [3/4]

template<class T >

Vector2< T > vceil ( const Vector2< T > & v )

◆ vceil() [4/4]

template<class T >

Vector3< T > vceil ( const Vector3< T > & v )

◆ vfloor() [1/2]

template<class T >

Vector2< T > vfloor ( const Vector2< T > & v )

◆ vfloor() [2/2]

template<class T >

Vector3< T > vfloor ( const Vector3< T > & v )

◆ vmax() [1/4]

template<class T >

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

◆ vmax() [2/4]

template<class T >

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

◆ vmax() [3/4]

template<class T >

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

◆ vmax() [4/4]

template<class T >

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

◆ vmin() [1/4]

template<class T >

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

◆ vmin() [2/4]

template<class T >

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

◆ vmin() [3/4]

template<class T >

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

◆ vmin() [4/4]

template<class T >

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

◆ vround() [1/2]

template<class T >

IVect2 vround ( const Vector2< T > & v )

◆ vround() [2/2]

template<class T >

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

◆ vsign() [1/4]

template<class T >

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

◆ vsign() [2/4]

template<class T >

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

◆ vsign() [3/4]

template<class T >

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

◆ vsign() [4/4]

template<class T >

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

Namespaces

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Friends

Detailed Description

Macro Definition Documentation

◆ BASE_EXPORT

Enumeration Type Documentation

◆ Type

Function Documentation

◆ check_cast() [1/2]

◆ check_cast() [2/2]

◆ clear()

◆ convertToUserType()

◆ determinant()

◆ emplace_n_back()

◆ FArray()

◆ fastToBool()

◆ fastToDouble()

◆ fastToDVect2()

◆ fastToDVect3()

◆ fastToInt()

◆ fastToLong()

◆ fastToString()

◆ fastToUserType() [1/2]

◆ fastToUserType() [2/2]

◆ find()

◆ getRawData() [1/2]

◆ getRawData() [2/2]

◆ getRawDataSize()

◆ getTotalMeasure()

◆ getUserTypeClaimed()

◆ insert() [1/2]

◆ insert() [2/2]

◆ inverse() [1/2]

◆ inverse() [2/2]

◆ isUserType()

◆ match()

◆ moveToUserType()

◆ operator&() [1/3]

◆ operator&() [2/3]

◆ operator&() [3/3]

◆ operator*() [1/5]

◆ operator*() [2/5]

◆ operator*() [3/5]

◆ operator*() [4/5]

◆ operator*() [5/5]

◆ operator[]()

◆ operator|()

◆ registerType()

◆ remove()

◆ removeAll()

◆ reset()

◆ resize()

◆ safeDiv()

◆ setToRawData()

◆ setToUserType()

◆ to()

◆ toAIVect3()

◆ toAUVect3()

◆ toAVect2() [1/2]

◆ toAVect2() [2/2]

◆ toAVect3() [1/2]

◆ toAVect3() [2/2]

◆ toBool()

◆ toByte()

◆ toDAVect2()

◆ toDAVect3()

◆ toDouble()

◆ toDVect2() [1/2]

◆ toDVect2() [2/2]

◆ toDVect3() [1/2]

◆ toDVect3() [2/2]

◆ toDVMatrix() [1/2]

◆ toDVMatrix() [2/2]

◆ toFAVect2()