A convenience header to include all aron files (full include, not forward declared) More...

Namespaces
namespace	converter

namespace	defaultconversion

namespace	detail

namespace	reader

namespace	rw

namespace	writer

Classes
class	AnyObject
	The AnyObject class. More...

class	Bool
	The Bool class. More...

struct	ConstNlohmannJSONVisitor
	The NlohmannJSONVisitor struct. More...

struct	ConstVariantVisitor
	The VariantVisitor struct. More...

struct	Converter
	Converter struct providing the needed methods. More...

class	Dict
	The Dict class. More...

class	Double
	The Double class. More...

class	Float
	The Float class. More...

struct	FromNlohmannJSONConverter

struct	FromVariantConverter

class	Image
	The Image class. More...

class	Int
	The Int class. More...

class	IntEnum
	The IntEnum class. More...

class	List
	The List class. More...

class	Long
	The Long class. More...

class	Matrix
	The Matrix class. More...

class	NDArray
	The NDArray class. More...

class	Object
	The Object class. More...

class	Pair
	The Pair class. More...

class	PointCloud
	The PointCloud class. More...

class	Quaternion
	The Qaternion class. More...

class	ReaderInterface
	The ReaderInterface class. More...

struct	RecursiveConstVariantVisitor
	The RecursiveVariantVisitor struct. More...

struct	RecursiveVisitor
	The RecursiveVisitor struct. More...

class	String
	The String class. More...

struct	ToNlohmannJSONConverter

struct	ToVariantConverter

class	Tuple
	The Tuple class. More...

class	Variant
	The Variant class. More...

class	VariantFactory
	The VariantFactory class. More...

struct	Visitor
	The Visitor struct. More...

struct	VisitorBase
	The VisitorBase struct. More...

class	WriterInterface
	The WriterInterface class. More...

Typedefs
using	AnyObjectPtr = std::shared_ptr<class AnyObject>

using	BoolPtr = std::shared_ptr<class Bool>

using	DictPtr = std::shared_ptr<class Dict>

using	DoublePtr = std::shared_ptr<class Double>

using	FloatPtr = std::shared_ptr<class Float>

using	ImagePtr = std::shared_ptr<class Image>

using	IntEnumPtr = std::shared_ptr<IntEnum>

using	IntPtr = std::shared_ptr<class Int>

using	ListPtr = std::shared_ptr<class List>

using	LongPtr = std::shared_ptr<class Long>

using	MatrixPtr = std::shared_ptr<class Matrix>

using	NDArrayPtr = std::shared_ptr<class NDArray>

using	ObjectPtr = std::shared_ptr<Object>

using	PairPtr = std::shared_ptr<class Pair>

using	PointCloudPtr = std::shared_ptr<class PointCloud>

using	QuaternionPtr = std::shared_ptr<class Quaternion>

using	StringPtr = std::shared_ptr<class String>

using	TuplePtr = std::shared_ptr<class Tuple>

typedef std::unique_ptr< VariantFactory >	VariantFactoryPtr

using	VariantPtr = std::shared_ptr<Variant>

Enumerations
enum class	Descriptor { LIST , OBJECT , TUPLE , PAIR , DICT , NDARRAY , MATRIX , QUATERNION , POINTCLOUD , IMAGE , INT_ENUM , INT , LONG , FLOAT , DOUBLE , BOOL , STRING , ANY_OBJECT , UNKNOWN = -1 }

Functions
type::Descriptor	Aron2Descriptor (const type::dto::GenericType &t)

template<class ConverterImplementation> requires isConverter<ConverterImplementation>
ConverterImplementation::WriterReturnType	readAndWrite (typename ConverterImplementation::ReaderInputType &o)
	the function to read from a variant and write to a writer T returns the returntype of T

template<class VisitorImplementation>
void	visit (VisitorImplementation &v, typename VisitorImplementation::Input &t)
	The visit function.

template<class RecursiveVisitorImplementation>
void	visitRecursive (RecursiveVisitorImplementation &v, typename RecursiveVisitorImplementation::Input &t)
	The visitRecursive function.

Variables
const std::vector< type::Descriptor >	AllDescriptors

const std::vector< type::Maybe >	AllMaybeTypes

Detailed Description

A convenience header to include all aron files (full include, not forward declared)

A convenience header to include all ndarray aron files (full include, not forward declared)

forward declarations of ALL aron type objects

A convenience header to include all enum aron files (full include, not forward declared)

A convenience header to include all container aron files (full include, not forward declared)

A convenience header to include all primitive aron files (full include, not forward declared)

Typedef Documentation

◆ AnyObjectPtr

using AnyObjectPtr = std::shared_ptr<class AnyObject>

◆ BoolPtr

using BoolPtr = std::shared_ptr<class Bool>

◆ DictPtr

using DictPtr = std::shared_ptr<class Dict>

◆ DoublePtr

using DoublePtr = std::shared_ptr<class Double>

◆ FloatPtr

using FloatPtr = std::shared_ptr<class Float>

◆ ImagePtr

using ImagePtr = std::shared_ptr<class Image>

◆ IntEnumPtr

typedef std::shared_ptr< class IntEnum > IntEnumPtr = std::shared_ptr<IntEnum>

◆ IntPtr

using IntPtr = std::shared_ptr<class Int>

◆ ListPtr

using ListPtr = std::shared_ptr<class List>

◆ LongPtr

using LongPtr = std::shared_ptr<class Long>

◆ MatrixPtr

using MatrixPtr = std::shared_ptr<class Matrix>

◆ NDArrayPtr

using NDArrayPtr = std::shared_ptr<class NDArray>

◆ ObjectPtr

typedef std::shared_ptr< class Object > ObjectPtr = std::shared_ptr<Object>

◆ PairPtr

using PairPtr = std::shared_ptr<class Pair>

◆ PointCloudPtr

using PointCloudPtr = std::shared_ptr<class PointCloud>

◆ QuaternionPtr

using QuaternionPtr = std::shared_ptr<class Quaternion>

◆ StringPtr

using StringPtr = std::shared_ptr<class String>

◆ TuplePtr

using TuplePtr = std::shared_ptr<class Tuple>

◆ VariantFactoryPtr

typedef std::unique_ptr<VariantFactory> VariantFactoryPtr

◆ VariantPtr

typedef std::shared_ptr< Variant > VariantPtr = std::shared_ptr<Variant>

Enumeration Type Documentation

◆ Descriptor

enum class Descriptor

strong

Enumerator
LIST
OBJECT
TUPLE
PAIR
DICT
NDARRAY
MATRIX
QUATERNION
POINTCLOUD
IMAGE
INT_ENUM
INT
LONG
FLOAT
DOUBLE
BOOL
STRING
ANY_OBJECT
UNKNOWN

Function Documentation

◆ Aron2Descriptor()

type::Descriptor Aron2Descriptor ( const type::dto::GenericType & t )

inline

◆ readAndWrite()

template<class ConverterImplementation>
requires isConverter<ConverterImplementation>

ConverterImplementation::WriterReturnType readAndWrite ( typename ConverterImplementation::ReaderInputType & o )

the function to read from a variant and write to a writer T returns the returntype of T

◆ visit()

template<class VisitorImplementation>

void visit	(	VisitorImplementation &	v,
		typename VisitorImplementation::Input &	t )

The visit function.

Takes a visitor implementation as input and a type representation (e.g. aron::type::variant or nlohmann::json). Inspired by std::visit for std::variant This method only performs a single visit. This is useful if you only want to call a specific method depending on the type, or if you want to call a customized recursive function If you want to call a visitX recursively, please refer to "RecursiveVisitor.h"

◆ visitRecursive()

template<class RecursiveVisitorImplementation>

void visitRecursive	(	RecursiveVisitorImplementation &	v,
		typename RecursiveVisitorImplementation::Input &	t )

The visitRecursive function.

Calls visitX of a RecursiveVisitorImplementation recursively. For more information please see Visitor.h

Variable Documentation

◆ AllDescriptors

const std::vector<type::Descriptor> AllDescriptors

Initial value:

= {Descriptor::LIST,
                                                          Descriptor::OBJECT,
                                                          Descriptor::TUPLE,
                                                          Descriptor::PAIR,
                                                          Descriptor::DICT,
                                                          Descriptor::NDARRAY,
                                                          Descriptor::MATRIX,
                                                          Descriptor::QUATERNION,
                                                          Descriptor::POINTCLOUD,
                                                          Descriptor::IMAGE,
                                                          Descriptor::INT_ENUM,
                                                          Descriptor::INT,
                                                          Descriptor::LONG,
                                                          Descriptor::FLOAT,
                                                          Descriptor::DOUBLE,
                                                          Descriptor::BOOL,
                                                          Descriptor::STRING,
                                                          Descriptor::ANY_OBJECT,
                                                          Descriptor::UNKNOWN}

◆ AllMaybeTypes

const std::vector<type::Maybe> AllMaybeTypes