libigl v2.5.0
Loading...
Searching...
No Matches
Classes | Functions
igl::serialization Namespace Reference

Classes

struct  is_eigen_type
 
struct  is_eigen_type< Eigen::Array< T, R, C, P, MR, MC > >
 
struct  is_eigen_type< Eigen::Matrix< T, R, C, P, MR, MC > >
 
struct  is_eigen_type< Eigen::SparseMatrix< T, P, I > >
 
struct  is_serializable
 
struct  is_smart_ptr
 
struct  is_smart_ptr< std::shared_ptr< T > >
 
struct  is_smart_ptr< std::unique_ptr< T > >
 
struct  is_smart_ptr< std::weak_ptr< T > >
 
struct  is_stl_container
 
struct  is_stl_container< std::list< T > >
 
struct  is_stl_container< std::map< T1, T2 > >
 
struct  is_stl_container< std::pair< T1, T2 > >
 
struct  is_stl_container< std::set< T > >
 
struct  is_stl_container< std::vector< T1, T2 > >
 

Functions

void serialization (bool s, igl::opengl::ViewerCore &obj, std::vector< char > &buffer)
 
template<>
void serialize (const igl::opengl::ViewerCore &obj, std::vector< char > &buffer)
 
template<>
void deserialize (igl::opengl::ViewerCore &obj, const std::vector< char > &buffer)
 
void serialization (bool s, igl::opengl::ViewerData &obj, std::vector< char > &buffer)
 
template<>
void serialize (const igl::opengl::ViewerData &obj, std::vector< char > &buffer)
 
template<>
void deserialize (igl::opengl::ViewerData &obj, const std::vector< char > &buffer)
 
template<typename T >
std::enable_if<!is_serializable< T >::value, size_t >::type getByteSize (const T &obj)
 
template<typename T >
std::enable_if<!is_serializable< T >::value >::type serialize (const T &obj, std::vector< char > &buffer, std::vector< char >::iterator &iter)
 
template<typename T >
std::enable_if<!is_serializable< T >::value >::type deserialize (T &obj, std::vector< char >::const_iterator &iter)
 
template<typename T >
std::enable_if< std::is_fundamental< T >::value, size_t >::type getByteSize (const T &obj)
 
template<typename T >
std::enable_if< std::is_fundamental< T >::value >::type serialize (const T &obj, std::vector< char > &buffer, std::vector< char >::iterator &iter)
 
template<typename T >
std::enable_if< std::is_fundamental< T >::value >::type deserialize (T &obj, std::vector< char >::const_iterator &iter)
 
size_t getByteSize (const std::string &obj)
 
void serialize (const std::string &obj, std::vector< char > &buffer, std::vector< char >::iterator &iter)
 
void deserialize (std::string &obj, std::vector< char >::const_iterator &iter)
 
template<typename T >
std::enable_if< std::is_enum< T >::value, size_t >::type getByteSize (const T &obj)
 
template<typename T >
std::enable_if< std::is_enum< T >::value >::type serialize (const T &obj, std::vector< char > &buffer, std::vector< char >::iterator &iter)
 
template<typename T >
std::enable_if< std::is_enum< T >::value >::type deserialize (T &obj, std::vector< char >::const_iterator &iter)
 
template<typename T >
std::enable_if< std::is_base_of< SerializableBase, T >::value, size_t >::type getByteSize (const T &obj)
 
template<typename T >
std::enable_if< std::is_base_of< SerializableBase, T >::value >::type serialize (const T &obj, std::vector< char > &buffer, std::vector< char >::iterator &iter)
 
template<typename T >
std::enable_if< std::is_base_of< SerializableBase, T >::value >::type deserialize (T &obj, std::vector< char >::const_iterator &iter)
 
template<typename T1 , typename T2 >
size_t getByteSize (const std::pair< T1, T2 > &obj)
 
template<typename T1 , typename T2 >
void serialize (const std::pair< T1, T2 > &obj, std::vector< char > &buffer, std::vector< char >::iterator &iter)
 
template<typename T1 , typename T2 >
void deserialize (std::pair< T1, T2 > &obj, std::vector< char >::const_iterator &iter)
 
template<typename T1 , typename T2 >
size_t getByteSize (const std::vector< T1, T2 > &obj)
 
template<typename T1 , typename T2 >
void serialize (const std::vector< T1, T2 > &obj, std::vector< char > &buffer, std::vector< char >::iterator &iter)
 
template<typename T1 , typename T2 >
void deserialize (std::vector< T1, T2 > &obj, std::vector< char >::const_iterator &iter)
 
template<typename T2 >
void deserialize (std::vector< bool, T2 > &obj, std::vector< char >::const_iterator &iter)
 
template<typename T >
size_t getByteSize (const std::set< T > &obj)
 
template<typename T >
void serialize (const std::set< T > &obj, std::vector< char > &buffer, std::vector< char >::iterator &iter)
 
template<typename T >
void deserialize (std::set< T > &obj, std::vector< char >::const_iterator &iter)
 
template<typename T1 , typename T2 >
size_t getByteSize (const std::map< T1, T2 > &obj)
 
template<typename T1 , typename T2 >
void serialize (const std::map< T1, T2 > &obj, std::vector< char > &buffer, std::vector< char >::iterator &iter)
 
template<typename T1 , typename T2 >
void deserialize (std::map< T1, T2 > &obj, std::vector< char >::const_iterator &iter)
 
template<typename T >
size_t getByteSize (const std::list< T > &obj)
 
template<typename T >
void serialize (const std::list< T > &obj, std::vector< char > &buffer, std::vector< char >::iterator &iter)
 
template<typename T >
void deserialize (std::list< T > &obj, std::vector< char >::const_iterator &iter)
 
template<typename T , int R, int C, int P, int MR, int MC>
size_t getByteSize (const Eigen::Matrix< T, R, C, P, MR, MC > &obj)
 
template<typename T , int R, int C, int P, int MR, int MC>
void serialize (const Eigen::Matrix< T, R, C, P, MR, MC > &obj, std::vector< char > &buffer, std::vector< char >::iterator &iter)
 
template<typename T , int R, int C, int P, int MR, int MC>
void deserialize (Eigen::Matrix< T, R, C, P, MR, MC > &obj, std::vector< char >::const_iterator &iter)
 
template<typename T , int R, int C, int P, int MR, int MC>
size_t getByteSize (const Eigen::Array< T, R, C, P, MR, MC > &obj)
 
template<typename T , int R, int C, int P, int MR, int MC>
void serialize (const Eigen::Array< T, R, C, P, MR, MC > &obj, std::vector< char > &buffer, std::vector< char >::iterator &iter)
 
template<typename T , int R, int C, int P, int MR, int MC>
void deserialize (Eigen::Array< T, R, C, P, MR, MC > &obj, std::vector< char >::const_iterator &iter)
 
template<typename T , int P, typename I >
size_t getByteSize (const Eigen::SparseMatrix< T, P, I > &obj)
 
template<typename T , int P, typename I >
void serialize (const Eigen::SparseMatrix< T, P, I > &obj, std::vector< char > &buffer, std::vector< char >::iterator &iter)
 
template<typename T , int P, typename I >
void deserialize (Eigen::SparseMatrix< T, P, I > &obj, std::vector< char >::const_iterator &iter)
 
template<typename T , int P>
size_t getByteSize (const Eigen::Quaternion< T, P > &obj)
 
template<typename T , int P>
void serialize (const Eigen::Quaternion< T, P > &obj, std::vector< char > &buffer, std::vector< char >::iterator &iter)
 
template<typename T , int P>
void deserialize (Eigen::Quaternion< T, P > &obj, std::vector< char >::const_iterator &iter)
 
template<typename T >
std::enable_if< std::is_pointer< T >::value, size_t >::type getByteSize (const T &obj)
 
template<typename T >
std::enable_if< std::is_pointer< T >::value >::type serialize (const T &obj, std::vector< char > &buffer, std::vector< char >::iterator &iter)
 
template<typename T >
std::enable_if< std::is_pointer< T >::value >::type deserialize (T &obj, std::vector< char >::const_iterator &iter)
 
template<typename T >
std::enable_if< serialization::is_smart_ptr< T >::value, size_t >::type getByteSize (const T &obj)
 
template<typename T >
std::enable_if< serialization::is_smart_ptr< T >::value >::type serialize (const T &obj, std::vector< char > &buffer, std::vector< char >::iterator &iter)
 
template<template< typename > class T0, typename T1 >
std::enable_if< serialization::is_smart_ptr< T0< T1 > >::value >::type deserialize (T0< T1 > &obj, std::vector< char >::const_iterator &iter)
 
template<typename T >
size_t getByteSize (const std::weak_ptr< T > &obj)
 
template<typename T >
void serialize (const std::weak_ptr< T > &obj, std::vector< char > &buffer, std::vector< char >::iterator &iter)
 
template<typename T >
void deserialize (std::weak_ptr< T > &obj, std::vector< char >::const_iterator &iter)
 
template<typename T >
void serialize (const T &obj, std::vector< char > &buffer)
 
template<typename T >
void deserialize (T &obj, const std::vector< char > &buffer)
 
template<typename T >
void updateMemoryMap (T &obj, size_t size)
 
template<typename T >
void updateMemoryMap (T &obj, size_t size, std::map< std::uintptr_t, IndexedPointerBase * > &memoryMap)
 

Function Documentation

◆ serialization() [1/2]

void igl::serialization::serialization ( bool  s,
igl::opengl::ViewerCore &  obj,
std::vector< char > &  buffer 
)
inline

◆ serialize() [1/20]

template<>
void igl::serialization::serialize ( const igl::opengl::ViewerCore &  obj,
std::vector< char > &  buffer 
)
inline

◆ deserialize() [1/21]

template<>
void igl::serialization::deserialize ( igl::opengl::ViewerCore &  obj,
const std::vector< char > &  buffer 
)
inline

◆ serialization() [2/2]

void igl::serialization::serialization ( bool  s,
igl::opengl::ViewerData &  obj,
std::vector< char > &  buffer 
)
inline

◆ serialize() [2/20]

template<>
void igl::serialization::serialize ( const igl::opengl::ViewerData &  obj,
std::vector< char > &  buffer 
)
inline

◆ deserialize() [2/21]

template<>
void igl::serialization::deserialize ( igl::opengl::ViewerData &  obj,
const std::vector< char > &  buffer 
)
inline

◆ getByteSize() [1/17]

template<typename T >
std::enable_if<!is_serializable< T >::value, size_t >::type igl::serialization::getByteSize ( const T &  obj)
inline

◆ serialize() [3/20]

template<typename T >
std::enable_if<!is_serializable< T >::value >::type igl::serialization::serialize ( const T &  obj,
std::vector< char > &  buffer,
std::vector< char >::iterator &  iter 
)
inline

◆ deserialize() [3/21]

template<typename T >
std::enable_if<!is_serializable< T >::value >::type igl::serialization::deserialize ( T &  obj,
std::vector< char >::const_iterator &  iter 
)
inline

◆ getByteSize() [2/17]

template<typename T >
std::enable_if< std::is_fundamental< T >::value, size_t >::type igl::serialization::getByteSize ( const T &  obj)
inline

◆ serialize() [4/20]

template<typename T >
std::enable_if< std::is_fundamental< T >::value >::type igl::serialization::serialize ( const T &  obj,
std::vector< char > &  buffer,
std::vector< char >::iterator &  iter 
)
inline

◆ deserialize() [4/21]

template<typename T >
std::enable_if< std::is_fundamental< T >::value >::type igl::serialization::deserialize ( T &  obj,
std::vector< char >::const_iterator &  iter 
)
inline

◆ getByteSize() [3/17]

size_t igl::serialization::getByteSize ( const std::string &  obj)
inline

◆ serialize() [5/20]

void igl::serialization::serialize ( const std::string &  obj,
std::vector< char > &  buffer,
std::vector< char >::iterator &  iter 
)
inline

◆ deserialize() [5/21]

void igl::serialization::deserialize ( std::string &  obj,
std::vector< char >::const_iterator &  iter 
)
inline

◆ getByteSize() [4/17]

template<typename T >
std::enable_if< std::is_enum< T >::value, size_t >::type igl::serialization::getByteSize ( const T &  obj)
inline

◆ serialize() [6/20]

template<typename T >
std::enable_if< std::is_enum< T >::value >::type igl::serialization::serialize ( const T &  obj,
std::vector< char > &  buffer,
std::vector< char >::iterator &  iter 
)
inline

◆ deserialize() [6/21]

template<typename T >
std::enable_if< std::is_enum< T >::value >::type igl::serialization::deserialize ( T &  obj,
std::vector< char >::const_iterator &  iter 
)
inline

◆ getByteSize() [5/17]

template<typename T >
std::enable_if< std::is_base_of< SerializableBase, T >::value, size_t >::type igl::serialization::getByteSize ( const T &  obj)
inline

◆ serialize() [7/20]

template<typename T >
std::enable_if< std::is_base_of< SerializableBase, T >::value >::type igl::serialization::serialize ( const T &  obj,
std::vector< char > &  buffer,
std::vector< char >::iterator &  iter 
)
inline

◆ deserialize() [7/21]

template<typename T >
std::enable_if< std::is_base_of< SerializableBase, T >::value >::type igl::serialization::deserialize ( T &  obj,
std::vector< char >::const_iterator &  iter 
)
inline

◆ getByteSize() [6/17]

template<typename T1 , typename T2 >
size_t igl::serialization::getByteSize ( const std::pair< T1, T2 > &  obj)
inline

◆ serialize() [8/20]

template<typename T1 , typename T2 >
void igl::serialization::serialize ( const std::pair< T1, T2 > &  obj,
std::vector< char > &  buffer,
std::vector< char >::iterator &  iter 
)
inline

◆ deserialize() [8/21]

template<typename T1 , typename T2 >
void igl::serialization::deserialize ( std::pair< T1, T2 > &  obj,
std::vector< char >::const_iterator &  iter 
)
inline

◆ getByteSize() [7/17]

template<typename T1 , typename T2 >
size_t igl::serialization::getByteSize ( const std::vector< T1, T2 > &  obj)
inline

◆ serialize() [9/20]

template<typename T1 , typename T2 >
void igl::serialization::serialize ( const std::vector< T1, T2 > &  obj,
std::vector< char > &  buffer,
std::vector< char >::iterator &  iter 
)
inline

◆ deserialize() [9/21]

template<typename T1 , typename T2 >
void igl::serialization::deserialize ( std::vector< T1, T2 > &  obj,
std::vector< char >::const_iterator &  iter 
)
inline

◆ deserialize() [10/21]

template<typename T2 >
void igl::serialization::deserialize ( std::vector< bool, T2 > &  obj,
std::vector< char >::const_iterator &  iter 
)
inline

◆ getByteSize() [8/17]

template<typename T >
size_t igl::serialization::getByteSize ( const std::set< T > &  obj)
inline

◆ serialize() [10/20]

template<typename T >
void igl::serialization::serialize ( const std::set< T > &  obj,
std::vector< char > &  buffer,
std::vector< char >::iterator &  iter 
)
inline

◆ deserialize() [11/21]

template<typename T >
void igl::serialization::deserialize ( std::set< T > &  obj,
std::vector< char >::const_iterator &  iter 
)
inline

◆ getByteSize() [9/17]

template<typename T1 , typename T2 >
size_t igl::serialization::getByteSize ( const std::map< T1, T2 > &  obj)
inline

◆ serialize() [11/20]

template<typename T1 , typename T2 >
void igl::serialization::serialize ( const std::map< T1, T2 > &  obj,
std::vector< char > &  buffer,
std::vector< char >::iterator &  iter 
)
inline

◆ deserialize() [12/21]

template<typename T1 , typename T2 >
void igl::serialization::deserialize ( std::map< T1, T2 > &  obj,
std::vector< char >::const_iterator &  iter 
)
inline

◆ getByteSize() [10/17]

template<typename T >
size_t igl::serialization::getByteSize ( const std::list< T > &  obj)
inline

◆ serialize() [12/20]

template<typename T >
void igl::serialization::serialize ( const std::list< T > &  obj,
std::vector< char > &  buffer,
std::vector< char >::iterator &  iter 
)
inline

◆ deserialize() [13/21]

template<typename T >
void igl::serialization::deserialize ( std::list< T > &  obj,
std::vector< char >::const_iterator &  iter 
)
inline

◆ getByteSize() [11/17]

template<typename T , int R, int C, int P, int MR, int MC>
size_t igl::serialization::getByteSize ( const Eigen::Matrix< T, R, C, P, MR, MC > &  obj)
inline

◆ serialize() [13/20]

template<typename T , int R, int C, int P, int MR, int MC>
void igl::serialization::serialize ( const Eigen::Matrix< T, R, C, P, MR, MC > &  obj,
std::vector< char > &  buffer,
std::vector< char >::iterator &  iter 
)
inline

◆ deserialize() [14/21]

template<typename T , int R, int C, int P, int MR, int MC>
void igl::serialization::deserialize ( Eigen::Matrix< T, R, C, P, MR, MC > &  obj,
std::vector< char >::const_iterator &  iter 
)
inline

◆ getByteSize() [12/17]

template<typename T , int R, int C, int P, int MR, int MC>
size_t igl::serialization::getByteSize ( const Eigen::Array< T, R, C, P, MR, MC > &  obj)
inline

◆ serialize() [14/20]

template<typename T , int R, int C, int P, int MR, int MC>
void igl::serialization::serialize ( const Eigen::Array< T, R, C, P, MR, MC > &  obj,
std::vector< char > &  buffer,
std::vector< char >::iterator &  iter 
)
inline

◆ deserialize() [15/21]

template<typename T , int R, int C, int P, int MR, int MC>
void igl::serialization::deserialize ( Eigen::Array< T, R, C, P, MR, MC > &  obj,
std::vector< char >::const_iterator &  iter 
)
inline

◆ getByteSize() [13/17]

template<typename T , int P, typename I >
size_t igl::serialization::getByteSize ( const Eigen::SparseMatrix< T, P, I > &  obj)
inline

◆ serialize() [15/20]

template<typename T , int P, typename I >
void igl::serialization::serialize ( const Eigen::SparseMatrix< T, P, I > &  obj,
std::vector< char > &  buffer,
std::vector< char >::iterator &  iter 
)
inline

◆ deserialize() [16/21]

template<typename T , int P, typename I >
void igl::serialization::deserialize ( Eigen::SparseMatrix< T, P, I > &  obj,
std::vector< char >::const_iterator &  iter 
)
inline

◆ getByteSize() [14/17]

template<typename T , int P>
size_t igl::serialization::getByteSize ( const Eigen::Quaternion< T, P > &  obj)
inline

◆ serialize() [16/20]

template<typename T , int P>
void igl::serialization::serialize ( const Eigen::Quaternion< T, P > &  obj,
std::vector< char > &  buffer,
std::vector< char >::iterator &  iter 
)
inline

◆ deserialize() [17/21]

template<typename T , int P>
void igl::serialization::deserialize ( Eigen::Quaternion< T, P > &  obj,
std::vector< char >::const_iterator &  iter 
)
inline

◆ getByteSize() [15/17]

template<typename T >
std::enable_if< std::is_pointer< T >::value, size_t >::type igl::serialization::getByteSize ( const T &  obj)
inline

◆ serialize() [17/20]

template<typename T >
std::enable_if< std::is_pointer< T >::value >::type igl::serialization::serialize ( const T &  obj,
std::vector< char > &  buffer,
std::vector< char >::iterator &  iter 
)
inline

◆ deserialize() [18/21]

template<typename T >
std::enable_if< std::is_pointer< T >::value >::type igl::serialization::deserialize ( T &  obj,
std::vector< char >::const_iterator &  iter 
)
inline

◆ getByteSize() [16/17]

template<typename T >
std::enable_if< serialization::is_smart_ptr< T >::value, size_t >::type igl::serialization::getByteSize ( const T &  obj)
inline

◆ serialize() [18/20]

template<typename T >
std::enable_if< serialization::is_smart_ptr< T >::value >::type igl::serialization::serialize ( const T &  obj,
std::vector< char > &  buffer,
std::vector< char >::iterator &  iter 
)
inline

◆ deserialize() [19/21]

template<template< typename > class T0, typename T1 >
std::enable_if< serialization::is_smart_ptr< T0< T1 > >::value >::type igl::serialization::deserialize ( T0< T1 > &  obj,
std::vector< char >::const_iterator &  iter 
)
inline

◆ getByteSize() [17/17]

template<typename T >
size_t igl::serialization::getByteSize ( const std::weak_ptr< T > &  obj)
inline

◆ serialize() [19/20]

template<typename T >
void igl::serialization::serialize ( const std::weak_ptr< T > &  obj,
std::vector< char > &  buffer,
std::vector< char >::iterator &  iter 
)
inline

◆ deserialize() [20/21]

template<typename T >
void igl::serialization::deserialize ( std::weak_ptr< T > &  obj,
std::vector< char >::const_iterator &  iter 
)
inline

◆ serialize() [20/20]

template<typename T >
void igl::serialization::serialize ( const T &  obj,
std::vector< char > &  buffer 
)
inline

◆ deserialize() [21/21]

template<typename T >
void igl::serialization::deserialize ( T &  obj,
const std::vector< char > &  buffer 
)
inline

◆ updateMemoryMap() [1/2]

template<typename T >
void igl::serialization::updateMemoryMap ( T &  obj,
size_t  size 
)
inline

◆ updateMemoryMap() [2/2]

template<typename T >
void igl::serialization::updateMemoryMap ( T &  obj,
size_t  size,
std::map< std::uintptr_t, IndexedPointerBase * > &  memoryMap 
)
inline