Sauvegarde d'une struct complexe vers fichier possible ?

Struct Particle{
	ScanMatcherMap map;
	OrientedPoint pose;
	double weight;
	double weightSum;
	double gweight;
	int previousIndex;
	TNode* node;
}; 

typedef Map<PointAccumulator, HierarchicalArray2D<PointAccumulator>> ScanMatcherMap;
template <class Cell, class Storage, const bool isClass=true> class Map{
		Point m_center;
		double m_worldSizeX, m_worldSizeY, m_delta;
		Storage m_storage;
		int m_mapSizeX, m_mapSizeY;
		int m_sizeX2, m_sizeY2;
		static const Cell m_unknown;
};

struct PointAccumulator{
		typedef point<float> FloatPoint;
		
	PointAccumulator(): acc(0,0), n(0), visits(0){}
	PointAccumulator(int i): acc(0,0), n(0), visits(0){assert(i==-1);}
	
	static PointAccumulator* unknown_ptr;
	FloatPoint acc;
	int n, visits;
};

template <class Cell> class HierarchicalArray2D: public Array2D<autoptr< Array2D<Cell> > >{
	
		typedef std::set< point<int>, pointcomparator<int> > PointSet;
		HierarchicalArray2D(int xsize, int ysize, int patchMagnitude=5);
				
		PointSet m_activeArea;
		int m_patchMagnitude;
		int m_patchSize;
};

template<class Cell, const bool debug=false> class Array2D{
		Cell ** m_cells;
		int m_xsize, m_ysize;
};

template <class X> class autoptr{
	struct reference{
		X* data;
		unsigned int shares;
	};
		reference * m_reference;
};


struct TNode{
      /**Constructs a node of the trajectory tree.
       @param pose:      the pose of the robot in the trajectory
       @param weight:    the weight of the particle at that point in the trajectory
       @param accWeight: the cumulative weight of the particle
       @param parent:    the parent node in the tree
       @param childs:    the number of childs
      */
      TNode(const OrientedPoint& pose, double weight, TNode* parent=0, unsigned int childs=0);

      OrientedPoint pose; 
      double weight;
      double accWeight;
      double gweight;
      TNode* parent;
      const RangeReading* reading;
      unsigned int childs;
      mutable unsigned int visitCounter;
      mutable bool flag;
    };

class RangeReading: public SensorReading, public std::vector<double>{
		std::vector<Point> cartesianForm(double maxRange=1e6) const;
		unsigned int activeBeams(double density=0.) const;
		OrientedPoint m_pose;
};

#include <iostream>
#include <iterator>
#include <algorithm>

#include <sstream>
#include <fstream>

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/split_free.hpp>

using namespace std;
using namespace boost::archive;
using namespace boost::serialization;

/*
 * point
 *
 */
template <class T> struct point{
	inline point():x(0),y(0) {}
	inline point(T _x, T _y):x(_x),y(_y){}
	T x, y;
	friend class boost::serialization::access;
	template <class Archive> 
	void serialize(Archive& ar, const unsigned int version){
		ar & x & y;
	}
};

/*
 * PointAccumulator
 *
 */
struct PointAccumulator{
	typedef point<float> FloatPoint;
	
	PointAccumulator(): acc(0,0), n(0), visits(0){}
	PointAccumulator(int i): acc(0,0), n(0), visits(0){assert(i==-1);}
	//PointAccumulator& operator=(const PointAccumulator & pa);


	static PointAccumulator* unknown_ptr;
	FloatPoint acc;
	int n, visits;
	
	friend class boost::serialization::access; 
	template <class Archive> void serialize(Archive& ar, const unsigned int version){
		ar & n & visits & acc;
	}
};
/*
PointAccumulator& PointAccumulator::operator=(const PointAccumulator &pa){
	acc = point<float>(pa.acc.x,pa.acc.y);
	n = pa.n;
	visits = pa.visits; 
	cout << "copied pa " << acc.x << endl;
	return *this;
}
*/
/*
 * Array2D
 *
 */
template<class Cell, const bool debug=false> class Array2D{
	public:
		Array2D(int xsize=0, int ysize=0);
		Array2D& operator=(const Array2D &);
		Array2D(const Array2D<Cell,debug> &);
		void clear();
		//inline Array2D(int xsize, int ysize, const Cell * flatCells): m_cells(flatCells), m_ysize(ysize), m_xsize(xsize){}
		void flatten();
		void unflatten();
		//~Array2D();
		inline Cell& cell(int x, int y);
		inline void print(){
			cout << "Displaying array2D (x,y) --> (" << m_xsize << "," << m_ysize << ")" << " as (n,visits,acc.x,acc.y)" <<  endl;
			for(int i=0;i<m_xsize;i++){
				for(int j=0;j<m_ysize;j++){
					cout << "(" << cell(i,j).n << "," << cell(i,j).visits << "," << cell(i,j).acc.x << "," << cell(i,j).acc.y << ") ";
				}	
				cout<<endl;
			} 
			/*cout << "flattened: " << endl;
			for(int i=0;i<m_xsize*m_ysize;i++){
				cout << "acc.x: " << m_cells1D[i].acc.x << "  acc.visits: " << m_cells1D[i].visits << " ";
			}*/
			cout << endl;
		}	
		Cell ** m_cells;
		Cell * m_cells1D;
	protected:
		int m_xsize, m_ysize;

	friend class boost::serialization::access; 
	template <class Archive> void serialize(Archive& ar, const unsigned int version){
		ar & m_xsize & m_ysize;

		for(int i=0; i<m_xsize*m_ysize;i++){		
			ar & m_cells1D[i];
		}
	}
};

template <class Cell, const bool debug>
Array2D<Cell,debug> & Array2D<Cell,debug>::operator=(const Array2D<Cell,debug> & g){
	if (debug || m_xsize!=g.m_xsize || m_ysize!=g.m_ysize){
		for (int i=0; i<m_xsize; i++)
			delete [] m_cells[i];
		delete [] m_cells;
		m_xsize=g.m_xsize;
		m_ysize=g.m_ysize;
		m_cells=new Cell*[m_xsize];
		for (int i=0; i<m_xsize; i++)
			m_cells[i]=new Cell[m_ysize];
	}
	for (int x=0; x<m_xsize; x++)
		for (int y=0; y<m_ysize; y++)
			m_cells[x][y]=g.m_cells[x][y];
	
	if (debug){
		std::cerr << __PRETTY_FUNCTION__ << std::endl;
		std::cerr << "m_xsize= " << m_xsize<< std::endl;
		std::cerr << "m_ysize= " << m_ysize<< std::endl;
	}
	return *this;
}

template <class Cell, const bool debug>
Array2D<Cell,debug>::Array2D(int xsize, int ysize){
//	assert(xsize>0);
//	assert(ysize>0);
	m_xsize=xsize;
	m_ysize=ysize;
	if (m_xsize>0 && m_ysize>0){
		m_cells=new Cell*[m_xsize];
		for (int i=0; i<m_xsize; i++)
			m_cells[i]=new Cell[m_ysize];
	}
	else{
		m_xsize=m_ysize=0;
		m_cells=0;
	}
	if (debug){
		std::cerr << __PRETTY_FUNCTION__ << std::endl;
		std::cerr << "m_xsize= " << m_xsize<< std::endl;
		std::cerr << "m_ysize= " << m_ysize<< std::endl;
	}
}
template <class Cell, const bool debug>
inline Cell& Array2D<Cell,debug>::cell(int x, int y){
	return m_cells[x][y];
}

template <class Cell, const bool debug>
Array2D<Cell,debug>::Array2D(const Array2D<Cell,debug> & g){
	m_xsize=g.m_xsize;
	m_ysize=g.m_ysize;
	m_cells=new Cell*[m_xsize];
	for (int x=0; x<m_xsize; x++){
		m_cells[x]=new Cell[m_ysize];
		for (int y=0; y<m_ysize; y++)
			m_cells[x][y]=g.m_cells[x][y];
	}
	if (debug){
		std::cerr << __PRETTY_FUNCTION__ << std::endl;
		std::cerr << "m_xsize= " << m_xsize<< std::endl;
		std::cerr << "m_ysize= " << m_ysize<< std::endl;
	}
}

template <class Cell, const bool debug>
void Array2D<Cell,debug>::clear(){
  if (debug){
  	std::cerr << __PRETTY_FUNCTION__ << std::endl;
		std::cerr << "m_xsize= " << m_xsize<< std::endl;
		std::cerr << "m_ysize= " << m_ysize<< std::endl;
  }
  for (int i=0; i<m_xsize; i++){
    delete [] m_cells[i];
    m_cells[i]=0;
  }
  delete [] m_cells;
  m_cells=0;

	delete [] m_cells1D;
	m_cells1D = 0;

	m_xsize =0;
	m_ysize =0;
}

template <class Cell, const bool debug>
void Array2D<Cell,debug>::flatten(){
	m_cells1D=new Cell[m_ysize*m_xsize];
	for (int x=0; x<m_xsize; x++){
		for (int y=0; y<m_ysize; y++)
			m_cells1D[x*m_ysize+y]= m_cells[x][y];
	}
}

template <class Cell, const bool debug>
void Array2D<Cell,debug>::unflatten(){
	m_cells=new Cell*[m_xsize];
	for (int x=0; x<m_xsize; x++){
		m_cells[x]=new Cell[m_ysize];
		for (int y=0; y<m_ysize; y++)
			m_cells[x][y]= m_cells1D[x*m_ysize+y];
	}
}


/*
 * SaveToFile and LoadFromFile
 *
 */
template <class A> void saveIntoFile(Array2D<PointAccumulator,false>& array, const char* file){
		ofstream ofile(file);
		A ar(ofile);		
		ar << array;
		ofile.close();
}

template <class A> void loadFromFile(Array2D<PointAccumulator,false>& array, const char* file){
	ifstream ifile(file);
	A ar(ifile);
	ar >> array;
	ifile.close();
	//return array;
}


/*
 * MAIN
 *
 */
int main(){
	
	Array2D<PointAccumulator,false> myArr = Array2D<PointAccumulator,false>(2,2);
	myArr.cell(0,0).acc.x = 3;
	myArr.cell(0,0).n = 15;
	myArr.cell(0,0).visits =16; 
	myArr.cell(0,1).acc.x = 3;
	myArr.cell(0,1).n = 17;
	myArr.cell(0,1).visits = 18;
	myArr.cell(1,0).acc.x = 3;
	
	myArr.cell(1,1).n = 20;
	myArr.cell(1,1).visits = 21;
	myArr.cell(1,1).acc.x = 22;
	myArr.cell(1,1).acc.y = 23;
	
	myArr.flatten();
	cout << "myArray (toSave)" << endl;	
	myArr.print();	
	saveIntoFile<text_oarchive>(myArr,"out.txt");
	
	Array2D<PointAccumulator,false> myArr4 = Array2D<PointAccumulator,false>();
	myArr4 = myArr;

	//Destroy myArr
	myArr.clear();
	cout << "myArray copy" << endl;
	myArr4.print();

	
	Array2D<PointAccumulator,false> myArr2; // = Array2D<PointAccumulator,true>();
	loadFromFile<text_iarchive>(myArr2,"out.txt");
	myArr2.unflatten();
	cout << "myArray2 (loaded)" << endl;
	myArr2.print();

	//myArr2 = myArr4;

	cout << "myArray (base)" << endl;
	myArr.print();
	cout << "myArray copy" << endl;
	myArr4.print();
	cout << "myArray2" << endl;	
	myArr2.print();
	//myArr2.clear();

	cout << "end" << endl;

	return 0;
}