dataarraywriter.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
 
#ifndef DUNE_GRID_IO_FILE_VTK_DATAARRAYWRITER_HH
#define DUNE_GRID_IO_FILE_VTK_DATAARRAYWRITER_HH
 
#include <ostream>
#include <string>
 
#include <dune/common/exceptions.hh>
#include <dune/common/indent.hh>
 
#include <dune/grid/io/file/vtk/streams.hh>
#include <dune/grid/io/file/vtk/common.hh>
 
namespace Dune
{
 
  namespace VTK {
 
 
    template<class T>
    class DataArrayWriter
    {
    public:
      virtual void write (T data) = 0;
      virtual bool writeIsNoop() const { return false; }
      virtual ~DataArrayWriter () {}
    };
 
    template<class T>
    class AsciiDataArrayWriter : public DataArrayWriter<T>
    {
    public:
 
      AsciiDataArrayWriter(std::ostream& theStream, std::string name,
                           int ncomps, const Indent& indent_)
        : s(theStream), counter(0), numPerLine(12), indent(indent_)
      {
        TypeName<T> tn;
        s << indent << "<DataArray type=\"" << tn() << "\" "
          << "Name=\"" << name << "\" ";
        s << "NumberOfComponents=\"" << ncomps << "\" ";
        s << "format=\"ascii\">\n";
        ++indent;
      }
 
      void write (T data)
      {
        typedef typename PrintType<T>::Type PT;
        if(counter%numPerLine==0) s << indent;
        else s << " ";
        s << (PT) data;
        counter++;
        if (counter%numPerLine==0) s << "\n";
      }
 
      ~AsciiDataArrayWriter ()
      {
        if (counter%numPerLine!=0) s << "\n";
        --indent;
        s << indent << "</DataArray>\n";
      }
 
    private:
      std::ostream& s;
      int counter;
      int numPerLine;
      Indent indent;
    };
 
    template<class T>
    class BinaryDataArrayWriter : public DataArrayWriter<T>
    {
    public:
 
      BinaryDataArrayWriter(std::ostream& theStream, std::string name,
                            int ncomps, int nitems, const Indent& indent_)
        : s(theStream), b64(theStream), indent(indent_)
      {
        TypeName<T> tn;
        s << indent << "<DataArray type=\"" << tn() << "\" "
          << "Name=\"" << name << "\" ";
        s << "NumberOfComponents=\"" << ncomps << "\" ";
        s << "format=\"binary\">\n";
 
        // write indentation for the data chunk
        s << indent+1;
        // store size
        unsigned long int size = ncomps*nitems*sizeof(T);
        b64.write(size);
        b64.flush();
      }
 
      void write (T data)
      {
        b64.write(data);
      }
 
      ~BinaryDataArrayWriter ()
      {
        b64.flush();
        // append newline to written data
        s << "\n";
        s << indent << "</DataArray>\n";
        s.flush();
      }
 
    private:
      std::ostream& s;
      Base64Stream b64;
      const Indent& indent;
    };
 
    template<class T>
    class AppendedRawDataArrayWriter : public DataArrayWriter<T>
    {
    public:
 
      AppendedRawDataArrayWriter(std::ostream& s, std::string name,
                                 int ncomps, unsigned nitems, unsigned& offset,
                                 const Indent& indent)
      {
        TypeName<T> tn;
        s << indent << "<DataArray type=\"" << tn() << "\" "
          << "Name=\"" << name << "\" ";
        s << "NumberOfComponents=\"" << ncomps << "\" ";
        s << "format=\"appended\" offset=\""<< offset << "\" />\n";
        offset += 4; // header
        offset += ncomps*nitems*sizeof(T);
      }
 
      void write (T data) { }
 
      bool writeIsNoop() const { return true; }
    };
 
    template<class T>
    class AppendedBase64DataArrayWriter : public DataArrayWriter<T>
    {
    public:
 
      AppendedBase64DataArrayWriter(std::ostream& s, std::string name,
                                    int ncomps, unsigned nitems,
                                    unsigned& offset, const Indent& indent)
      {
        TypeName<T> tn;
        s << indent << "<DataArray type=\"" << tn() << "\" "
          << "Name=\"" << name << "\" ";
        s << "NumberOfComponents=\"" << ncomps << "\" ";
        s << "format=\"appended\" offset=\""<< offset << "\" />\n";
        offset += 8; // header
        unsigned bytes = ncomps*nitems*sizeof(T);
        offset += bytes/3*4;
        if(bytes%3 != 0)
          offset += 4;
      }
 
      void write (T data) { }
 
      bool writeIsNoop() const { return true; }
    };
 
    //
    //  Naked ArrayWriters for the appended section
    //
 
    template<class T>
    class NakedBase64DataArrayWriter : public DataArrayWriter<T>
    {
    public:
 
      NakedBase64DataArrayWriter(std::ostream& theStream, int ncomps,
                                 int nitems)
        : b64(theStream)
      {
        // store size
        unsigned long int size = ncomps*nitems*sizeof(T);
        b64.write(size);
        b64.flush();
      }
 
      void write (T data)
      {
        b64.write(data);
      }
 
    private:
      Base64Stream b64;
    };
 
    template<class T>
    class NakedRawDataArrayWriter : public DataArrayWriter<T>
    {
      RawStream s;
 
    public:
 
      NakedRawDataArrayWriter(std::ostream& theStream, int ncomps,
                              int nitems)
        : s(theStream)
      {
        s.write((unsigned int)(ncomps*nitems*sizeof(T)));
      }
 
      void write (T data)
      {
        s.write(data);
      }
    };
 
    //
    //  Factory
    //
 
 
    class DataArrayWriterFactory {
      enum Phase { main, appended };
 
      OutputType type;
      std::ostream& stream;
      unsigned offset;
      Phase phase;
 
    public:
 
      inline DataArrayWriterFactory(OutputType type_, std::ostream& stream_)
        : type(type_), stream(stream_), offset(0), phase(main)
      { }
 
 
      inline bool beginAppended() {
        phase = appended;
        switch(type) {
        case ascii :          return false;
        case base64 :         return false;
        case appendedraw :    return true;
        case appendedbase64 : return true;
        }
        DUNE_THROW(IOError, "Dune::VTK::DataArrayWriter: unsupported "
                   "OutputType " << type);
      }
 
      const std::string& appendedEncoding() const {
        static const std::string rawString = "raw";
        static const std::string base64String = "base64";
 
        switch(type) {
        case ascii :
        case base64 :
          DUNE_THROW(IOError, "DataArrayWriterFactory::appendedEncoding(): No "
                     "appended encoding for OutputType " << type);
        case appendedraw :    return rawString;
        case appendedbase64 : return base64String;
        }
        DUNE_THROW(IOError, "DataArrayWriterFactory::appendedEncoding(): "
                   "unsupported OutputType " << type);
      }
 
 
      template<typename T>
      DataArrayWriter<T>* make(const std::string& name, unsigned ncomps,
                               unsigned nitems, const Indent& indent) {
        switch(phase) {
        case main :
          switch(type) {
          case ascii :
            return new AsciiDataArrayWriter<T>(stream, name, ncomps, indent);
          case base64 :
            return new BinaryDataArrayWriter<T>(stream, name, ncomps, nitems,
                                                indent);
          case appendedraw :
            return new AppendedRawDataArrayWriter<T>(stream, name, ncomps,
                                                     nitems, offset, indent);
          case appendedbase64 :
            return new AppendedBase64DataArrayWriter<T>(stream, name, ncomps,
                                                        nitems, offset,
                                                        indent);
          }
          break;
        case appended :
          switch(type) {
          case ascii :
          case base64 :
            break; // invlid in appended mode
          case appendedraw :
            return new NakedRawDataArrayWriter<T>(stream, ncomps, nitems);
          case appendedbase64 :
            return new NakedBase64DataArrayWriter<T>(stream, ncomps, nitems);
          }
          break;
        }
        DUNE_THROW(IOError, "Dune::VTK::DataArrayWriter: unsupported "
                   "OutputType " << type << " in phase " << phase);
      }
    };
 
  } // namespace VTK
 
 
} // namespace Dune
 
#endif // DUNE_GRID_IO_FILE_VTK_DATAARRAYWRITER_HH