types_basic.hpp

Go to the documentation of this file.

/*
*  SICAK - SIde-Channel Analysis toolKit
*  Copyright (C) 2018 Petr Socha, FIT, CTU in Prague
*
*  This program is free software: you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation, either version 3 of the License, or
*  (at your option) any later version.
*
*  This program 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 General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

#ifndef TYPES_BASIC_HPP
#define TYPES_BASIC_HPP

#include <algorithm>
#include <memory>
#include <utility>
#include "exceptions.hpp"

class DataType {

public:

        virtual ~DataType() {}

protected:

        DataType() {}
        
};


template <class T>
class ArrayType : public DataType {

public:

        virtual              ~ArrayType() {}
        virtual size_t length() const = 0;
        virtual size_t size() const = 0;
        virtual       void   fill(T val) = 0;
        virtual       T *    data() = 0;
        virtual const T *    data() const = 0;

protected:

        ArrayType() {}

};


template <class T>
class VectorType : public ArrayType<T> {

public:

        virtual                ~VectorType() {}
        virtual         void   init(size_t length) = 0;
        virtual         void   init(size_t length, T initVal) = 0;

        virtual         T &    operator()       (size_t index) = 0;
        virtual const   T &    operator()       (size_t index)                   const = 0;

protected:

        VectorType() {}        
        
};


template <class T>
class MatrixType : public ArrayType<T> {

public:

        virtual ~MatrixType() {}

        virtual size_t cols() const = 0;
        virtual size_t rows() const = 0;

        virtual void   init(size_t cols, size_t rows) = 0;
        virtual void   init(size_t cols, size_t rows, T initVal) = 0;

        virtual         T & operator()       (size_t col, size_t row) = 0;
        virtual const   T & operator()       (size_t col, size_t row)  const = 0;

protected:

        MatrixType() {};        
        
};


class StructuredType : public DataType {

public:

        virtual ~StructuredType() {}

protected:

        StructuredType() {}        
        
};


template <class T>
class ComputationalContext : public StructuredType {

protected:

        ComputationalContext() {}

public:

        virtual ~ComputationalContext() {}
        virtual       void   fill(T val) = 0;

};


template <class T>
class Vector : public VectorType<T> {

public:

        Vector() : m_data(nullptr), m_length(0), m_capacity(0) {}
        Vector(size_t length) : m_data(nullptr), m_length(0), m_capacity(0) {
            (*this).init(length);
        }
        Vector(size_t length, T initVal) : m_data(nullptr), m_length(0), m_capacity(0) {
            (*this).init(length);
            (*this).fill(initVal);             
        }

        Vector(Vector&& other) : m_data(std::move(other.m_data)), m_length(other.m_length) {  }
        Vector& operator=(Vector&& other) {
                m_data = std::move(other.m_data);
                m_length = other.m_length;
                return (*this);
        }

        virtual ~Vector() {}

        virtual size_t length() const { return m_length; }

        virtual size_t size() const { return m_length * sizeof(T); }

        virtual void   init(size_t length) {
            
            // realloc if asking for more than I can take
            if(length > m_capacity){
                
                try {
                    
                    m_data.reset(new T[length]);
                    m_capacity = length;
                    
                } catch (std::bad_alloc & e) {
                    throw RuntimeException("Memory allocation failed"); 
                }
                
            } 

            m_length = length;  //< set the length the user have asked for (array is at least this big)
            
        }

        virtual void   init(size_t length, T initVal) {
                (*this).init(length);
                (*this).fill(initVal);
        }

        virtual void    fill(T val) {
                std::fill_n(m_data.get(), m_length, val);
        }

        virtual T *     data() { return m_data.get(); }

        virtual const T *     data() const { return m_data.get(); }

        T & operator()       (size_t index) { return m_data[index]; }

        const   T & operator()       (size_t index) const { return m_data[index]; }

protected:

        std::unique_ptr<T[]> m_data;
        size_t m_length;
        size_t m_capacity;
        
};


template <class T>
class Matrix : public MatrixType<T> {

public:

        Matrix() : m_vector(), m_cols(0), m_rows(0) {}
        Matrix(size_t cols, size_t rows) : m_vector(cols * rows), m_cols(cols), m_rows(rows) {}
        Matrix(size_t cols, size_t rows, T initVal) : m_vector(cols * rows, initVal), m_cols(cols), m_rows(rows) {}

        Matrix(Matrix&& other) : m_vector(std::move(other.m_vector)), m_cols(other.m_cols), m_rows(other.m_rows) {}
        Matrix& operator=(Matrix&& other) {
                m_vector = std::move(other.m_vector);
                m_cols = other.m_cols;
                m_rows = other.m_rows;
                return (*this);
        }

        virtual ~Matrix() {}

        virtual size_t cols() const { return m_cols; }
        virtual size_t rows() const { return m_rows; }

        virtual void   init(size_t cols, size_t rows) {
                m_vector.init(cols * rows);
                m_cols = cols;
                m_rows = rows;
        }
        virtual void   init(size_t cols, size_t rows, T initVal) {
                m_vector.init(cols * rows, initVal);
                m_cols = cols;
                m_rows = rows;
        }

        virtual T *    data() { return m_vector.data(); }
        virtual const T *    data() const { return m_vector.data(); }

        virtual size_t length() const { return m_vector.length(); }
        virtual size_t size() const { return m_vector.size(); }

        virtual     void fill(T val) {
                m_vector.fill(val);
        }

        virtual         T & operator()       (size_t col, size_t row) { return m_vector(row * m_cols + col); }
        virtual const   T & operator()       (size_t col, size_t row) const { return m_vector(row * m_cols + col); }

protected:

        Vector<T> m_vector;
        size_t m_cols;
        size_t m_rows;        
        
};


#endif /* TYPES_BASIC_HPP */