/home/amesfoort/DAL/dal/hdf5/types/h5tuple.h

/* Copyright 2011-2012  ASTRON, Netherlands Institute for Radio Astronomy
 * This file is part of the Data Access Library (DAL).
 *
 * This library 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.
 *
 * This library 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 this library.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef DAL_H5TUPLE_H
#define DAL_H5TUPLE_H

#include <hdf5.h>
#include <algorithm>
#include "hid_gc.h"
#include "../exceptions/exceptions.h"

namespace dal {

// A non-templated common root, required for IsDerivedFrom checking
class TupleUntemplated {
protected:
  TupleUntemplated() {} // prevent direct instantiation
public:
  ~TupleUntemplated() {} // prevent generating a vtable by forbidding virtual functions
}; 

template<typename T, size_t N> class TupleBase: public TupleUntemplated {
protected:
  TupleBase() {} // prevent direct instantiation
public:
  typedef T type;

  static size_t size() { return N; }

  /*
   * Provide some array-like and vector-like functionality.
   */

  typedef T *iterator;
  typedef const T *const_iterator;

  const T& operator[](size_t index) const { return *(begin() + index); }
        T& operator[](size_t index)       { return *(begin() + index); }

  const_iterator begin() const { return reinterpret_cast<const T*>(this); }
        iterator begin()       { return reinterpret_cast<T*>(this); }

  const_iterator end() const { return begin() + size(); }
        iterator end()       { return begin() + size(); }

  std::vector<T> get() const {
    std::vector<T> result(size());

    std::copy(begin(), end(), result.begin());

    return result;
  }

  void set( const std::vector<T> &other ) {
    if (other.size() != size())
      throw DALValueError("Can not set a tuple using a vector of a different size");

    std::copy(other.begin(), other.end(), begin());
  }
};

template<typename T, size_t N> class Tuple: public TupleBase<T,N> {
private:
  // prevent construction of generic form, as it provides no storage
  Tuple();
  ~Tuple();
};

template<typename T> class Tuple<T,1>: public TupleBase<T,1> {
public:
  T first;  
};

template<typename T> class Tuple<T,2>: public TupleBase<T,2> {
public:
  T first;  
  T second; 
};

template<typename T> class Tuple<T,3>: public TupleBase<T,3> {
public:
  T first;  
  T second; 
  T third;  
};

template<typename T> class Tuple<T,4>: public TupleBase<T,4> {
public:
  T first;  
  T second; 
  T third;  
  T fourth; 
};

template<typename T, size_t N> class Array: public TupleBase<T,N> {
public:
  T elems[N];
};

inline hid_gc h5tupleType( hid_t element, size_t num )
{
  hsize_t dims[1];

  dims[0] = num;

  hid_gc tuple_id(H5Tarray_create2(element, 1, dims), H5Tclose, "Could not create tuple datatype");

  return tuple_id;
}

}

#endif