matfile/matfile_concepts/src/Readers/ArraySparseWrapper.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 ARRAYSPARSEWRAPPERREADER_HPP_
#define ARRAYSPARSEWRAPPERREADER_HPP_

template<class Wrapper>
class Reader<Wrapper, ArraySparseWrapper>
{

public:
  static void read(std::string& in, Wrapper& wrapper) {
    std::string uncompressed;
    char *p;
    miINT32_t *tag = reinterpret_cast<miINT32_t*>(&in[0]);

    if (*tag == miCOMPRESSED) {
      // Call zlib
      z_stream strm;
      strm.zalloc = Z_NULL;
      strm.zfree = Z_NULL;
      strm.opaque = Z_NULL;
      strm.avail_in = 0;
      strm.next_in = Z_NULL;
      inflateInit(&strm); //TODO: control return value

      miINT32_t matrixtag[2];
      strm.next_in = reinterpret_cast<Bytef*>(&in[8]);
      strm.avail_in = *(tag+1);
      strm.next_out = reinterpret_cast<Bytef*>(matrixtag);
      strm.avail_out = 8;
      inflate(&strm, Z_NO_FLUSH); //TODO: control return value

      //TODO: control matrixtag[0]
      uncompressed.reserve(matrixtag[1]);
      strm.next_out = reinterpret_cast<Bytef*>(&uncompressed[0]);
      strm.avail_out = matrixtag[1];
      inflate(&strm, Z_NO_FLUSH);

      p = &uncompressed[0];
    } else {
      p = &in[8];
    }

    // Flags
    const miUINT32_t *flags = reinterpret_cast<miUINT32_t*>(p+8);
    bool isComplex = ((*flags & 2048) != 0);
    wrapper.isComplex(isComplex);
    miUINT32_t nnz = *(flags+1);
    wrapper.nnz(nnz);
    p += 16;

    // Size
    miINT32_t *size = reinterpret_cast<miINT32_t*>(p);
    miINT32_t sizeLength = *(size+1);
    //TODO: control that matrix is two-dimensional
    miINT32_t rows = *(size+2);
    miINT32_t cols = *(size+3);
    wrapper.size(rows, cols);
    p += 8 + (sizeLength+7)/8*8;

    // Name
    //TODO: short tags
    miINT32_t *nameTag = reinterpret_cast<miINT32_t*>(p);
    miINT32_t nameLength = *(nameTag+1);
    std::string name(p+8, nameLength);
    wrapper.name(name);
    p += 8 + (nameLength+7)/8*8;

    // ir
    miINT32_t *ir = reinterpret_cast<miINT32_t*>(p+8);
    //TODO: control irLength == 4*nnz
    memcpy(wrapper.ir(), ir, 4*nnz);
    p += 8 + (4*nnz+7)/8*8;

    // jc
    miINT32_t *jc = reinterpret_cast<miINT32_t*>(p+8);
    //TODO: control jcLength == 4*(cols+1)
    memcpy(wrapper.jc(), jc, 4*(cols+1));
    p += 8 + (4*(cols+1)+7)/8*8;

    // pr
    miINT32_t *prTag = reinterpret_cast<miINT32_t*>(p);
    miMATRIX_class realType = *prTag;
    wrapper.realType(realType);
    miINT32_t prLength = *(prTag+1);
    memcpy(wrapper.pr(), p+8, prLength);
    p += 8 + (prLength+7)/8*8;

    // pi
    if (isComplex && wrapper.pi() != NULL) {
      miINT32_t *piTag = reinterpret_cast<miINT32_t*>(p);
      miMATRIX_class imagType = *piTag;
      wrapper.imagType(imagType);
      miINT32_t piLength = *(piTag+1);
      memcpy(wrapper.pi(), p+8, piLength);
      p += (piLength+7)/8*8;
    }


  }

};

#endif /* ARRAYSPARSEWRAPPERREADER_HPP_ */