MatrixArray.hpp

Go to the documentation of this file.

#ifndef __MATRIXARRAY_H__
#define __MATRIXARRAY_H__

#include <types/MatrixTypes.hpp>
#include <string>
#include <map>
#include <stdio.h>
#include <exception>


// Forward declaration of class boost::serialization::access
namespace boost {
namespace serialization {
class access;
}//: serialization
}//: access

namespace mic {
namespace types {


template<typename T>
class MatrixArray {
public:

    MatrixArray() = default;

    MatrixArray(std::string name_)  : array_name ( name_ ) {
    }


    MatrixArray ( std::string name_, std::initializer_list<std::tuple<std::string, size_t, size_t> > args_) : array_name ( name_ ) {

        add ( args_ );

    }

    MatrixArray ( const MatrixArray& other ) {
        // Copy name.
        array_name = other.array_name;

        keys_map.clear();
        matrices.clear();
        // Copy data.
        for (auto& i: other.keys_map) {
            std::string tmp_name = i.first;
            mic::types::MatrixPtr<T> tmp_mat_ptr =  other.matrices[i.second];

            // Add tuple to array.
            keys_map[ tmp_name ] = matrices.size();
            matrices.push_back ( std::make_shared<mic::types::Matrix<T> > (mic::types::Matrix<T> (*tmp_mat_ptr) ) );
        }//: for

    }

    MatrixArray& operator= ( const MatrixArray& other ) {
        // Copy name.
        array_name = other.array_name;

        keys_map.clear();
        matrices.clear();
        // Copy data.
        for (auto& i: other.keys_map) {
            std::string tmp_name = i.first;
            mic::types::MatrixPtr<T> tmp_mat_ptr =  other.matrices[i.second];

            // Add tuple to array.
            keys_map[ tmp_name ] = matrices.size();
            matrices.push_back ( std::make_shared<mic::types::Matrix<T> > (mic::types::Matrix<T> (*tmp_mat_ptr) ) );
        }//: for

        return *this;
    }

    void add ( std::initializer_list<std::tuple<std::string, size_t, size_t> > params_ ) {
        for ( auto i : params_ ) {
            keys_map[std::get<0> ( i )] = matrices.size();
            matrices.push_back ( std::make_shared<mic::types::Matrix<T> > ( mic::types::Matrix<T> ( std::get<1> ( i ), std::get<2> ( i ) ) ) );
        }//: for
    }

    void add ( std::tuple<std::string, size_t, size_t> param_ ) {
        keys_map[std::get<0> ( param_ )] = matrices.size();
        matrices.push_back ( std::make_shared<mic::types::Matrix<T> > ( mic::types::Matrix<T> ( std::get<1> ( param_ ), std::get<2> ( param_ ) ) ) );
    }

    void add ( std::string name_, size_t input_, size_t output_) {
        keys_map[name_] = matrices.size();
        matrices.push_back ( std::make_shared<mic::types::Matrix<T> > ( mic::types::Matrix<T> ( input_, output_ ) ) );
    }

    void add ( std::string name_, std::shared_ptr<mic::types::Matrix<T> > matrix_ptr_) {
        keys_map[name_] = matrices.size();
        matrices.push_back ( matrix_ptr_);
    }

    mic::types::MatrixPtr<T>& operator[] ( size_t number_ ) {
        if (number_ >= matrices.size())
            throw std::range_error("MatrixArray " + array_name + " size is smaller than: " + std::to_string(number_));

        return matrices[number_];
    }

    inline bool keyExists(char key_) {
        return (keys_map.find ( std::to_string(key_) ) == keys_map.end());
    }

    inline bool keyExists(std::string key_) {
        return keys_map.find ( key_ ) != keys_map.end();
    }


    mic::types::MatrixPtr<T>& operator[] ( char key_ ) {
        if ( !keyExists(key_) )
            throw std::range_error("MatrixArray " + array_name + " does not have a key " + key_);

        return ( *this ) [std::string ( 1, key_ )];
    }

    mic::types::MatrixPtr<T>& operator[] ( std::string key_ ) {
        if ( !keyExists(key_) )
            throw std::range_error("MatrixArray " + array_name + " does not have a key " + key_);

        return matrices[keys_map[key_]];
    }

    friend std::ostream& operator<<(std::ostream& os_, const MatrixArray& obj_) {
        // Display name
        os_ << "[" << obj_.array_name << "]:\n";
        for (auto& i: obj_.keys_map) {
            // Display elements.
            os_ << "(" << i.second << ") [" << i.first << "]:\n";
            os_ << (*obj_.matrices[i.second]) << std::endl;
        }
        return os_;
    }

    void setZero() {

        for ( size_t i = 0; i < matrices.size(); i++ )
            matrices[i]->setZero();
    }

    std::string name() {
        return array_name;
    }

    std::map<std::string, size_t> keys() {
        return keys_map;
    }

    size_t size() {
        return matrices.size();
    }

protected:
    std::string array_name;

    std::vector<mic::types::MatrixPtr<T> > matrices;


    std::map<std::string, size_t> keys_map;

private:
    // Friend class - required for using boost serialization.
    friend class boost::serialization::access;

    template<class Archive>
    void save(Archive & ar, const unsigned int version) const {
        // Serialize name and size.
        ar & array_name;
        size_t size = matrices.size();
        ar & size;
        // Serialize elements.
        for (auto& i: keys_map) {
            ar & i.first;
            ar & (*matrices[i.second]);
        }//: for
     }

     template<class Archive>
     void load(Archive & ar, const unsigned int version) {
        // Deserialize name and size.
        ar & array_name;
        size_t size;
        ar & size;
        // Deserialize elements.
        for (size_t i=0; i < size; i++) {
            std::string tmp_name;
            ar & tmp_name;
            mic::types::Matrix<T> tmp_mat;
            ar & tmp_mat;
            // Add tuple to array.
            keys_map[ tmp_name ] = matrices.size();
            matrices.push_back ( std::make_shared<mic::types::Matrix<T> > (mic::types::Matrix<T> (tmp_mat) ) );

        }//: for

     }

     // The serialization must be splited as load requires to allocate the memory.
     BOOST_SERIALIZATION_SPLIT_MEMBER()

};

}//: namespace types
}//: namespace mic

// Just in the case that something important will change in the MatrixArray class - set version.
BOOST_CLASS_VERSION(mic::types::MatrixArray<bool>, 1)
BOOST_CLASS_VERSION(mic::types::MatrixArray<short>, 1)
BOOST_CLASS_VERSION(mic::types::MatrixArray<int>, 1)
BOOST_CLASS_VERSION(mic::types::MatrixArray<long>, 1)
BOOST_CLASS_VERSION(mic::types::MatrixArray<float>, 1)
BOOST_CLASS_VERSION(mic::types::MatrixArray<double>, 1)



#endif /*__MATRIXARRAY_H__*/