matfile/matfile_concepts/src/Devices/InputDevice.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 INPUTDEVICE_HPP_
#define INPUTDEVICE_HPP_

#include "basics/debug.hh"
#include "basics/exceptions.hh"

// Debug flags
#define InputDeviceElem_D 0
#define InputDeviceFind_D 0


class bad_matfile : public std::exception
{
private:
  std::string what_;

public:
  bad_matfile() {
    what_ = "Bad matfile";
  }

  virtual ~bad_matfile() throw() { }

  virtual const char* what() throw() {
    return what_.c_str();
  }
};

class NotExistingMatrix : public concepts::ExceptionBase
{
public:
  NotExistingMatrix
  (const std::string& matrix, const std::string& matfile) throw() : 
    concepts::ExceptionBase("", 0, "", "")
    , matrix_(matrix), matfile_(matfile) {
  }

  virtual ~NotExistingMatrix() throw() { }
protected:
  std::ostream& info(std::ostream& os) const throw() {
    return os << '[' << file_ << ", line " << line_ << "] " << function_ 
              << " -- not existing matrix " << matrix_ 
              << " in file " << matfile_;
  }
private:
  const std::string matrix_, matfile_;
};

class InputDevice
{
public:
  template<typename charT>
  InputDevice(const std::basic_string<charT>& filename);

  template<typename charT>
  InputDevice(const charT* filename);

  std::string description() const { return description_; }

  std::string subsystem() const { return subsystem_; }

  miINT16_t version() const { return version_; }

  bool inverse_endian() const { return inverse_endian_; }

  const std::vector<MatrixInfo>& info() const { return data_; }

  /* *
   * \brief Returns a numeric array.
   *
   * Returns the numeric array with the given name.
   *
   * \param name The name of the desidered matrix.
   */
  //DenseMatrix getNumArray(const std::string& name) const;


  std::vector<MatrixInfo>::iterator begin() {
    return data_.begin();
  }

  std::vector<MatrixInfo>::const_iterator begin() const {
    return data_.begin();
  }

  std::vector<MatrixInfo>::iterator end() {
    return data_.end();
  }

  std::vector<MatrixInfo>::const_iterator end() const {
    return data_.end();
  }


  template<class WrapperClass>
  void readArray(const std::string& name, WrapperClass& wrapper) {
    for (std::vector<MatrixInfo>::iterator i = begin(); i != end(); ++i) {
      if (i->_name == name) {
        std::istringstream stream(i->_buffer, std::ios::binary);
        detail::Reader<WrapperClass>::read(i->_buffer, wrapper);
        return;
      }
    }
  } 
  
  /*
   * Operator for handling Dimensions of Matrix in matfile. The Inputstring should be the name of an existing 
   * Matrix in in the matfile, related to the the Inputdevice. Otherwise an exceptions is thrown.
   */
  MatrixInfo operator[](const std::string) const;
  
  
  std::vector<MatrixInfo>::const_iterator  find(const std::string) const;

private:
  std::string filename_;

  std::string description_;
  std::string subsystem_;
  miINT16_t version_;
  bool inverse_endian_;

  std::vector<MatrixInfo> data_;

private:
  void extract_header(std::istream&);
  void extract_info(std::istream&);
    
  
};


template<typename charT>
InputDevice::InputDevice(const std::basic_string<charT>& filename)
  : filename_(filename)
{
  std::ifstream fs(filename.c_str(), std::ifstream::binary | std::ifstream::in);

  fs.seekg(0, std::ios::end);
  int endfile = fs.tellg();

  fs.seekg(0);
  extract_header(fs);
  fs.seekg(128);

  //Extract arrays
  int pos;
  while ((pos = fs.tellg()) != endfile) {
    miINT32_t tag[2];
    fs.read(reinterpret_cast<char*>(tag), 8);
    fs.seekg(pos);
    extract_info(fs);
    fs.seekg(pos + 8 + tag[1]);
  }
}

template<typename charT>
InputDevice::InputDevice(const charT* filename)
: filename_(filename)
{
  std::ifstream fs(filename, std::ifstream::binary | std::ifstream::in);

  fs.seekg(0, std::ios::end);
  int endfile = fs.tellg();

  fs.seekg(0);
  extract_header(fs);
  fs.seekg(128);

  //Extract arrays
  int pos;
  while ((pos = fs.tellg()) != endfile) {
    miINT32_t tag[2];
    fs.read(reinterpret_cast<char*>(tag), 8);
    fs.seekg(pos);
    extract_info(fs);
    fs.seekg(pos + 8 + tag[1]);
  }
}


void InputDevice::extract_header(std::istream& fs)
{
  //Description
  char descstr[117];
  fs.read(descstr, 116);
  descstr[116] = '\0';
  description_ = descstr;

  //Subsystem data offset
  char subsysstr[9];
  fs.read(subsysstr, 8);
  subsysstr[8] = '\0';
  subsystem_ = subsysstr;

  //Version
  fs.read(reinterpret_cast<char*>(&version_), 2);

  //Endian
  char e[2];
  fs.read(e, 2);
  if (e[0] == 'I' || e[1] == 'M')
    inverse_endian_ = false;
  else if(e[0] == 'M' || e[1] == 'I')
    inverse_endian_ = true;
  else
    throw bad_matfile();
}


void InputDevice::extract_info(std::istream& fs)
{
  data_.push_back(MatrixInfo());
  MatrixInfo &rd = data_.back();

  std::string &buffer = rd._buffer;

  // Read tag
  buffer.resize(8);
  fs.read(&buffer[0], 8);
  miINT32_t *tag = reinterpret_cast<miINT32_t*>(&buffer[0]);

  if (tag[0] == miMATRIX) {
    buffer.resize(8+tag[1]);
    fs.read(&buffer[8], tag[1]);

    // Extract flags
    miUINT32_t *flags = reinterpret_cast<miUINT32_t*>(&buffer[16]);
    rd._class = *flags & 255;
    rd._isComplex = ((*flags & 2048) != 0);

    // Extract dimension
    std::vector<miINT32_t> &_dimensions = rd._dimensions;
    miINT32_t *dimTag = reinterpret_cast<miINT32_t*>(&buffer[24]);
    miINT32_t ndim = *(dimTag+1)/4;
    _dimensions.resize(ndim);
    memcpy(&_dimensions[0], dimTag+2, *(dimTag+1));

    // Extract name
    std::string &_name = rd._name;
    miINT32_t *nameTag = dimTag + 2 + (ndim+1)/2*2;
    miINT32_t nameLength = *(nameTag+1);
    _name.resize(nameLength);
    memcpy(&_name[0], nameTag+2, nameLength);
  } else if (tag[0] == miCOMPRESSED) {
    miINT32_t compressedSize = tag[1];
    std::string &compressed = rd._buffer;
    std::string uncompressed;
    compressed.resize(8+compressedSize);
    fs.read(&compressed[8], compressedSize);

    // 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

    uncompressed.reserve(32);
    strm.next_in = reinterpret_cast<Bytef*>(&compressed[8]);
    strm.avail_in = compressedSize;
    strm.next_out = reinterpret_cast<Bytef*>(&uncompressed[0]);
    strm.avail_out = 32;
    inflate(&strm, Z_NO_FLUSH); //TODO: control return value

    // Extract flags
    miUINT32_t *flags = reinterpret_cast<miUINT32_t*>(&uncompressed[16]);
    rd._class = *flags & 255;
    rd._isComplex = ((*flags & 2048) != 0);

    // Dimensions size
    miINT32_t dimSize = *reinterpret_cast<miINT32_t*>(&uncompressed[28]);
    strm.next_out = reinterpret_cast<Bytef*>(&uncompressed[0]);
    strm.avail_out = 16;
    inflate(&strm, Z_NO_FLUSH);

    // Extract dimensions
    std::vector<miINT32_t> &dimensions = rd._dimensions;
    dimensions.resize(dimSize/4);
    memcpy(&dimensions[0], &uncompressed[0], dimSize);

    // Name tag
    char *nameTag = &uncompressed[0] + (dimSize+7)/8*8;
    if (*reinterpret_cast<miINT32_t*>(nameTag) > 255) {
      //Short tag
      miINT32_t nameDimension = *reinterpret_cast<miINT16_t*>(nameTag+2);
      if (nameDimension > 4)
        throw bad_matfile();
      rd._name.assign(nameTag + 4, nameDimension);
    } else {
      miINT32_t nameDimension = *reinterpret_cast<miINT32_t*>(nameTag + 4);
      uncompressed.resize(nameDimension);
      strm.next_out = reinterpret_cast<Bytef*>(&uncompressed[0]);
      strm.avail_out = nameDimension;
      inflate(&strm, Z_NO_FLUSH);
      rd._name = uncompressed;
    }
  } else
    throw bad_matfile();
}
 
MatrixInfo InputDevice::operator[](const std::string matrixName) const 
{
  std::vector<MatrixInfo>::const_iterator iter = this->find(matrixName);
  DEBUGL(InputDeviceElem_D, "Searching for matrix " << matrixName);
  
  if(iter == this->end())
    throw conceptsException
      (NotExistingMatrix(matrixName, filename_));

  return *iter;
}
 
 
std::vector<MatrixInfo>::const_iterator 
InputDevice::find(const std::string matrixName) const 
{
  DEBUGL(InputDeviceFind_D, "Searching for matrix " << matrixName);
  std::vector<MatrixInfo>::const_iterator iter = this->begin(); 

  while(iter != this->end() && iter->getName() != matrixName)
    ++iter;

  DEBUGL(InputDeviceFind_D, "done.");
  return iter;
}

#endif  /* INPUTDEVICE_HPP_ */