Pure virtual base class for various output writers. More...

#include <Writer.h>

Inheritance diagram for YODA::Writer:

Public Member Functions
virtual	~Writer ()
	Virtual destructor.

void	setPrecision (int precision)
	Set precision of numerical quantities in this writer's output.

void	setAOPrecision (const bool needsDP=false)
	Set precision of numerical quantities for current AO in this writer's output.

void	useCompression (const bool compress=true)
	Use libz compression?

Writing a single analysis object.
void	write (const std::string &filename, const AnalysisObject &ao)
	Write out object ao to file filename.

void	write (std::ostream &stream, const AnalysisObject &ao)
	Write out object ao to output stream stream.

template<typename T >
std::enable_if_t< DerefableToAO< T >::value >	write (std::ostream &stream, const T &ao)
	Write out pointer-like object ao to output stream stream.

template<typename T >
std::enable_if_t< DerefableToAO< T >::value >	write (const std::string &filename, const T &ao)
	Write out pointer-like object ao to file filename.

Writing multiple analysis objects by collection.
void	write (YODA_H5::File &file, const std::vector< const AnalysisObject * > &aos)

void	write (std::ostream &stream, const std::vector< const AnalysisObject * > &aos, int precision=-1)

template<typename RANGE >
std::enable_if_t< CIterable< RANGE >::value >	write (std::ostream &stream, const RANGE &aos)

template<typename RANGE >
std::enable_if_t< CIterable< RANGE >::value >	write (const std::string &filename, const RANGE &aos)
	Write out a collection of objects objs to file filename.

Writing multiple analysis objects by iterator range.
template<typename AOITER >
void	write (std::ostream &stream, const AOITER &begin, const AOITER &end, int precision=-1)

template<typename AOITER >
void	write (const std::string &filename, const AOITER &begin, const AOITER &end)

Protected Member Functions
Main writer elements
virtual void	writeHead (std::ostream &)
	Write any opening boilerplate required by the format to stream.

virtual void	writeBody (std::ostream &stream, const AnalysisObject *ao)
	Write the body elements corresponding to AnalysisObject ao to stream.

virtual void	writeBody (std::ostream &stream, const AnalysisObject &ao)
	Write the body elements corresponding to AnalysisObject pointer ao to stream.

template<typename T >
std::enable_if_t< DerefableToAO< T >::value >	writeBody (std::ostream &stream, const T &ao)
	Write the body elements corresponding to AnalysisObject ao to stream.

virtual void	writeFoot (std::ostream &stream)
	Write any closing boilerplate required by the format to stream.

Specific AO type writer implementations, to be implemented in derived classes
virtual void	writeAO (std::ostream &stream, const AnalysisObject &ao)=0

virtual void	writeAOS (YODA_H5::File &file, const vector< const AnalysisObject * > &aos)=0

Detailed Description

Pure virtual base class for various output writers.

Definition at line 31 of file Writer.h.

Constructor & Destructor Documentation

◆ ~Writer()

virtual YODA::Writer::~Writer ( )

inlinevirtual

Virtual destructor.

Definition at line 35 of file Writer.h.

35{}

Member Function Documentation

◆ setAOPrecision()

void YODA::Writer::setAOPrecision ( const bool needsDP = false )

inline

Set precision of numerical quantities for current AO in this writer's output.

Definition at line 181 of file Writer.h.

                                                    {
      if (needsDP)             _aoprecision = std::numeric_limits<double>::max_digits10;
      else if (_precision > 0) _aoprecision = _precision;
      else                     _aoprecision = 6;
    }

Referenced by write().

◆ setPrecision()

void YODA::Writer::setPrecision ( int precision )

inline

Set precision of numerical quantities in this writer's output.

Definition at line 176 of file Writer.h.

                                     {
      _precision = precision;
    }

Referenced by YODA::WriterFLAT::create(), YODA::WriterH5::create(), YODA::WriterYODA::create(), YODA::WriterYODA1::create(), YODA::write(), YODA::write(), YODA::write(), YODA::write(), YODA::write(), YODA::write(), and write().

◆ useCompression()

void YODA::Writer::useCompression ( const bool compress = true )

inline

Use libz compression?

Definition at line 188 of file Writer.h.

                                                  {
      _compress = compress;
    }

Referenced by YODA::mkWriter(), and write().

◆ write() [1/10]

void YODA::Writer::write	(	const std::string &	filename,
		const AnalysisObject &	ao
	)

Write out object ao to file filename.

Definition at line 56 of file Writer.cc.

                                                                        {
    std::vector<const AnalysisObject*> vec{&ao};
    write(filename, vec);
  }

References write().

Referenced by write(), YODA::write(), write(), YODA::write(), write(), YODA::write(), write(), YODA::write(), YODA::write(), YODA::write(), write(), write(), write(), and write().

◆ write() [2/10]

template<typename AOITER >

void YODA::Writer::write	(	const std::string &	filename,
		const AOITER &	begin,
		const AOITER &	end
	)

inline

Write out the objects specified by start iterator begin and end iterator end to file filename.

Todo:: Add SFINAE trait checking for AOITER = DerefableToAO

Definition at line 130 of file Writer.h.

                                                                                  {
      std::vector<const AnalysisObject*> vec;
      // vec.reserve(std::distance(begin, end));
      for (AOITER ipao = begin; ipao != end; ++ipao)  vec.push_back(&(**ipao));
 
      if (filename != "-") {
        try {
          const size_t lastdot = filename.find_last_of(".");
          std::string fmt = Utils::toLower(lastdot == std::string::npos ? filename : filename.substr(lastdot+1));
          const bool compress = (fmt == "gz") || (fmt == "h5" && enableH5compression);
          useCompression(compress);
          #ifdef HAVE_HDF5
          // check if the requested format is H5
          if (Utils::startswith(fmt, "h5")) {
            try {
              YODA_H5::File h5(filename, YODA_H5::File::OpenOrCreate | YODA_H5::File::Truncate);
              write(h5, vec);
            } catch(...) {
              throw WriteError("Failed to open HDF5 file " + filename);
            }
            return;
          }
          #endif
          // try writing to stream
          std::ofstream stream;
          stream.exceptions(std::ofstream::failbit | std::ofstream::badbit);
          stream.open(filename.c_str());
          if (stream.fail())
            throw WriteError("Writing to filename " + filename + " failed");
          write(stream, vec);
        } catch (std::ofstream::failure& e) {
          throw WriteError("Writing to filename " + filename + " failed: " + e.what());
        }
      } else {
        try {
          write(std::cout, vec);
        } catch (std::runtime_error& e) {
          throw WriteError("Writing to stdout failed: " + std::string(e.what()));
        }
      }
 
    }

References YODA::enableH5compression, useCompression(), and write().

◆ write() [3/10]

template<typename RANGE >

std::enable_if_t< CIterable< RANGE >::value > YODA::Writer::write	(	const std::string &	filename,
		const RANGE &	aos
	)

inline

Write out a collection of objects objs to file filename.

Definition at line 102 of file Writer.h.

                                                       {
      write(filename, std::begin(aos), std::end(aos));
    }

References write().

◆ write() [4/10]

template<typename T >

std::enable_if_t< DerefableToAO< T >::value > YODA::Writer::write	(	const std::string &	filename,
		const T &	ao
	)

inline

Write out pointer-like object ao to file filename.

Definition at line 60 of file Writer.h.

                                                  {
      write(filename, *ao);
    }

References write().

◆ write() [5/10]

void YODA::Writer::write	(	std::ostream &	stream,
		const AnalysisObject &	ao
	)

inline

Write out object ao to output stream stream.

Definition at line 45 of file Writer.h.

                                                             {
      std::vector<const AnalysisObject*> vec{&ao};
      write(stream, vec);
    }

References write().

◆ write() [6/10]

template<typename AOITER >

void YODA::Writer::write	(	std::ostream &	stream,
		const AOITER &	begin,
		const AOITER &	end,
		int	precision = `-1`
	)

inline

Write out the objects specified by start iterator begin and end iterator end to output stream stream.

Todo:: Add SFINAE trait checking for AOITER = DerefableToAO

Definition at line 117 of file Writer.h.

                                                                                               {
      std::vector<const AnalysisObject*> vec;
      // vec.reserve(std::distance(begin, end));
      for (AOITER ipao = begin; ipao != end; ++ipao)  vec.push_back(&(**ipao));
      write(stream, vec, precision);
    }

References write().

◆ write() [7/10]

template<typename RANGE >

std::enable_if_t< CIterable< RANGE >::value > YODA::Writer::write	(	std::ostream &	stream,
		const RANGE &	aos
	)

inline

Write out a collection of objects objs to output stream stream.

Note: The enable_if call checks whether RANGE is const_iterable, if yes the return type is void. If not, this template will not be a candidate in the lookup

Definition at line 95 of file Writer.h.

                                                {
      write(stream, std::begin(aos), std::end(aos));
    }

References write().

◆ write() [8/10]

void YODA::Writer::write	(	std::ostream &	stream,
		const std::vector< const AnalysisObject * > &	aos,
		int	precision = `-1`
	)

Write out a vector of AO pointers (untemplated=exact type-match) to the given stream

Note: This is the canonical function for implementing AO writing to stream: all others call this.; Among other reasons, this is non-inline to hide zstr from the public API

Todo:: Remove the head/body/foot distinction?

Definition at line 69 of file Writer.cc.

                                                                                             {
    std::unique_ptr<std::ostream> zos;
    std::ostream* os = &stream;
 
    setPrecision(precision);
 
    // Write numbers in the "C" locale
    std::locale prev_locale = os->getloc();
    os->imbue(std::locale::classic());
 
    // Wrap the stream if needed
    if (_compress) {
      #ifdef HAVE_LIBZ
      // Doesn't work to always create zstr wrapper: have to only create if compressing :-/
      // zstr::ostream zstream(stream);
      // ostream& os = _compress ? zstream : stream;
      os = new zstr::ostream(stream);
      zos.reset(os);
      #else
      throw UserError("YODA was compiled without zlib support: can't write to a compressed stream");
      #endif
    }
 
    // Write the data components
    writeHead(*os);
    bool first = true;
    for (const AnalysisObject* aoptr : aos) {
      setAOPrecision( aoptr->annotation("WriterDoublePrecision", 0) );
      if (!first) *os << "\n"; //< blank line between items
      writeBody(*os, aoptr);
      first = false;
    }
    writeFoot(*os);
    *os << flush;
 
    os->imbue(prev_locale);
  }

References setAOPrecision(), setPrecision(), writeBody(), writeFoot(), and writeHead().

◆ write() [9/10]

template<typename T >

std::enable_if_t< DerefableToAO< T >::value > YODA::Writer::write	(	std::ostream &	stream,
		const T &	ao
	)

inline

Write out pointer-like object ao to output stream stream.

Definition at line 53 of file Writer.h.

                                           {
      write(stream, *ao);
    }

References write().

◆ write() [10/10]

void YODA::Writer::write	(	YODA_H5::File &	file,
		const std::vector< const AnalysisObject * > &	aos
	)

Write out a vector of AO pointers (untemplated=exact type-match) to the given stream

Note: This is the canonical function for implementing AO writing to H5: all others call this.; Among other reasons, this is non-inline to hide zstr from the public API

Definition at line 63 of file Writer.cc.

                                                                                   {
    writeAOS(file, aos);
  }

References writeAOS().

◆ writeAO()

virtual void YODA::Writer::writeAO	(	std::ostream &	stream,
		const AnalysisObject &	ao
	)

protectedpure virtual

Implemented in YODA::WriterFLAT, YODA::WriterYODA, and YODA::WriterYODA1.

Referenced by writeBody().

◆ writeAOS()

virtual void YODA::Writer::writeAOS	(	YODA_H5::File &	file,
		const vector< const AnalysisObject * > &	aos
	)

protectedpure virtual

Implemented in YODA::WriterH5.

Referenced by write().

◆ writeBody() [1/3]

void YODA::Writer::writeBody	(	std::ostream &	stream,
		const AnalysisObject &	ao
	)

protectedvirtual

Write the body elements corresponding to AnalysisObject pointer ao to stream.

Definition at line 114 of file Writer.cc.

                                                                  {
    try {
      writeAO(stream, ao);
    }
    catch(...) {
      ostringstream oss;
      oss << "Unrecognised analysis object type " << ao.type() << " in Writer::write";
      throw Exception(oss.str());
    }
  }

References YODA::AnalysisObject::type(), and writeAO().

◆ writeBody() [2/3]

void YODA::Writer::writeBody	(	std::ostream &	stream,
		const AnalysisObject *	ao
	)

protectedvirtual

Write the body elements corresponding to AnalysisObject ao to stream.

Definition at line 109 of file Writer.cc.

                                                                  {
    if (!ao) throw WriteError("Attempting to write a null AnalysisObject*");
    writeBody(stream, *ao);
  }

References writeBody().

Referenced by write(), and writeBody().

◆ writeBody() [3/3]

template<typename T >

std::enable_if_t< DerefableToAO< T >::value > YODA::Writer::writeBody	(	std::ostream &	stream,
		const T &	ao
	)

inlineprotected

Write the body elements corresponding to AnalysisObject ao to stream.

Note: Requires that ao is dereferenceable to an AnalysisObject, via the DerefableToAO<T> trait,

Definition at line 211 of file Writer.h.

211{ writeBody(stream, *ao); }

References writeBody().

Referenced by writeBody().

◆ writeFoot()

virtual void YODA::Writer::writeFoot ( std::ostream & stream )

inlineprotectedvirtual

Write any closing boilerplate required by the format to stream.

Definition at line 214 of file Writer.h.

214{ stream << std::flush; }

Referenced by write().

◆ writeHead()

virtual void YODA::Writer::writeHead ( std::ostream & )

inlineprotectedvirtual

Write any opening boilerplate required by the format to stream.

Definition at line 199 of file Writer.h.

199{}

Referenced by write().

The documentation for this class was generated from the following files:

include/YODA/Writer.h
src/Writer.cc

Public Member Functions

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ ~Writer()

Member Function Documentation

◆ setAOPrecision()

◆ setPrecision()

◆ useCompression()

◆ write() [1/10]

◆ write() [2/10]

◆ write() [3/10]

◆ write() [4/10]

◆ write() [5/10]

◆ write() [6/10]

◆ write() [7/10]

◆ write() [8/10]

◆ write() [9/10]

◆ write() [10/10]

◆ writeAO()

◆ writeAOS()

◆ writeBody() [1/3]

◆ writeBody() [2/3]

◆ writeBody() [3/3]

◆ writeFoot()

◆ writeHead()