igl::serialization Namespace Reference

Classes
struct	is_eigen_type
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 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

deserialize() [1/20]

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

    {
      typename Eigen::Matrix<T,R,C,P,MR,MC>::Index rows,cols;
      serialization::deserialize(rows,iter);
      serialization::deserialize(cols,iter);
      size_t size = sizeof(T)*rows*cols;
      obj.resize(rows,cols);
      auto ptr = reinterpret_cast<uint8_t*>(obj.data());
      std::copy(iter,iter+size,ptr);
      iter+=size;
    }

References Eigen::PlainObjectBase< Derived >::data(), deserialize(), and Eigen::PlainObjectBase< Derived >::resize().

Here is the call graph for this function:

deserialize() [2/20]

template<typename T , int P>

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

inline

    {
      serialization::deserialize(obj.w(),iter);
      serialization::deserialize(obj.x(),iter);
      serialization::deserialize(obj.y(),iter);
      serialization::deserialize(obj.z(),iter);
    }

References deserialize(), Eigen::QuaternionBase< Derived >::w(), Eigen::QuaternionBase< Derived >::x(), Eigen::QuaternionBase< Derived >::y(), and Eigen::QuaternionBase< Derived >::z().

Here is the call graph for this function:

deserialize() [3/20]

template<typename T , int P, typename I >

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

inline

    {
      typename Eigen::SparseMatrix<T,P,I>::Index rows,cols,nonZeros;
      serialization::deserialize(rows,iter);
      serialization::deserialize(cols,iter);
      serialization::deserialize(nonZeros,iter);
 
      obj.resize(rows,cols);
      obj.setZero();
 
      std::vector<Eigen::Triplet<T,I> > triplets;
      for(int i=0;i<nonZeros;i++)
      {
        typename Eigen::SparseMatrix<T,P,I>::Index rowId,colId;
        serialization::deserialize(rowId,iter);
        serialization::deserialize(colId,iter);
        T value;
        serialization::deserialize(value,iter);
        triplets.push_back(Eigen::Triplet<T,I>(rowId,colId,value));
      }
      obj.setFromTriplets(triplets.begin(),triplets.end());
    }

References deserialize(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::resize(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::setFromTriplets(), and Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::setZero().

Here is the call graph for this function:

deserialize() [4/20]

template<>

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

inline

    {
      serialization(false, obj, const_cast<std::vector<char>&>(buffer));
    }

References serialization().

Referenced by deserialize(), deserialize(), deserialize(), deserialize(), deserialize(), deserialize(), deserialize(), deserialize(), deserialize(), deserialize(), igl::deserialize(), deserialize(), and deserialize().

Here is the call graph for this function:

Here is the caller graph for this function:

deserialize() [5/20]

template<>

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

inline

    {
      serialization(false, obj, const_cast<std::vector<char>&>(buffer));
      obj.dirty = igl::opengl::MeshGL::DIRTY_ALL;
    }

References igl::opengl::ViewerData::dirty, igl::opengl::MeshGL::DIRTY_ALL, and serialization().

Here is the call graph for this function:

deserialize() [6/20]

template<typename T >

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

inline

    {
        size_t size;
        serialization::deserialize(size, iter);
 
        obj.clear();
        for (size_t i = 0; i < size; ++i)
        {
            T val;
            serialization::deserialize(val, iter);
            obj.emplace_back(val);
        }
    }

References deserialize().

Here is the call graph for this function:

deserialize() [7/20]

template<typename T1 , typename T2 >

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

inline

    {
      size_t size;
      serialization::deserialize(size,iter);
 
      obj.clear();
      for(size_t i=0; i<size; ++i)
      {
        std::pair<T1,T2> pair;
        serialization::deserialize(pair,iter);
        obj.insert(pair);
      }
    }

References deserialize().

Here is the call graph for this function:

deserialize() [8/20]

template<typename T1 , typename T2 >

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

inline

    {
      serialization::deserialize(obj.first,iter);
      serialization::deserialize(obj.second,iter);
    }

References deserialize().

Here is the call graph for this function:

deserialize() [9/20]

template<typename T >

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

inline

    {
      size_t size;
      serialization::deserialize(size,iter);
 
      obj.clear();
      for(size_t i=0; i<size; ++i)
      {
        T val;
        serialization::deserialize(val,iter);
        obj.insert(val);
      }
    }

References deserialize().

Here is the call graph for this function:

deserialize() [10/20]

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

inline

    {
      size_t size;
      serialization::deserialize(size,iter);
 
      std::string str(size,'\0');
      for(size_t i=0; i<size; ++i)
      {
        serialization::deserialize(str.at(i),iter);
      }
 
      obj = str;
    }

References deserialize().

Here is the call graph for this function:

deserialize() [11/20]

template<typename T2 >

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

inline

    {
      size_t size;
      serialization::deserialize(size,iter);
 
      obj.resize(size);
      for(int i=0;i<obj.size();i++)
      {
        bool val;
        serialization::deserialize(val,iter);
        obj[i] = val;
      }
    }

References deserialize().

Here is the call graph for this function:

deserialize() [12/20]

template<typename T1 , typename T2 >

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

inline

    {
      size_t size;
      serialization::deserialize(size,iter);
 
      obj.resize(size);
      for(T1& v : obj)
      {
        serialization::deserialize(v,iter);
      }
    }

References deserialize().

Here is the call graph for this function:

deserialize() [13/20]

template<typename T >

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

inline

    {
 
    }

deserialize() [14/20]

template<typename T >

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

inline

    {
      std::cerr << typeid(obj).name() << " is not deserializable: derive from igl::Serializable or spezialize the template function igl::serialization::deserialize(T& obj, const std::vector<char>& buffer)" << std::endl;
    }

deserialize() [15/20]

template<typename T >

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

inline

    {
      std::vector<char>::size_type size;
      serialization::deserialize<>(size,iter);
 
      std::vector<char> tmp;
      tmp.resize(size);
      std::copy(iter,iter+size,tmp.begin());
 
      deserialize<>(obj,tmp);
      iter += size;
    }

deserialize() [16/20]

template<typename T >

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

inline

    {
      uint8_t* ptr = reinterpret_cast<uint8_t*>(&obj);
      std::copy(iter,iter+sizeof(T),ptr);
      iter += sizeof(T);
    }

deserialize() [17/20]

template<typename T >

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

inline

    {
      uint8_t* ptr = reinterpret_cast<uint8_t*>(&obj);
      std::copy(iter,iter+sizeof(T),ptr);
      iter += sizeof(T);
    }

deserialize() [18/20]

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

    {
      std::vector<char>::size_type size;
      serialization::deserialize(size,iter);
 
      std::vector<char> tmp;
      tmp.resize(size);
      std::copy(iter,iter+size,tmp.begin());
 
      obj.Deserialize(tmp);
      iter += size;
    }

References deserialize().

Here is the call graph for this function:

deserialize() [19/20]

template<typename T >

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

inline

    {
      bool isNullPtr;
      serialization::deserialize(isNullPtr,iter);
 
      if(isNullPtr)
      {
        if(obj)
        {
          std::cout << "serialization: possible memory leak in serialization for '" << typeid(obj).name() << "'" << std::endl;
          obj = nullptr;
        }
      }
      else
      {
        if(obj)
        {
          std::cout << "serialization: possible memory corruption in deserialization for '" << typeid(obj).name() << "'" << std::endl;
        }
        else
        {
          obj = new typename std::remove_pointer<T>::type();
        }
        serialization::deserialize(*obj,iter);
      }
    }

References deserialize().

Here is the call graph for this function:

deserialize() [20/20]

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

    {
      bool isNullPtr;
      serialization::deserialize(isNullPtr,iter);
 
      if(isNullPtr)
      {
        obj.reset();
      }
      else
      {
        obj = T0<T1>(new T1());
        serialization::deserialize(*obj,iter);
      }
    }

References deserialize().

Here is the call graph for this function:

getByteSize() [1/16]

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

    {
      // space for numbers of rows,cols and data
      return 2*sizeof(typename Eigen::Matrix<T,R,C,P,MR,MC>::Index)+sizeof(T)*obj.rows()*obj.cols();
    }

References Eigen::PlainObjectBase< Derived >::cols(), and Eigen::PlainObjectBase< Derived >::rows().

Here is the call graph for this function:

getByteSize() [2/16]

template<typename T , int P>

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

inline

    {
      return sizeof(T)*4;
    }

getByteSize() [3/16]

template<typename T , int P, typename I >

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

inline

    {
      // space for numbers of rows,cols,nonZeros and tripplets with data (rowIdx,colIdx,value)
      size_t size = sizeof(typename Eigen::SparseMatrix<T,P,I>::Index);
      return 3*size+(sizeof(T)+2*size)*obj.nonZeros();
    }

References Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::nonZeros().

Here is the call graph for this function:

getByteSize() [4/16]

template<typename T >

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

inline

    {
        return std::accumulate(obj.begin(), obj.end(), getByteSize(obj.size()), [](const size_t& acc, const T& cur) { return acc + getByteSize(cur); });
    }

References getByteSize().

Here is the call graph for this function:

getByteSize() [5/16]

template<typename T1 , typename T2 >

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

inline

    {
      return std::accumulate(obj.begin(),obj.end(),sizeof(size_t),[](const size_t& acc,const std::pair<T1,T2>& cur) { return acc+getByteSize(cur); });
    }

getByteSize() [6/16]

template<typename T1 , typename T2 >

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

inline

    {
      return getByteSize(obj.first)+getByteSize(obj.second);
    }

References getByteSize().

Here is the call graph for this function:

getByteSize() [7/16]

template<typename T >

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

inline

    {
      return std::accumulate(obj.begin(),obj.end(),getByteSize(obj.size()),[](const size_t& acc,const T& cur) { return acc+getByteSize(cur); });
    }

References getByteSize().

Here is the call graph for this function:

getByteSize() [8/16]

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

inline

    {
      return getByteSize(obj.length())+obj.length()*sizeof(uint8_t);
    }

References getByteSize().

Here is the call graph for this function:

getByteSize() [9/16]

template<typename T1 , typename T2 >

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

inline

    {
      return std::accumulate(obj.begin(),obj.end(),sizeof(size_t),[](const size_t& acc,const T1& cur) { return acc+getByteSize(cur); });
    }

getByteSize() [10/16]

template<typename T >

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

inline

    {
      return sizeof(size_t);
    }

getByteSize() [11/16]

template<typename T >

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

inline

    {
      return sizeof(std::vector<char>::size_type);
    }

Referenced by getByteSize(), getByteSize(), getByteSize(), getByteSize(), getByteSize(), and igl::serialize().

Here is the caller graph for this function:

getByteSize() [12/16]

template<typename T >

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

inline

    {
      return sizeof(T);
    }

getByteSize() [13/16]

template<typename T >

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

inline

    {
      return sizeof(T);
    }

getByteSize() [14/16]

template<typename T >

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

inline

    {
      return sizeof(std::vector<char>::size_type);
    }

getByteSize() [15/16]

template<typename T >

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

inline

    {
      size_t size = sizeof(bool);
 
      if(obj)
        size += getByteSize(*obj);
 
      return size;
    }

References getByteSize().

Here is the call graph for this function:

getByteSize() [16/16]

template<typename T >

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

inline

    {
      return getByteSize(obj.get());
    }

References getByteSize().

Here is the call graph for this function:

serialization() [1/2]

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

inline

    {
 
      SERIALIZE_MEMBER(background_color);
 
      SERIALIZE_MEMBER(light_position);
      SERIALIZE_MEMBER(lighting_factor);
 
      SERIALIZE_MEMBER(trackball_angle);
      SERIALIZE_MEMBER(rotation_type);
 
      SERIALIZE_MEMBER(camera_base_zoom);
      SERIALIZE_MEMBER(camera_zoom);
      SERIALIZE_MEMBER(orthographic);
      SERIALIZE_MEMBER(camera_base_translation);
      SERIALIZE_MEMBER(camera_translation);
      SERIALIZE_MEMBER(camera_view_angle);
      SERIALIZE_MEMBER(camera_dnear);
      SERIALIZE_MEMBER(camera_dfar);
      SERIALIZE_MEMBER(camera_eye);
      SERIALIZE_MEMBER(camera_center);
      SERIALIZE_MEMBER(camera_up);
 
      SERIALIZE_MEMBER(depth_test);
      SERIALIZE_MEMBER(is_animating);
      SERIALIZE_MEMBER(animation_max_fps);
 
      SERIALIZE_MEMBER(object_scale);
 
      SERIALIZE_MEMBER(viewport);
      SERIALIZE_MEMBER(view);
      SERIALIZE_MEMBER(proj);
      SERIALIZE_MEMBER(norm);
    }

References serialization(), and SERIALIZE_MEMBER.

Referenced by deserialize(), deserialize(), serialization(), serialization(), serialize(), and serialize().

Here is the call graph for this function:

Here is the caller graph for this function:

serialization() [2/2]

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

inline

    {
      SERIALIZE_MEMBER(V);
      SERIALIZE_MEMBER(F);
      SERIALIZE_MEMBER(F_normals);
      SERIALIZE_MEMBER(F_material_ambient);
      SERIALIZE_MEMBER(F_material_diffuse);
      SERIALIZE_MEMBER(F_material_specular);
      SERIALIZE_MEMBER(V_normals);
      SERIALIZE_MEMBER(V_material_ambient);
      SERIALIZE_MEMBER(V_material_diffuse);
      SERIALIZE_MEMBER(V_material_specular);
      SERIALIZE_MEMBER(V_uv);
      SERIALIZE_MEMBER(F_uv);
      SERIALIZE_MEMBER(texture_R);
      SERIALIZE_MEMBER(texture_G);
      SERIALIZE_MEMBER(texture_B);
      SERIALIZE_MEMBER(texture_A);
      SERIALIZE_MEMBER(lines);
      SERIALIZE_MEMBER(points);
      SERIALIZE_MEMBER(labels_positions);
      SERIALIZE_MEMBER(labels_strings);
      SERIALIZE_MEMBER(dirty);
      SERIALIZE_MEMBER(face_based);
      SERIALIZE_MEMBER(show_faces);
      SERIALIZE_MEMBER(show_lines);
      SERIALIZE_MEMBER(invert_normals);
      SERIALIZE_MEMBER(show_overlay);
      SERIALIZE_MEMBER(show_overlay_depth);
      SERIALIZE_MEMBER(show_vertid);
      SERIALIZE_MEMBER(show_faceid);
      SERIALIZE_MEMBER(show_texture);
      SERIALIZE_MEMBER(point_size);
      SERIALIZE_MEMBER(line_width);
      SERIALIZE_MEMBER(line_color);
      SERIALIZE_MEMBER(shininess);
      SERIALIZE_MEMBER(id);
    }

References serialization(), and SERIALIZE_MEMBER.

Here is the call graph for this function:

serialize() [1/19]

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

    {
      serialization::serialize(obj.rows(),buffer,iter);
      serialization::serialize(obj.cols(),buffer,iter);
      size_t size = sizeof(T)*obj.rows()*obj.cols();
      auto ptr = reinterpret_cast<const uint8_t*>(obj.data());
      iter = std::copy(ptr,ptr+size,iter);
    }

References Eigen::PlainObjectBase< Derived >::cols(), Eigen::PlainObjectBase< Derived >::data(), Eigen::PlainObjectBase< Derived >::rows(), and serialize().

Here is the call graph for this function:

serialize() [2/19]

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

    {
      serialization::serialize(obj.w(),buffer,iter);
      serialization::serialize(obj.x(),buffer,iter);
      serialization::serialize(obj.y(),buffer,iter);
      serialization::serialize(obj.z(),buffer,iter);
    }

References serialize(), Eigen::QuaternionBase< Derived >::w(), Eigen::QuaternionBase< Derived >::x(), Eigen::QuaternionBase< Derived >::y(), and Eigen::QuaternionBase< Derived >::z().

Here is the call graph for this function:

serialize() [3/19]

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

    {
      serialization::serialize(obj.rows(),buffer,iter);
      serialization::serialize(obj.cols(),buffer,iter);
      serialization::serialize(obj.nonZeros(),buffer,iter);
 
      for(int k=0;k<obj.outerSize();++k)
      {
        for(typename Eigen::SparseMatrix<T,P,I>::InnerIterator it(obj,k);it;++it)
        {
          serialization::serialize(it.row(),buffer,iter);
          serialization::serialize(it.col(),buffer,iter);
          serialization::serialize(it.value(),buffer,iter);
        }
      }
    }

References Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::cols(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::nonZeros(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::outerSize(), Eigen::SparseMatrix< _Scalar, _Options, _StorageIndex >::rows(), and serialize().

Here is the call graph for this function:

serialize() [4/19]

template<>

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

inline

    {
      serialization(true, const_cast<igl::opengl::ViewerCore&>(obj), buffer);
    }

References serialization().

Referenced by serialize(), serialize(), serialize(), serialize(), serialize(), serialize(), serialize(), serialize(), serialize(), igl::serialize(), and serialize().

Here is the call graph for this function:

Here is the caller graph for this function:

serialize() [5/19]

template<>

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

inline

    {
      serialization(true, const_cast<igl::opengl::ViewerData&>(obj), buffer);
    }

References serialization().

Here is the call graph for this function:

serialize() [6/19]

template<typename T >

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

inline

    {
        serialization::serialize(obj.size(), buffer, iter);
        for (const T& cur : obj)
        {
            serialization::serialize(cur, buffer, iter);
        }
    }

References serialize().

Here is the call graph for this function:

serialize() [7/19]

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

    {
      serialization::serialize(obj.size(),buffer,iter);
      for(const auto& cur : obj)
      {
        serialization::serialize(cur,buffer,iter);
      }
    }

References serialize().

Here is the call graph for this function:

serialize() [8/19]

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

    {
      serialization::serialize(obj.first,buffer,iter);
      serialization::serialize(obj.second,buffer,iter);
    }

References serialize().

Here is the call graph for this function:

serialize() [9/19]

template<typename T >

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

inline

    {
      serialization::serialize(obj.size(),buffer,iter);
      for(const T& cur : obj)
      {
        serialization::serialize(cur,buffer,iter);
      }
    }

References serialize().

Here is the call graph for this function:

serialize() [10/19]

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

inline

    {
      serialization::serialize(obj.length(),buffer,iter);
      for(const auto& cur : obj)
      {
        serialization::serialize(cur,buffer,iter);
      }
    }

References serialize().

Here is the call graph for this function:

serialize() [11/19]

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

    {
      size_t size = obj.size();
      serialization::serialize(size,buffer,iter);
      for(const T1& cur : obj)
      {
        serialization::serialize(cur,buffer,iter);
      }
    }

References serialize().

Here is the call graph for this function:

serialize() [12/19]

template<typename T >

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

inline

    {
 
    }

serialize() [13/19]

template<typename T >

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

inline

    {
      std::cerr << typeid(obj).name() << " is not serializable: derive from igl::Serializable or spezialize the template function igl::serialization::serialize(const T& obj,std::vector<char>& buffer)" << std::endl;
    }

serialize() [14/19]

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

    {
      // data
      std::vector<char> tmp;
      serialize<>(obj,tmp);
 
      // size
      size_t size = buffer.size();
      serialization::serialize(tmp.size(),buffer,iter);
      size_t cur = iter - buffer.begin();
 
      buffer.resize(size+tmp.size());
      iter = buffer.begin()+cur;
      iter = std::copy(tmp.begin(),tmp.end(),iter);
    }

References serialize().

Here is the call graph for this function:

serialize() [15/19]

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

    {
      //serialization::updateMemoryMap(obj,sizeof(T));
      const uint8_t* ptr = reinterpret_cast<const uint8_t*>(&obj);
      iter = std::copy(ptr,ptr+sizeof(T),iter);
    }

serialize() [16/19]

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

    {
      const uint8_t* ptr = reinterpret_cast<const uint8_t*>(&obj);
      iter = std::copy(ptr,ptr+sizeof(T),iter);
    }

serialize() [17/19]

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

    {
      // data
      std::vector<char> tmp;
      obj.Serialize(tmp);
 
      // size
      size_t size = buffer.size();
      serialization::serialize(tmp.size(),buffer,iter);
      size_t cur = iter - buffer.begin();
 
      buffer.resize(size+tmp.size());
      iter = buffer.begin()+cur;
      iter = std::copy(tmp.begin(),tmp.end(),iter);
    }

References serialize().

Here is the call graph for this function:

serialize() [18/19]

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

    {
      serialization::serialize(obj == nullptr,buffer,iter);
 
      if(obj)
        serialization::serialize(*obj,buffer,iter);
    }

References serialize().

Here is the call graph for this function:

serialize() [19/19]

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

    {
      serialize(obj.get(),buffer,iter);
    }

References serialize().

Here is the call graph for this function:

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

    {
      // check if object is already serialized
      auto startPtr = new IndexedPointer<T>();
      startPtr->Object = &obj;
      auto startBasePtr = static_cast<IndexedPointerBase*>(startPtr);
      startBasePtr->Type = IndexedPointerBase::BEGIN;
      auto startAddress = reinterpret_cast<std::uintptr_t>(&obj);
      auto p = std::pair<std::uintptr_t,IndexedPointerBase*>(startAddress,startBasePtr);
 
      auto el = memoryMap.insert(p);
      auto iter = ++el.first; // next elememt
      if(el.second && (iter == memoryMap.end() || iter->second->Type != IndexedPointerBase::END))
      {
        // not yet serialized
        auto endPtr = new IndexedPointer<T>();
        auto endBasePtr = static_cast<IndexedPointerBase*>(endPtr);
        endBasePtr->Type = IndexedPointerBase::END;
        auto endAddress = reinterpret_cast<std::uintptr_t>(&obj) + size - 1;
        auto p = std::pair<std::uintptr_t,IndexedPointerBase*>(endAddress,endBasePtr);
 
        // insert end address
        memoryMap.insert(el.first,p);
      }
      else
      {
        // already serialized
 
        // remove inserted address
        memoryMap.erase(el.first);
      }
    }

References igl::IndexedPointerBase::BEGIN, igl::IndexedPointerBase::END, and igl::IndexedPointerBase::Type.