matfile/matfile_concepts/src/Writers/ArrayDenseWrapper.hh

Go to the documentation of this file.

/*
    This file is part of matfile.

    Copyright (C) 2010-2011 Andrea Arteaga <arteagaa@student.ethz.ch>

    matfile is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published
    by the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    matfile is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with matfile.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef ARRAYDENSEWRAPPERWRITER_hh_
#define ARRAYDENSEWRAPPERWRITER_hh_

template<class WrapperClass> class Writer<WrapperClass, ArrayDenseWrapper>
{
public:
  static void write(std::ostream& out, const std::string& name, const WrapperClass& wrapper)
  {
    int beginpos = out.tellp();

    // Parameters
      bool isComplex = wrapper.isComplex();
      miINT32_t rows, cols;
      wrapper.size(rows, cols);
      const MATtype realType = wrapper.realType();
      const MATtype imagType = wrapper.imagType();
      const miINT32_t realScalarSize = typeSize(realType);
      const miINT32_t imagScalarSize = typeSize(imagType);
       
    // Write tag
    miINT32_t tag[2];
    tag[0] = miMATRIX;
    tag[1] = 0;
    out.write(reinterpret_cast<char*>(tag), 8);

    // Write flags
    miINT32_t flagstag[2];
    flagstag[0] = miUINT32;
    flagstag[1] = 8;
    miUINT32_t flags[2];
    flags[0] = mxDOUBLE_CLASS;
    flags[0] += 2048 * isComplex;
    out.write(reinterpret_cast<char*>(flagstag), 8).write(reinterpret_cast<char*>(flags), 8);

    // Write dimensions
    miINT32_t dimensions[4];
    dimensions[0] = miINT32;
    dimensions[1] = 8;
    dimensions[2] = rows;
    dimensions[3] = cols;
    out.write(reinterpret_cast<char*>(dimensions), 16);

    // Write name
    miINT32_t nametag[2];
    nametag[0] = miINT8;
    nametag[1] = name.size();
    out.write(reinterpret_cast<char*>(nametag), 8).write(name.data(), name.size());
    for (miINT32_t i = name.size(); i % 8 != 0; ++i)
      out.put(' ');
        

    // Write real part
    
    
    miINT32_t realtag[2];
    realtag[0] = wrapper.realType();
    realtag[1] = realScalarSize * rows * cols;
    out.write(reinterpret_cast<char*>(realtag), 8);
    
    //Einen Versuch ist es Wert.
        for (miINT32_t c = 0; c < cols; ++c)
          for (miINT32_t r = 0; r < rows; ++r){
          out.write(reinterpret_cast<const char*>(wrapper.realData(r,c)), realScalarSize);
        } 
    //.. endet der Versuch hier
    
    //out.write(wrapper.realData(), realtag[1]);
    for (miINT32_t i = realtag[1]; i % 8 != 0; ++i)
      out.put(' ');
    

    // Write imaginary part
    if (isComplex) {
      miINT32_t imagtag[2];
      imagtag[0] = wrapper.imagType();
      imagtag[1] = imagScalarSize * rows*cols;
      out.write(reinterpret_cast<char*>(imagtag), 8);
      //
      for (miINT32_t c = 0; c < cols; ++c)
        for (miINT32_t r = 0; r < rows; ++r){
          out.write(reinterpret_cast<const char*>((wrapper.complexData(r,c))) , realScalarSize);
        } 
      
       //.. endet der Versuch hier
       
       
            
      //out.write(wrapper.imagData(), imagtag[1]);
      for (miINT32_t i = imagtag[1]; i % 8 != 0; ++i)
        out.put(' ');
    }
    
    
    // Seek back and write size
    int endpos = out.tellp();
    out.seekp(beginpos+4);
    miINT32_t size = endpos-beginpos-8;
    out.write(reinterpret_cast<char*>(&size), 4);
    out.seekp(endpos);
    

  }
};

#endif /* ARRAYDENSEWRAPPERWRITER_HH_ */