portelli/Grid
1
0
Fork 0
mirror of https://github.com/paboyle/Grid.git synced 2024-11-10 07:55:35 +00:00
Code Releases Activity

Merge pull request #21 from aportelli/master

Browse Source 
Overhaul of I/O interface
This commit is contained in:
azusayamaguchi 2015-11-19 11:45:50 +00:00
commit d43034d3ac
16 changed files with 686 additions and 709 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -43,6 +43,7 @@
######################################## ########################################
Makefile.in Makefile.in
Makefile Makefile
Config.h
config.log config.log
config.status config.status
.deps .deps

172
lib/Config.h
View File

@ -1,172 +0,0 @@
/* lib/Config.h. Generated from Config.h.in by configure. */
/* lib/Config.h.in. Generated from configure.ac by autoheader. */
/* AVX Intrinsics */
/* #undef AVX1 */
/* AVX2 Intrinsics */
/* #undef AVX2 */
/* AVX512 Intrinsics for Knights Corner */
/* #undef AVX512 */
/* EMPTY_SIMD only for DEBUGGING */
/* #undef EMPTY_SIMD */
/* GRID_COMMS_MPI */
/* #undef GRID_COMMS_MPI */
/* GRID_COMMS_NONE */
#define GRID_COMMS_NONE 1
/* GRID_DEFAULT_PRECISION is DOUBLE */
/* #undef GRID_DEFAULT_PRECISION_DOUBLE */
/* GRID_DEFAULT_PRECISION is SINGLE */
#define GRID_DEFAULT_PRECISION_SINGLE 1
/* Support Altivec instructions */
/* #undef HAVE_ALTIVEC */
/* Support AVX (Advanced Vector Extensions) instructions */
/* #undef HAVE_AVX */
/* Support AVX2 (Advanced Vector Extensions 2) instructions */
/* #undef HAVE_AVX2 */
/* Define to 1 if you have the declaration of `be64toh', and to 0 if you
don't. */
#define HAVE_DECL_BE64TOH 1
/* Define to 1 if you have the declaration of `ntohll', and to 0 if you don't.
*/
#define HAVE_DECL_NTOHLL 0
/* Define to 1 if you have the <endian.h> header file. */
#define HAVE_ENDIAN_H 1
/* Support FMA3 (Fused Multiply-Add) instructions */
/* #undef HAVE_FMA */
/* Define to 1 if you have the `gettimeofday' function. */
#define HAVE_GETTIMEOFDAY 1
/* Define to 1 if you have the <gmp.h> header file. */
#define HAVE_GMP_H 1
/* Define to 1 if you have the <inttypes.h> header file. */
#define HAVE_INTTYPES_H 1
/* Define to 1 if you have the `gmp' library (-lgmp). */
#define HAVE_LIBGMP 1
/* Define to 1 if you have the `mpfr' library (-lmpfr). */
#define HAVE_LIBMPFR 1
/* Define to 1 if you have the <malloc.h> header file. */
#define HAVE_MALLOC_H 1
/* Define to 1 if you have the <malloc/malloc.h> header file. */
/* #undef HAVE_MALLOC_MALLOC_H */
/* Define to 1 if you have the <memory.h> header file. */
#define HAVE_MEMORY_H 1
/* Support mmx instructions */
#define HAVE_MMX /**/
/* Define to 1 if you have the <mm_malloc.h> header file. */
#define HAVE_MM_MALLOC_H 1
/* Support SSE (Streaming SIMD Extensions) instructions */
#define HAVE_SSE /**/
/* Support SSE2 (Streaming SIMD Extensions 2) instructions */
#define HAVE_SSE2 /**/
/* Support SSE3 (Streaming SIMD Extensions 3) instructions */
#define HAVE_SSE3 /**/
/* Support SSSE4.1 (Streaming SIMD Extensions 4.1) instructions */
#define HAVE_SSE4_1 /**/
/* Support SSSE4.2 (Streaming SIMD Extensions 4.2) instructions */
#define HAVE_SSE4_2 /**/
/* Support SSSE3 (Supplemental Streaming SIMD Extensions 3) instructions */
#define HAVE_SSSE3 /**/
/* Define to 1 if you have the <stdint.h> header file. */
#define HAVE_STDINT_H 1
/* Define to 1 if you have the <stdlib.h> header file. */
#define HAVE_STDLIB_H 1
/* Define to 1 if you have the <strings.h> header file. */
#define HAVE_STRINGS_H 1
/* Define to 1 if you have the <string.h> header file. */
#define HAVE_STRING_H 1
/* Define to 1 if you have the <sys/stat.h> header file. */
#define HAVE_SYS_STAT_H 1
/* Define to 1 if you have the <sys/types.h> header file. */
#define HAVE_SYS_TYPES_H 1
/* Define to 1 if you have the <unistd.h> header file. */
#define HAVE_UNISTD_H 1
/* NEON ARMv8 Experimental support */
/* #undef NEONv8 */
/* Name of package */
#define PACKAGE "grid"
/* Define to the address where bug reports for this package should be sent. */
#define PACKAGE_BUGREPORT "paboyle@ph.ed.ac.uk"
/* Define to the full name of this package. */
#define PACKAGE_NAME "Grid"
/* Define to the full name and version of this package. */
#define PACKAGE_STRING "Grid 1.0"
/* Define to the one symbol short name of this package. */
#define PACKAGE_TARNAME "grid"
/* Define to the home page for this package. */
#define PACKAGE_URL ""
/* Define to the version of this package. */
#define PACKAGE_VERSION "1.0"
/* SSE4 Intrinsics */
#define SSE4 1
/* Define to 1 if you have the ANSI C header files. */
#define STDC_HEADERS 1
/* Version number of package */
#define VERSION "1.0"
/* Define for Solaris 2.5.1 so the uint32_t typedef from <sys/synch.h>,
<pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
#define below would cause a syntax error. */
/* #undef _UINT32_T */
/* Define for Solaris 2.5.1 so the uint64_t typedef from <sys/synch.h>,
<pthread.h>, or <semaphore.h> is not used. If the typedef were allowed, the
#define below would cause a syntax error. */
/* #undef _UINT64_T */
/* Define to `unsigned int' if <sys/types.h> does not define. */
/* #undef size_t */
/* Define to the type of an unsigned integer type of width exactly 32 bits if
such a type exists and the standard includes do not define it. */
/* #undef uint32_t */
/* Define to the type of an unsigned integer type of width exactly 64 bits if
such a type exists and the standard includes do not define it. */
/* #undef uint64_t */

4
lib/Log.cc
View File

@ -2,8 +2,8 @@
namespace Grid { namespace Grid {
GridStopWatch GridLogger::StopWatch; GridStopWatch Logger::StopWatch;
std::ostream GridLogger::devnull(0); std::ostream Logger::devnull(0);
GridLogger GridLogError (1,"Error"); GridLogger GridLogError (1,"Error");
GridLogger GridLogWarning (1,"Warning"); GridLogger GridLogWarning (1,"Warning");

54
lib/Log.h
View File

@ -6,31 +6,39 @@ namespace Grid {
std::ostream& operator<< (std::ostream& stream, const GridTime& time); std::ostream& operator<< (std::ostream& stream, const GridTime& time);
class GridLogger { class Logger {
int active; protected:
std::string name; int active;
std::string name, topName;
public: public:
static GridStopWatch StopWatch;
static GridStopWatch StopWatch; static std::ostream devnull;
static std::ostream devnull;
Logger(std::string topNm, int on, std::string nm)
GridLogger(int on, std::string nm): active(on), name(nm) { : active(on), name(nm), topName(topNm) {};
};
void Active(int on) {active = on;};
void Active(int on) {active = on;}; int isActive(void) {return active;};
friend std::ostream& operator<< (std::ostream& stream, const GridLogger& log){ friend std::ostream& operator<< (std::ostream& stream, const Logger& log){
if ( log.active ) { if ( log.active ) {
StopWatch.Stop(); StopWatch.Stop();
GridTime now = StopWatch.Elapsed(); GridTime now = StopWatch.Elapsed();
StopWatch.Start(); StopWatch.Start();
stream << "Grid : "<<log.name << " : " << now << " : "; stream << std::setw(8) << std::left << log.topName << " : ";
return stream; stream << std::setw(12) << std::left << log.name << " : ";
} else { stream << now << " : ";
return devnull; return stream;
} else {
return devnull;
}
} }
}
};
class GridLogger: public Logger {
public:
GridLogger(int on, std::string nm): Logger("Grid", on, nm){};
}; };
void GridLogConfigure(std::vector<std::string> &logstreams); void GridLogConfigure(std::vector<std::string> &logstreams);

2
lib/Make.inc
View File

@ -1,4 +1,4 @@
HFILES=./algorithms/approx/bigfloat.h ./algorithms/approx/bigfloat_double.h ./algorithms/approx/Chebyshev.h ./algorithms/approx/MultiShiftFunction.h ./algorithms/approx/Remez.h ./algorithms/approx/Zolotarev.h ./algorithms/CoarsenedMatrix.h ./algorithms/iterative/AdefGeneric.h ./algorithms/iterative/ConjugateGradient.h ./algorithms/iterative/ConjugateGradientMultiShift.h ./algorithms/iterative/ConjugateResidual.h ./algorithms/iterative/ImplicitlyRestartedLanczos.h ./algorithms/iterative/MatrixUtils.h ./algorithms/iterative/NormalEquations.h ./algorithms/iterative/PrecConjugateResidual.h ./algorithms/iterative/PrecGeneralisedConjugateResidual.h ./algorithms/iterative/SchurRedBlack.h ./algorithms/LinearOperator.h ./algorithms/Preconditioner.h ./algorithms/SparseMatrix.h ./Algorithms.h ./AlignedAllocator.h ./cartesian/Cartesian_base.h ./cartesian/Cartesian_full.h ./cartesian/Cartesian_red_black.h ./Cartesian.h ./communicator/Communicator_base.h ./Communicator.h ./Config.h ./cshift/Cshift_common.h ./cshift/Cshift_mpi.h ./cshift/Cshift_none.h ./Cshift.h ./Grid.h ./Init.h ./lattice/Lattice_arith.h ./lattice/Lattice_base.h ./lattice/Lattice_comparison.h ./lattice/Lattice_comparison_utils.h ./lattice/Lattice_conformable.h ./lattice/Lattice_coordinate.h ./lattice/Lattice_ET.h ./lattice/Lattice_local.h ./lattice/Lattice_overload.h ./lattice/Lattice_peekpoke.h ./lattice/Lattice_reality.h ./lattice/Lattice_reduction.h ./lattice/Lattice_rng.h ./lattice/Lattice_trace.h ./lattice/Lattice_transfer.h ./lattice/Lattice_transpose.h ./lattice/Lattice_unary.h ./lattice/Lattice_where.h ./Lattice.h ./Log.h ./Old/Tensor_peek.h ./Old/Tensor_poke.h ./parallelIO/BinaryIO.h ./parallelIO/NerscIO.h ./pugixml/pugixml.h ./qcd/action/ActionBase.h ./qcd/action/ActionParams.h ./qcd/action/Actions.h ./qcd/action/fermion/CayleyFermion5D.h ./qcd/action/fermion/ContinuedFractionFermion5D.h ./qcd/action/fermion/DomainWallFermion.h ./qcd/action/fermion/FermionOperator.h ./qcd/action/fermion/FermionOperatorImpl.h ./qcd/action/fermion/g5HermitianLinop.h ./qcd/action/fermion/MobiusFermion.h ./qcd/action/fermion/MobiusZolotarevFermion.h ./qcd/action/fermion/OverlapWilsonCayleyTanhFermion.h ./qcd/action/fermion/OverlapWilsonCayleyZolotarevFermion.h ./qcd/action/fermion/OverlapWilsonContfracTanhFermion.h ./qcd/action/fermion/OverlapWilsonContfracZolotarevFermion.h ./qcd/action/fermion/OverlapWilsonPartialFractionTanhFermion.h ./qcd/action/fermion/OverlapWilsonPartialFractionZolotarevFermion.h ./qcd/action/fermion/PartialFractionFermion5D.h ./qcd/action/fermion/ScaledShamirFermion.h ./qcd/action/fermion/ShamirZolotarevFermion.h ./qcd/action/fermion/WilsonCompressor.h ./qcd/action/fermion/WilsonFermion.h ./qcd/action/fermion/WilsonFermion5D.h ./qcd/action/fermion/WilsonKernels.h ./qcd/action/gauge/WilsonGaugeAction.h ./qcd/action/pseudofermion/EvenOddSchurDifferentiable.h ./qcd/action/pseudofermion/OneFlavourEvenOddRational.h ./qcd/action/pseudofermion/OneFlavourEvenOddRationalRatio.h ./qcd/action/pseudofermion/OneFlavourRational.h ./qcd/action/pseudofermion/OneFlavourRationalRatio.h ./qcd/action/pseudofermion/TwoFlavour.h ./qcd/action/pseudofermion/TwoFlavourEvenOdd.h ./qcd/action/pseudofermion/TwoFlavourEvenOddRatio.h ./qcd/action/pseudofermion/TwoFlavourRatio.h ./qcd/hmc/HMC.h ./qcd/hmc/integrators/Integrator.h ./qcd/hmc/integrators/Integrator_algorithm.h ./qcd/QCD.h ./qcd/spin/Dirac.h ./qcd/spin/TwoSpinor.h ./qcd/utils/CovariantCshift.h ./qcd/utils/LinalgUtils.h ./qcd/utils/SpaceTimeGrid.h ./qcd/utils/SUn.h ./qcd/utils/WilsonLoops.h ./serialisation/BaseIO.h ./serialisation/BinaryIO.h ./serialisation/MacroMagic.h ./serialisation/Serialisation.h ./serialisation/TextIO.h ./serialisation/XmlIO.h ./simd/Grid_avx.h ./simd/Grid_avx512.h ./simd/Grid_empty.h ./simd/Grid_imci.h ./simd/Grid_neon.h ./simd/Grid_qpx.h ./simd/Grid_sse4.h ./simd/Grid_vector_types.h ./simd/Grid_vector_unops.h ./Simd.h ./stencil/Lebesgue.h ./Stencil.h ./tensors/Tensor_arith.h ./tensors/Tensor_arith_add.h ./tensors/Tensor_arith_mac.h ./tensors/Tensor_arith_mul.h ./tensors/Tensor_arith_scalar.h ./tensors/Tensor_arith_sub.h ./tensors/Tensor_class.h ./tensors/Tensor_determinant.h ./tensors/Tensor_exp.h ./tensors/Tensor_extract_merge.h ./tensors/Tensor_index.h ./tensors/Tensor_inner.h ./tensors/Tensor_logical.h ./tensors/Tensor_outer.h ./tensors/Tensor_reality.h ./tensors/Tensor_Ta.h ./tensors/Tensor_trace.h ./tensors/Tensor_traits.h ./tensors/Tensor_transpose.h ./tensors/Tensor_unary.h ./Tensors.h ./Threads.h ./Timer.h HFILES=./algorithms/approx/bigfloat.h ./algorithms/approx/bigfloat_double.h ./algorithms/approx/Chebyshev.h ./algorithms/approx/MultiShiftFunction.h ./algorithms/approx/Remez.h ./algorithms/approx/Zolotarev.h ./algorithms/CoarsenedMatrix.h ./algorithms/iterative/AdefGeneric.h ./algorithms/iterative/ConjugateGradient.h ./algorithms/iterative/ConjugateGradientMultiShift.h ./algorithms/iterative/ConjugateResidual.h ./algorithms/iterative/ImplicitlyRestartedLanczos.h ./algorithms/iterative/MatrixUtils.h ./algorithms/iterative/NormalEquations.h ./algorithms/iterative/PrecConjugateResidual.h ./algorithms/iterative/PrecGeneralisedConjugateResidual.h ./algorithms/iterative/SchurRedBlack.h ./algorithms/LinearOperator.h ./algorithms/Preconditioner.h ./algorithms/SparseMatrix.h ./Algorithms.h ./AlignedAllocator.h ./cartesian/Cartesian_base.h ./cartesian/Cartesian_full.h ./cartesian/Cartesian_red_black.h ./Cartesian.h ./communicator/Communicator_base.h ./Communicator.h ./Config.h ./cshift/Cshift_common.h ./cshift/Cshift_mpi.h ./cshift/Cshift_none.h ./Cshift.h ./Grid.h ./Init.h ./lattice/Lattice_arith.h ./lattice/Lattice_base.h ./lattice/Lattice_comparison.h ./lattice/Lattice_comparison_utils.h ./lattice/Lattice_conformable.h ./lattice/Lattice_coordinate.h ./lattice/Lattice_ET.h ./lattice/Lattice_local.h ./lattice/Lattice_overload.h ./lattice/Lattice_peekpoke.h ./lattice/Lattice_reality.h ./lattice/Lattice_reduction.h ./lattice/Lattice_rng.h ./lattice/Lattice_trace.h ./lattice/Lattice_transfer.h ./lattice/Lattice_transpose.h ./lattice/Lattice_unary.h ./lattice/Lattice_where.h ./Lattice.h ./Log.h ./Old/Tensor_peek.h ./Old/Tensor_poke.h ./parallelIO/BinaryIO.h ./parallelIO/NerscIO.h ./pugixml/pugixml.h ./qcd/action/ActionBase.h ./qcd/action/ActionParams.h ./qcd/action/Actions.h ./qcd/action/fermion/CayleyFermion5D.h ./qcd/action/fermion/ContinuedFractionFermion5D.h ./qcd/action/fermion/DomainWallFermion.h ./qcd/action/fermion/FermionOperator.h ./qcd/action/fermion/FermionOperatorImpl.h ./qcd/action/fermion/g5HermitianLinop.h ./qcd/action/fermion/MobiusFermion.h ./qcd/action/fermion/MobiusZolotarevFermion.h ./qcd/action/fermion/OverlapWilsonCayleyTanhFermion.h ./qcd/action/fermion/OverlapWilsonCayleyZolotarevFermion.h ./qcd/action/fermion/OverlapWilsonContfracTanhFermion.h ./qcd/action/fermion/OverlapWilsonContfracZolotarevFermion.h ./qcd/action/fermion/OverlapWilsonPartialFractionTanhFermion.h ./qcd/action/fermion/OverlapWilsonPartialFractionZolotarevFermion.h ./qcd/action/fermion/PartialFractionFermion5D.h ./qcd/action/fermion/ScaledShamirFermion.h ./qcd/action/fermion/ShamirZolotarevFermion.h ./qcd/action/fermion/WilsonCompressor.h ./qcd/action/fermion/WilsonFermion.h ./qcd/action/fermion/WilsonFermion5D.h ./qcd/action/fermion/WilsonKernels.h ./qcd/action/gauge/WilsonGaugeAction.h ./qcd/action/pseudofermion/EvenOddSchurDifferentiable.h ./qcd/action/pseudofermion/OneFlavourEvenOddRational.h ./qcd/action/pseudofermion/OneFlavourEvenOddRationalRatio.h ./qcd/action/pseudofermion/OneFlavourRational.h ./qcd/action/pseudofermion/OneFlavourRationalRatio.h ./qcd/action/pseudofermion/TwoFlavour.h ./qcd/action/pseudofermion/TwoFlavourEvenOdd.h ./qcd/action/pseudofermion/TwoFlavourEvenOddRatio.h ./qcd/action/pseudofermion/TwoFlavourRatio.h ./qcd/hmc/HMC.h ./qcd/hmc/integrators/Integrator.h ./qcd/hmc/integrators/Integrator_algorithm.h ./qcd/QCD.h ./qcd/spin/Dirac.h ./qcd/spin/TwoSpinor.h ./qcd/utils/CovariantCshift.h ./qcd/utils/LinalgUtils.h ./qcd/utils/SpaceTimeGrid.h ./qcd/utils/SUn.h ./qcd/utils/WilsonLoops.h ./serialisation/BaseIO.h ./serialisation/BinaryIO.h ./serialisation/MacroMagic.h ./serialisation/Serialisation.h ./serialisation/TextIO.h ./serialisation/XmlIO.h ./simd/Grid_avx.h ./simd/Grid_avx512.h ./simd/Grid_empty.h ./simd/Grid_imci.h ./simd/Grid_neon.h ./simd/Grid_qpx.h ./simd/Grid_sse4.h ./simd/Grid_vector_types.h ./simd/Grid_vector_unops.h ./Simd.h ./stencil/Lebesgue.h ./Stencil.h ./tensors/Tensor_arith.h ./tensors/Tensor_arith_add.h ./tensors/Tensor_arith_mac.h ./tensors/Tensor_arith_mul.h ./tensors/Tensor_arith_scalar.h ./tensors/Tensor_arith_sub.h ./tensors/Tensor_class.h ./tensors/Tensor_determinant.h ./tensors/Tensor_exp.h ./tensors/Tensor_extract_merge.h ./tensors/Tensor_index.h ./tensors/Tensor_inner.h ./tensors/Tensor_logical.h ./tensors/Tensor_outer.h ./tensors/Tensor_reality.h ./tensors/Tensor_Ta.h ./tensors/Tensor_trace.h ./tensors/Tensor_traits.h ./tensors/Tensor_transpose.h ./tensors/Tensor_unary.h ./Tensors.h ./Threads.h ./Timer.h
CCFILES=./algorithms/approx/MultiShiftFunction.cc ./algorithms/approx/Remez.cc ./algorithms/approx/Zolotarev.cc ./Init.cc ./Log.cc ./pugixml/pugixml.cc ./qcd/action/fermion/CayleyFermion5D.cc ./qcd/action/fermion/ContinuedFractionFermion5D.cc ./qcd/action/fermion/PartialFractionFermion5D.cc ./qcd/action/fermion/WilsonFermion.cc ./qcd/action/fermion/WilsonFermion5D.cc ./qcd/action/fermion/WilsonKernels.cc ./qcd/action/fermion/WilsonKernelsHand.cc ./qcd/hmc/HMC.cc ./qcd/spin/Dirac.cc ./qcd/utils/SpaceTimeGrid.cc ./stencil/Lebesgue.cc ./stencil/Stencil_common.cc CCFILES=./algorithms/approx/MultiShiftFunction.cc ./algorithms/approx/Remez.cc ./algorithms/approx/Zolotarev.cc ./Init.cc ./Log.cc ./pugixml/pugixml.cc ./qcd/action/fermion/CayleyFermion5D.cc ./qcd/action/fermion/ContinuedFractionFermion5D.cc ./qcd/action/fermion/PartialFractionFermion5D.cc ./qcd/action/fermion/WilsonFermion.cc ./qcd/action/fermion/WilsonFermion5D.cc ./qcd/action/fermion/WilsonKernels.cc ./qcd/action/fermion/WilsonKernelsHand.cc ./qcd/hmc/HMC.cc ./qcd/spin/Dirac.cc ./qcd/utils/SpaceTimeGrid.cc ./serialisation/BinaryIO.cc ./serialisation/TextIO.cc ./serialisation/XmlIO.cc ./stencil/Lebesgue.cc ./stencil/Stencil_common.cc

244
lib/serialisation/BaseIO.h
View File

@ -1,49 +1,211 @@
#ifndef GRID_SERIALISATION_ABSTRACT_READER_H #ifndef GRID_SERIALISATION_ABSTRACT_READER_H
#define GRID_SERIALISATION_ABSTRACT_READER_H #define GRID_SERIALISATION_ABSTRACT_READER_H
#include <type_traits>
namespace Grid { namespace Grid {
class Writer {
public:
virtual ~Writer() {};
virtual void push(const std::string &s) = 0;
virtual void pop(void) =0;
virtual void write( const std::string& s,const std::string &output ) =0;
virtual void write( const std::string& s,const int16_t output ) =0;
virtual void write( const std::string& s,const uint16_t output ) =0;
virtual void write( const std::string& s,const int32_t output ) =0;
virtual void write( const std::string& s,const uint32_t output ) =0;
virtual void write( const std::string& s,const int64_t output ) =0;
virtual void write( const std::string& s,const uint64_t output ) =0;
virtual void write( const std::string& s,const float output ) =0;
virtual void write( const std::string& s,const double output ) =0;
virtual void write( const std::string& s,const bool output ) =0;
}; class Serializable {};
class Reader { // static polymorphism implemented using CRTP idiom
public:
// Static abstract writer
template <typename T>
class Writer
virtual ~Reader() {}; {
public:
virtual void read( const std::string& s,std::string &output ) =0; Writer(void);
virtual void push(const std::string &s) =0; virtual ~Writer(void) = default;
virtual void pop(void) = 0; void push(const std::string &s);
void pop(void);
virtual void read( const std::string& s, int16_t &output ) =0; template <typename U>
virtual void read( const std::string& s, uint16_t &output ) =0; typename std::enable_if<std::is_base_of<Serializable, U>::value, void>::type
virtual void read( const std::string& s, int32_t &output ) =0; write(const std::string& s, const U &output);
virtual void read( const std::string& s, uint32_t &output ) =0; template <typename U>
virtual void read( const std::string& s, int64_t &output ) =0; typename std::enable_if<!std::is_base_of<Serializable, U>::value, void>::type
virtual void read( const std::string& s, uint64_t &output ) =0; write(const std::string& s, const U &output);
virtual void read( const std::string& s, float &output ) =0; private:
virtual void read( const std::string& s, double &output ) =0; T *upcast;
virtual void read( const std::string& s, bool &output ) =0; };
// Static abstract reader
template <typename T>
class Reader
{
public:
Reader(void);
virtual ~Reader(void) = default;
void push(const std::string &s);
void pop(void);
template <typename U>
typename std::enable_if<std::is_base_of<Serializable, U>::value, void>::type
read(const std::string& s, U &output);
template <typename U>
typename std::enable_if<!std::is_base_of<Serializable, U>::value, void>::type
read(const std::string& s, U &output);
protected:
template <typename U>
void fromString(U &output, const std::string &s);
private:
T *upcast;
};
// Generic writer interface
template <typename T>
inline void push(Writer<T> &w, const std::string &s)
{
w.push(s);
}
template <typename T>
inline void push(Writer<T> &w, const char *s)
{
w.push(std::string(s));
}
template <typename T>
inline void pop(Writer<T> &w)
{
w.pop();
}
template <typename T, typename U>
inline void write(Writer<T> &w, const std::string& s, const U &output)
{
w.write(s, output);
}
// Generic reader interface
template <typename T>
inline void push(Reader<T> &r, const std::string &s)
{
r.push(s);
}
template <typename T>
inline void push(Reader<T> &r, const char *s)
{
r.push(std::string(s));
}
template <typename T>
inline void pop(Reader<T> &r)
{
r.pop();
}
template <typename T, typename U>
inline void read(Reader<T> &r, const std::string &s, U &output)
{
r.read(s, output);
}
template < class T >
inline std::ostream& operator << (std::ostream& os, const std::vector<T>& v)
{
os << "[";
for (auto &x: v)
{
os << x << " ";
}
if (v.size() > 0)
{
os << "\b";
}
os << "]";
return os;
}
// Writer template implementation ////////////////////////////////////////////
template <typename T>
Writer<T>::Writer(void)
{
upcast = static_cast<T *>(this);
}
template <typename T>
void Writer<T>::push(const std::string &s)
{
upcast->push(s);
}
template <typename T>
void Writer<T>::pop(void)
{
upcast->pop();
}
template <typename T>
template <typename U>
typename std::enable_if<std::is_base_of<Serializable, U>::value, void>::type
Writer<T>::write(const std::string &s, const U &output)
{
U::write(*this, s, output);
}
template <typename T>
template <typename U>
typename std::enable_if<!std::is_base_of<Serializable, U>::value, void>::type
Writer<T>::write(const std::string &s, const U &output)
{
upcast->writeDefault(s, output);
}
// Reader template implementation ////////////////////////////////////////////
template <typename T>
Reader<T>::Reader(void)
{
upcast = static_cast<T *>(this);
}
template <typename T>
void Reader<T>::push(const std::string &s)
{
upcast->push(s);
}
template <typename T>
void Reader<T>::pop(void)
{
upcast->pop();
}
template <typename T>
template <typename U>
typename std::enable_if<std::is_base_of<Serializable, U>::value, void>::type
Reader<T>::read(const std::string &s, U &output)
{
U::read(*this, s, output);
}
template <typename T>
template <typename U>
typename std::enable_if<!std::is_base_of<Serializable, U>::value, void>::type
Reader<T>::read(const std::string &s, U &output)
{
upcast->readDefault(s, output);
}
template <typename T>
template <typename U>
void Reader<T>::fromString(U &output, const std::string &s)
{
std::istringstream is(s);
is.exceptions(std::ios::failbit);
try
{
is >> std::boolalpha >> output;
}
catch(std::istringstream::failure &e)
{
std::cerr << "numerical conversion failure on '" << s << "' ";
std::cerr << "(typeid: " << typeid(U).name() << ")" << std::endl;
abort();
}
}
};
} }
#endif #endif

36
lib/serialisation/BinaryIO.cc Normal file
View File

@ -0,0 +1,36 @@
#include <Grid.h>
using namespace Grid;
using namespace std;
// Writer implementation ///////////////////////////////////////////////////////
BinaryWriter::BinaryWriter(const string &fileName)
: file_(fileName, ios::binary|ios::out)
{}
template <>
void BinaryWriter::writeDefault(const string &s, const string &output)
{
uint64_t sz = output.size();
write("", sz);
for (uint64_t i = 0; i < sz; ++i)
{
write("", output[i]);
}
}
// Reader implementation ///////////////////////////////////////////////////////
BinaryReader::BinaryReader(const string &fileName)
: file_(fileName, ios::binary|ios::in)
{}
template <>
void BinaryReader::readDefault(const string &s, string &output)
{
uint64_t sz;
read("", sz);
output.reserve(sz);
file_.read((char *)output.data(), sz);
}

153
lib/serialisation/BinaryIO.h
View File

@ -9,101 +9,76 @@
#include <vector> #include <vector>
#include <cassert> #include <cassert>
namespace Grid { namespace Grid {
class BinaryWriter : public Writer {
private:
std::ofstream file; class BinaryWriter: public Writer<BinaryWriter>
{
public: public:
BinaryWriter(const std::string &fileName);
BinaryWriter(const std::string &_file) : file(_file,std::ios::binary|std::ios::out) {} virtual ~BinaryWriter(void) = default;
void push(const std::string &s) {};
~BinaryWriter() {} void pop(void) {};
template <typename U>
// Binary is scopeless void writeDefault(const std::string &s, const U &x);
void push(const std::string &s) {} template <typename U>
void pop(void) {} void writeDefault(const std::string &s, const std::vector<U> &x);
private:
void write(const std::string& s,const std::string &output) { std::ofstream file_;
uint32_t sz = output.size();
write(s,sz);
const char * cstr = output.c_str();
for(int c=0;c<output.size();c++){
write(s,cstr[c]);
}
}; };
void write( const std::string& s,const char output ) { writeInternal(s,output); };
void write( const std::string& s,const int16_t output ) { writeInternal(s,output); }; class BinaryReader: public Reader<BinaryReader>
void write( const std::string& s,const uint16_t output ) { writeInternal(s,output); }; {
void write( const std::string& s,const int32_t output ) { writeInternal(s,output); }; public:
void write( const std::string& s,const uint32_t output ) { writeInternal(s,output); }; BinaryReader(const std::string &fileName);
void write( const std::string& s,const int64_t output ) { writeInternal(s,output); }; virtual ~BinaryReader(void) = default;
void write( const std::string& s,const uint64_t output ) { writeInternal(s,output); }; void push(const std::string &s) {};
void write( const std::string& s,const float output ) { writeInternal(s,output); }; void pop(void) {};
void write( const std::string& s,const double output ) { writeInternal(s,output); }; template <typename U>
void write( const std::string& s,const bool output ) { writeInternal(s,output); }; void readDefault(const std::string &s, U &output);
template <typename U>
private: void readDefault(const std::string &s, std::vector<U> &output);
template<class T> void writeInternal( const std::string& s,const T output ){ private:
// FIXME --- htons, htonl, htno64 etc.. std::ifstream file_;
file.write((char *)&output,sizeof(T)); };
// Writer template implementation ////////////////////////////////////////////
template <typename U>
void BinaryWriter::writeDefault(const std::string &s, const U &x)
{
file_.write((char *)&x, sizeof(U));
} }
}; template <typename U>
void BinaryWriter::writeDefault(const std::string &s, const std::vector<U> &x)
{
class BinaryReader : public Reader{ uint64_t sz = x.size();
private:
write("", sz);
std::ifstream file; for (uint64_t i = 0; i < sz; ++i)
{
public: write("", x[i]);
}
}
BinaryReader(const std::string &_file) : file(_file,std::ios::binary|std::ios::in) {}
// Reader template implementation ////////////////////////////////////////////
~BinaryReader() {} template <typename U>
void BinaryReader::readDefault(const std::string &s, U &output)
// Binary is scopeless {
void push(const std::string &s) { } file_.read((char *)&output, sizeof(U));
void pop(void) { } }
void read( const std::string& s,std::string &output ) { template <typename U>
void BinaryReader::readDefault(const std::string &s, std::vector<U> &output)
output.clear(); {
uint64_t sz;
uint32_t sz;
file.read((char *)&sz,sizeof(sz)); read("", sz);
output.resize(sz);
for(int c=0;c<sz;c++){ for (uint64_t i = 0; i < sz; ++i)
char ch; {
file.read(&ch,sizeof(ch)); read("", output[i]);
output.push_back(ch);
} }
};
void read( const std::string& s, int16_t &output ) { readInternal(s,output); };
void read( const std::string& s, uint16_t &output ) { readInternal(s,output); };
void read( const std::string& s, int32_t &output ) { readInternal(s,output); };
void read( const std::string& s, uint32_t &output ) { readInternal(s,output); };
void read( const std::string& s, int64_t &output ) { readInternal(s,output); };
void read( const std::string& s, uint64_t &output ) { readInternal(s,output); };
void read( const std::string& s, float &output ) { readInternal(s,output); };
void read( const std::string& s, double &output ) { readInternal(s,output); };
void read( const std::string& s, bool &output ) { readInternal(s,output); };
private:
template<class T> void readInternal( const std::string& path, T &output ){
file.read((char *)&output,sizeof(output)); // byte order??
} }
};
} }
#endif #endif

10
lib/serialisation/MacroMagic.h
View File

@ -111,8 +111,8 @@ THE SOFTWARE.
#define GRID_MACRO_MEMBER(A,B) A B; #define GRID_MACRO_MEMBER(A,B) A B;
#define GRID_MACRO_OS_WRITE_MEMBER(A,B) os<< #A <<" "#B <<" = "<< obj. B <<" ; " <<std::endl; #define GRID_MACRO_OS_WRITE_MEMBER(A,B) os<< #A <<" "#B <<" = "<< obj. B <<" ; " <<std::endl;
#define GRID_MACRO_READ_MEMBER(A,B) read(RD,#B,obj. B); #define GRID_MACRO_READ_MEMBER(A,B) Grid::read(RD,#B,obj. B);
#define GRID_MACRO_WRITE_MEMBER(A,B) write(WR,#B,obj. B); #define GRID_MACRO_WRITE_MEMBER(A,B) Grid::write(WR,#B,obj. B);
#define GRID_DECL_CLASS_MEMBERS(cname,...) \ #define GRID_DECL_CLASS_MEMBERS(cname,...) \
\ \
@ -120,14 +120,16 @@ THE SOFTWARE.
GRID_MACRO_EVAL(GRID_MACRO_MAP(GRID_MACRO_MEMBER,__VA_ARGS__)) \ GRID_MACRO_EVAL(GRID_MACRO_MAP(GRID_MACRO_MEMBER,__VA_ARGS__)) \
\ \
\ \
friend void write(Writer &WR,const std::string &s, const cname &obj){ \ template <typename T>\
static void write(Writer<T> &WR,const std::string &s, const cname &obj){ \
push(WR,s);\ push(WR,s);\
GRID_MACRO_EVAL(GRID_MACRO_MAP(GRID_MACRO_WRITE_MEMBER,__VA_ARGS__)) \ GRID_MACRO_EVAL(GRID_MACRO_MAP(GRID_MACRO_WRITE_MEMBER,__VA_ARGS__)) \
pop(WR);\ pop(WR);\
} \ } \
\ \
\ \
friend void read(Reader &RD,const std::string &s, cname &obj){ \ template <typename T>\
static void read(Reader<T> &RD,const std::string &s, cname &obj){ \
push(RD,s);\ push(RD,s);\
GRID_MACRO_EVAL(GRID_MACRO_MAP(GRID_MACRO_READ_MEMBER,__VA_ARGS__)) \ GRID_MACRO_EVAL(GRID_MACRO_MAP(GRID_MACRO_READ_MEMBER,__VA_ARGS__)) \
pop(RD);\ pop(RD);\

83
lib/serialisation/Serialisation.h
View File

@ -5,85 +5,6 @@
#include <serialisation/BaseIO.h> #include <serialisation/BaseIO.h>
#include <stdint.h> #include <stdint.h>
namespace Grid {
// Generic reader writer interface
inline void push(Writer & WR,const std::string &s) { WR.push(s);}
inline void push(Writer & WR,const char *s) { WR.push(std::string(s));}
inline void pop (Writer & WR) { WR.pop();}
// inline void write(Writer& wr, const std::string& s,const char * output ) { wr.write(s,std::string(output)); };
inline void write(Writer& wr, const std::string& s,const std::string &output) { wr.write(s,output); };
inline void write(Writer& wr, const std::string& s,const int16_t output ) { wr.write(s,output); };
inline void write(Writer& wr, const std::string& s,const uint16_t output ) { wr.write(s,output); };
inline void write(Writer& wr, const std::string& s,const int32_t output ) { wr.write(s,output); };
inline void write(Writer& wr, const std::string& s,const uint32_t output ) { wr.write(s,output); };
inline void write(Writer& wr, const std::string& s,const int64_t output ) { wr.write(s,output); };
inline void write(Writer& wr, const std::string& s,const uint64_t output ) { wr.write(s,output); };
inline void write(Writer& wr, const std::string& s,const float output ) { wr.write(s,output); };
inline void write(Writer& wr, const std::string& s,const double output ) { wr.write(s,output); };
inline void write(Writer& wr, const std::string& s,const bool output ) { wr.write(s,output); };
inline void push(Reader & WR,const std::string &s) { WR.push(s);}
inline void push(Reader & WR,const char *s) { WR.push(std::string(s));}
inline void pop (Reader & WR) { WR.pop();}
inline void read(Reader& rd, const std::string& s,std::string &output) { rd.read(s,output); };
inline void read(Reader& rd, const std::string& s, int16_t &output ) { rd.read(s,output); };
inline void read(Reader& rd, const std::string& s, uint16_t &output ) { rd.read(s,output); };
inline void read(Reader& rd, const std::string& s, int32_t &output ) { rd.read(s,output); };
inline void read(Reader& rd, const std::string& s, uint32_t &output ) { rd.read(s,output); };
inline void read(Reader& rd, const std::string& s, int64_t &output ) { rd.read(s,output); };
inline void read(Reader& rd, const std::string& s, uint64_t &output ) { rd.read(s,output); };
inline void read(Reader& rd, const std::string& s, float &output ) { rd.read(s,output); };
inline void read(Reader& rd, const std::string& s, double &output ) { rd.read(s,output); };
inline void read(Reader& rd, const std::string& s, bool &output ) { rd.read(s,output); };
template<class T> void write(Writer& wr, const std::string& s,const std::vector<T> output ) {
push(wr,s);
uint64_t sz =output.size();
write(wr,"N",sz);
for(int i=0;i<output.size();i++){
std::ostringstream oss; oss << "elem" << i;
write(wr,oss.str(),output[i]);
}
pop(wr);
};
template<class T>
void read(Reader& rd, const std::string& s,std::vector<T> &output ) {
push(rd,s);
uint64_t sz; read(rd,"N",sz);
// skip the vector length
T tmp;
output.resize(0);
for(int i=0;i<sz;i++){
std::ostringstream oss; oss << "elem" << i;
read(rd,oss.str(),tmp);
output.push_back(tmp);
}
pop(rd);
};
template < class T >
inline std::ostream& operator << (std::ostream& os, const std::vector<T>& v)
{
os << "[";
for (typename std::vector<T>::const_iterator ii = v.begin(); ii != v.end(); ++ii)
{
os << " " << *ii;
}
os << " ]";
return os;
}
}
////////////////////////////////////////// //////////////////////////////////////////
// Todo: // Todo:
////////////////////////////////////////// //////////////////////////////////////////
@ -97,7 +18,7 @@ namespace Grid {
// Select the default serialiser use ifdef's // Select the default serialiser use ifdef's
////////////////////////////////////////// //////////////////////////////////////////
namespace Grid { namespace Grid {
typedef XMLReader DefaultReader; typedef XmlReader DefaultReader;
typedef XMLWriter DefaultWriter; typedef XmlWriter DefaultWriter;
} }
#endif #endif

66
lib/serialisation/TextIO.cc Normal file
View File

@ -0,0 +1,66 @@
#include <Grid.h>
using namespace Grid;
using namespace std;
// Writer implementation ///////////////////////////////////////////////////////
TextWriter::TextWriter(const string &fileName)
: file_(fileName, ios::out)
{}
void TextWriter::push(const string &s)
{
level_++;
};
void TextWriter::pop(void)
{
level_--;
};
void TextWriter::indent(void)
{
for (int i = 0; i < level_; ++i)
{
file_ << '\t';
}
};
// Reader implementation ///////////////////////////////////////////////////////
TextReader::TextReader(const string &fileName)
: file_(fileName, ios::in)
{}
void TextReader::push(const string &s)
{
level_++;
};
void TextReader::pop(void)
{
level_--;
};
void TextReader::checkIndent(void)
{
char c;
for (int i = 0; i < level_; ++i)
{
file_.get(c);
if (c != '\t')
{
cerr << "mismatch on tab " << c << " level " << level_;
cerr << " i "<< i <<endl;
abort();
}
}
}
template <>
void TextReader::readDefault(const string &s, string &output)
{
checkIndent();
output.clear();
getline(file_, output);
}

198
lib/serialisation/TextIO.h
View File

@ -9,140 +9,88 @@
#include <vector> #include <vector>
#include <cassert> #include <cassert>
namespace Grid { namespace Grid
{
class TextWriter : public Writer {
private: class TextWriter: public Writer<TextWriter>
std::ofstream file;
int level;
void indent(void) {
for(int i=0;i<level;i++){
file <<"\t";
}
}
public:
TextWriter(const std::string &_file) : file(_file,std::ios::out) {
level=0;
}
~TextWriter() { }
void push(const std::string &s)
{ {
// std::string tmp = s; public:
// write(s,tmp); TextWriter(const std::string &fileName);
level++; virtual ~TextWriter(void) = default;
} void push(const std::string &s);
void pop(void) { void pop(void);
level--; template <typename U>
} void writeDefault(const std::string &s, const U &output);
template <typename U>
void write( const std::string& s,const std::string &output ) { void writeDefault(const std::string &s, const std::vector<U> &output);
indent(); private:
file<<output<<std::endl; void indent(void);
private:
std::ofstream file_;
int level_{0};
}; };
void write( const std::string& s,const int16_t output ) { writeInternal(s,output); };
void write( const std::string& s,const uint16_t output ) { writeInternal(s,output); }; class TextReader: public Reader<TextReader>
void write( const std::string& s,const int32_t output ) { writeInternal(s,output); }; {
void write( const std::string& s,const uint32_t output ) { writeInternal(s,output); }; public:
void write( const std::string& s,const int64_t output ) { writeInternal(s,output); }; TextReader(const std::string &fileName);
void write( const std::string& s,const uint64_t output ) { writeInternal(s,output); }; virtual ~TextReader(void) = default;
void write( const std::string& s,const float output ) { writeInternal(s,output); }; void push(const std::string &s);
void write( const std::string& s,const double output ) { writeInternal(s,output); }; void pop(void);
void write( const std::string& s,const bool output ) { writeInternal(s,output); }; template <typename U>
void readDefault(const std::string &s, U &output);
private: template <typename U>
void readDefault(const std::string &s, std::vector<U> &output);
template<class T> void writeInternal( const std::string& s,const T output ){ private:
void checkIndent(void);
private:
std::ifstream file_;
int level_{0};
};
// Writer template implementation ////////////////////////////////////////////
template <typename U>
void TextWriter::writeDefault(const std::string &s, const U &output)
{
indent(); indent();
file << std::boolalpha << output<<std::endl; file_ << std::boolalpha << output << std::endl;
} }
}; template <typename U>
void TextWriter::writeDefault(const std::string &s, const std::vector<U> &output)
class TextReader : public Reader { {
private: uint64_t sz = output.size();
std::ifstream file;
int level;
public:
TextReader(const std::string &_file) : file(_file,std::ios::in) { level = 0;};
~TextReader() { }
void read( const std::string& s,std::string &output ) {
char c='a';
for(int i=0;i<level;i++){
file.get(c);
if ( c != '\t' )
std::cout << "mismatch on tab "<<c<<" level "<< level<< " i "<< i<<std::endl;
}
output.clear();
std::getline(file,output);
};
void push(const std::string &s) {
// std::string tmp; read(s,tmp);
level++;
}
void pop(void) { level--; }
template<class T>
void read( const std::string& s, std::vector<T> &output ) {
push(s); write(s, sz);
for (uint64_t i = 0; i < sz; ++i)
uint64_t n; read("N",n); {
write(s, output[i]);
// skip the vector length
T tmp;
output.resize(0);
for(int i=0;i<n;i++){
std::ostringstream oss; oss << "elem" << i;
read(*this,oss.str(),tmp);
output.push_back(tmp);
} }
pop();
};
void read( const std::string& s, int16_t &output ) { readInternal(s,output); };
void read( const std::string& s, uint16_t &output ) { readInternal(s,output); };
void read( const std::string& s, int32_t &output ) { readInternal(s,output); };
void read( const std::string& s, uint32_t &output ) { readInternal(s,output); };
void read( const std::string& s, int64_t &output ) { readInternal(s,output); };
void read( const std::string& s, uint64_t &output ) { readInternal(s,output); };
void read( const std::string& s, float &output ) { readInternal(s,output); };
void read( const std::string& s, double &output ) { readInternal(s,output); };
void read( const std::string& s, bool &output ) { readInternal(s,output); };
private:
template<class T> void readInternal( const std::string& path, T &output ){
std::string asString;
read(path,asString);
convert(asString,output);
}
template<class T> void convert(const std::string &asString,T &output)
{
std::istringstream is(asString); is.exceptions(std::ios::failbit);
try {
is >> std::boolalpha >> output;
} catch(std::istringstream::failure e) {
std::cerr << "XML read failure on "<<" "<<asString<<" "<<typeid(T).name()<<std::endl;
}
assert( is.tellg()==-1);
} }
}; // Reader template implementation ////////////////////////////////////////////
template <typename U>
void TextReader::readDefault(const std::string &s, U &output)
{
std::string buf;
readDefault(s, buf);
fromString(output, buf);
}
template <typename U>
void TextReader::readDefault(const std::string &s, std::vector<U> &output)
{
uint64_t sz;
read("", sz);
output.resize(sz);
for (uint64_t i = 0; i < sz; ++i)
{
read("", output[i]);
}
}
} }
#endif #endif

59
lib/serialisation/XmlIO.cc Normal file
View File

@ -0,0 +1,59 @@
#include <Grid.h>
using namespace Grid;
using namespace std;
// Writer implementation ///////////////////////////////////////////////////////
XmlWriter::XmlWriter(const string &fileName)
: fileName_(fileName)
{
node_ = doc_.append_child();
node_.set_name("grid");
}
XmlWriter::~XmlWriter(void)
{
doc_.save_file(fileName_.c_str(), " ");
}
void XmlWriter::push(const string &s)
{
node_ = node_.append_child(s.c_str());
}
void XmlWriter::pop(void)
{
node_ = node_.parent();
}
// Reader implementation ///////////////////////////////////////////////////////
XmlReader::XmlReader(const string &fileName)
: fileName_(fileName)
{
pugi::xml_parse_result result = doc_.load_file(fileName_.c_str());
if ( !result )
{
cerr << "XML error description: " << result.description() << "\n";
cerr << "XML error offset : " << result.offset << "\n";
abort();
}
node_ = doc_.child("grid");
}
void XmlReader::push(const string &s)
{
node_ = node_.child(s.c_str());
}
void XmlReader::pop(void)
{
node_ = node_.parent();
}
template <>
void XmlReader::readDefault(const string &s, string &output)
{
output = node_.child(s.c_str()).first_child().value();
}

201
lib/serialisation/XmlIO.h
View File

@ -11,136 +11,93 @@
#include "pugixml/pugixml.h" #include "pugixml/pugixml.h"
namespace Grid
namespace Grid { {
class XMLWriter : public Writer { class XmlWriter: public Writer<XmlWriter>
private:
pugi::xml_document doc;
pugi::xml_node node;
std::string file;
public:
XMLWriter(const std::string &_file) : file(_file)
{ {
node=doc.append_child();
node.set_name("document"); public:
} XmlWriter(const std::string &fileName);
virtual ~XmlWriter(void);
~XMLWriter() void push(const std::string &s);
{ void pop(void);
// simple_walker walker; template <typename U>
// doc.traverse(walker); void writeDefault(const std::string &s, const U &x);
template <typename U>
doc.save_file(file.c_str()," "); void writeDefault(const std::string &s, const std::vector<U> &x);
} private:
pugi::xml_document doc_;
void push(const std::string &s) pugi::xml_node node_;
{ std::string fileName_;
node = node.append_child(s.c_str());
}
void pop(void) {
node = node.parent();
}
void write( const std::string& s,const std::string &output ) {
pugi::xml_node leaf=node.append_child(s.c_str());
leaf.append_child(pugi::node_pcdata).set_value(output.c_str());
}; };
void write( const std::string& s,const int16_t output ) { writeInternal(s,output); }; class XmlReader: public Reader<XmlReader>
void write( const std::string& s,const uint16_t output ) { writeInternal(s,output); }; {
void write( const std::string& s,const int32_t output ) { writeInternal(s,output); }; public:
void write( const std::string& s,const uint32_t output ) { writeInternal(s,output); }; XmlReader(const std::string &fileName);
void write( const std::string& s,const int64_t output ) { writeInternal(s,output); }; virtual ~XmlReader(void) = default;
void write( const std::string& s,const uint64_t output ) { writeInternal(s,output); }; void push(const std::string &s);
void write( const std::string& s,const float output ) { writeInternal(s,output); }; void pop(void);
void write( const std::string& s,const double output ) { writeInternal(s,output); }; template <typename U>
void write( const std::string& s,const bool output ) { writeInternal(s,output); }; void readDefault(const std::string &s, U &output);
template <typename U>
private: void readDefault(const std::string &s, std::vector<U> &output);
private:
template<class T> void writeInternal( const std::string& s,const T output ){ pugi::xml_document doc_;
pugi::xml_node node_;
std::string fileName_;
};
// Writer template implementation ////////////////////////////////////////////
template <typename U>
void XmlWriter::writeDefault(const std::string &s, const U &x)
{
std::ostringstream os; std::ostringstream os;
os << std::boolalpha << output;
write(s,os.str()); os << std::boolalpha << x;
pugi::xml_node leaf = node_.append_child(s.c_str());
leaf.append_child(pugi::node_pcdata).set_value(os.str().c_str());
} }
}; template <typename U>
void XmlWriter::writeDefault(const std::string &s, const std::vector<U> &x)
class XMLReader : public Reader {
private:
pugi::xml_document doc;
pugi::xml_node node;
public:
XMLReader(const std::string &_file)
{ {
pugi::xml_parse_result result = doc.load_file(_file.c_str()); push(s);
for (auto &x_i: x)
if ( !result ) { {
std::cout << "XML error description: " << result.description() << "\n"; write("elem", x_i);
std::cout << "XML error offset: " << result.offset << "\n";
} }
pop();
assert(result); }
// simple_walker walker; // Reader template implementation ////////////////////////////////////////////
// doc.traverse(walker); template <typename U>
void XmlReader::readDefault(const std::string &s, U &output)
node= doc.child("document"); {
} std::string buf;
~XMLReader() { } readDefault(s, buf);
fromString(output, buf);
void read( const std::string& s,std::string &output ) { }
output=node.child(s.c_str()).first_child().value();
}; template <typename U>
void push(const std::string &s) void XmlReader::readDefault(const std::string &s, std::vector<U> &output)
{ {
node = node.child(s.c_str()); pugi::xml_node nodeCpy;
} std::string buf;
void pop(void) { unsigned int i = 0;
node = node.parent();
} push(s);
while (node_.child("elem"))
void read( const std::string& s, int16_t &output ) { readInternal(s,output); }; {
void read( const std::string& s, uint16_t &output ) { readInternal(s,output); }; output.resize(i + 1);
void read( const std::string& s, int32_t &output ) { readInternal(s,output); }; read("elem", output[i]);
void read( const std::string& s, uint32_t &output ) { readInternal(s,output); }; node_.child("elem").set_name("elem-done");
void read( const std::string& s, int64_t &output ) { readInternal(s,output); }; i++;
void read( const std::string& s, uint64_t &output ) { readInternal(s,output); }; }
void read( const std::string& s, float &output ) { readInternal(s,output); }; pop();
void read( const std::string& s, double &output ) { readInternal(s,output); };
void read( const std::string& s, bool &output ) { readInternal(s,output); };
private:
template<class T> void readInternal( const std::string& path, T &output ){
std::string asString;
read(path,asString);
convert(asString,output);
}
template<class T> void convert(const std::string &asString,T &output)
{
std::istringstream is(asString); is.exceptions(std::ios::failbit);
try {
is >> std::boolalpha >> output;
} catch(std::istringstream::failure e) {
std::cerr << "XML read failure on "<<" "<<asString<<" "<<typeid(T).name()<<std::endl;
}
assert( is.tellg()==-1);
} }
};
} }
#endif #endif

4
tests/Make.inc
View File

@ -98,8 +98,8 @@ Test_gparity_SOURCES=Test_gparity.cc
Test_gparity_LDADD=-lGrid Test_gparity_LDADD=-lGrid
Test_gpwilson_even_odd_SOURCES=Test_gpwilson_even_odd.cc #Test_gpwilson_even_odd_SOURCES=Test_gpwilson_even_odd.cc
Test_gpwilson_even_odd_LDADD=-lGrid #Test_gpwilson_even_odd_LDADD=-lGrid
Test_hmc_EODWFRatio_SOURCES=Test_hmc_EODWFRatio.cc Test_hmc_EODWFRatio_SOURCES=Test_hmc_EODWFRatio.cc

108
tests/Test_serialisation.cc
View File

@ -1,36 +1,35 @@
#include <Grid.h> #include <Grid.h>
namespace Grid { namespace Grid {
class myclass: Serializable {
class myclass { public:
public:
GRID_DECL_CLASS_MEMBERS(myclass,
GRID_DECL_CLASS_MEMBERS(myclass, int, x,
int, x, double, y,
double, y, bool , b,
bool , b, std::string, name,
std::string, name, std::vector<double>, array,
std::vector<double>, array, std::vector<std::vector<double>>, twodimarray,
std::vector<std::vector<double> >, twodimarray, );
);
myclass() {}
myclass(){} myclass(int i)
myclass(int i) : array(4,5.1), twodimarray(3,std::vector<double>(2,1.23456)) { : array(4,5.1), twodimarray(3,std::vector<double>(2,1.23456))
x=i; {
y=2*i; x=i;
b=true; y=2*i;
name="bother said pooh"; b=true;
} name="bother said pooh";
}
}; };
} }
int16_t i16 = 1; int16_t i16 = 1;
uint16_t u16 = 2; uint16_t u16 = 2;
int32_t i32 = 3; int32_t i32 = 3;
uint32_t u32 = 4; uint32_t u32 = 4;
int64_t i64 = 5; int64_t i64 = 5;
uint64_t u64 = 6; uint64_t u64 = 6;
float f = M_PI; float f = M_PI;
double d = 2*M_PI; double d = 2*M_PI;
@ -41,8 +40,9 @@ using namespace Grid;
int main(int argc,char **argv) int main(int argc,char **argv)
{ {
{ {
XMLWriter WR("bother.xml"); XmlWriter WR("bother.xml");
// test basic type writing
push(WR,"BasicTypes"); push(WR,"BasicTypes");
write(WR,std::string("i16"),i16); write(WR,std::string("i16"),i16);
write(WR,"u16",u16); write(WR,"u16",u16);
@ -54,40 +54,54 @@ int main(int argc,char **argv)
write(WR,"d",d); write(WR,"d",d);
write(WR,"b",b); write(WR,"b",b);
pop(WR); pop(WR);
// test serializable class writing
myclass obj(1234); // non-trivial constructor myclass obj(1234); // non-trivial constructor
write(WR,"obj",obj); write(WR,"obj",obj);
WR.write("obj2", obj);
std::vector<myclass> vec;
vec.push_back(myclass(1234));
vec.push_back(myclass(5678));
vec.push_back(myclass(3838));
write(WR, "objvec", vec);
}; };
XMLReader RD("bother.xml"); // read tests
myclass copy1, copy2, copy3;
myclass copy1; std::vector<myclass> veccopy1, veccopy2, veccopy3;
myclass copy2; //// XML
myclass copy3; {
XmlReader RD("bother.xml");
read(RD,"obj",copy1); read(RD,"obj",copy1);
std::cout << "Loaded " << copy1<<std::endl; read(RD,"objvec", veccopy1);
std::cout << "Loaded (XML) -----------------" << std::endl;
std::cout << copy1 << std::endl << veccopy1 << std::endl;
}
//// binary
{ {
BinaryWriter BWR("bother.bin"); BinaryWriter BWR("bother.bin");
write(BWR,"discard",copy1 ); write(BWR,"discard",copy1 );
write(BWR,"discard",veccopy1 );
} }
{ {
BinaryReader BRD("bother.bin"); BinaryReader BRD("bother.bin");
read (BRD,"discard",copy2 ); read (BRD,"discard",copy2 );
std::cout<<copy2<<std::endl; read (BRD,"discard",veccopy2 );
std::cout << "Loaded (bin) -----------------" << std::endl;
std::cout << copy2 << std::endl << veccopy2 << std::endl;
} }
//// text
{ {
TextWriter TWR("bother.txt"); TextWriter TWR("bother.txt");
write(TWR,"discard",copy1 ); write(TWR,"discard",copy1 );
write(TWR,"discard",veccopy1 );
} }
{ {
TextReader TRD("bother.txt"); TextReader TRD("bother.txt");
read (TRD,"discard",copy3 ); read (TRD,"discard",copy3 );
std::cout<<copy3<<std::endl; read (TRD,"discard",veccopy3 );
std::cout << "Loaded (txt) -----------------" << std::endl;
std::cout << copy3 << std::endl << veccopy3 << std::endl;
} }
} }