FArray.h

// ===========================================================================
// Imagine++ Libraries
// Copyright (C) Imagine
// For detailed information: http://imagine.enpc.fr/software
// ===========================================================================

namespace Imagine {


    template <typename T,int S> class FArray {

    protected:
        T _data[S];

    public:
        typedef T* iterator;
        typedef const T* const_iterator;

        FArray(){}
        explicit FArray(const T& v) {
            fill(v);
        }
        template <typename T2> FArray(const T2 t[S]) {
            for (int i=0;i<S;i++) (*this)[i] = T(t[i]);
        }
        template <typename T2> FArray(const FArray<T2,S>& a) {
            for (int i=0;i<S;i++) (*this)[i] = T(a[i]);
        }
        FArray(T v0, T v1) { 
            assert(S==2);
            (*this)[0]=v0; (*this)[1]=v1;
        }
        FArray(T v0, T v1, T v2) {
            assert(S==3);
            (*this)[0]=v0; (*this)[1]=v1; (*this)[2]=v2;
        }
        FArray(T v0, T v1, T v2, T v3) {
            assert(S==4);
            (*this)[0]=v0; (*this)[1]=v1; (*this)[2]=v2; (*this)[3]=v3;
        }
        FArray& fill(const T& v) {
            std::fill(begin(),end(),v);
            return *this;
        }
        template <typename T2> FArray& copy(const T2 t[S]) {
            for (int i=0;i<S;i++) (*this)[i] = T(t[i]);
            return *this;
        }
        template <typename T2> FArray& copy(const FArray<T2,S>& b) {
            for (int i=0;i<S;i++) (*this)[i] = T(b[i]);
            return *this;
        }
        template <typename T2> FArray& operator = (const FArray<T2,S>& b) {
            return copy(b);
        }
        bool empty() const { return false; }
        int size() const { return S; }
        const T& operator [] (int i) const {
            assert(i>=0 && i<S);
            return _data[i];
        }
        T& operator [] (int i) {
            assert(i>=0 && i<S);
            return _data[i];
        }
        const T* data() const { return _data; }
        T* data() { return _data; }
        iterator begin() { return _data; }
        const_iterator begin() const { return _data; }
        iterator end() { return _data+S; }
        const_iterator end() const { return _data+S; }
        bool operator == (const FArray& b) const {
            return std::equal(begin(),end(),b.begin());
        }
        bool operator != (const FArray& b) const {
            return !(*this == b);
        }
        friend std::pair<T,T> range(const FArray& a)
        {   
            std::pair<T,T> r(a[0],a[0]);
            for (const_iterator it = a.begin()+1 ; it != a.end() ; ++it)
            {
                r.first = std::min(r.first, *it);
                r.second = std::max(r.second, *it);
            }
            return r;
        }
        friend inline void write(std::ostream& out,const FArray& a) {
            out.write((const char*)a._data,(std::streamsize)S*sizeof(T));
        }
        friend inline void read(std::istream& in, FArray& a) {
            in.read((char*)a._data,(std::streamsize)S*sizeof(T));
        }
        friend inline std::ostream& operator<<(std::ostream& out,const FArray& a) {
            for (const_iterator it = a.begin() ; it != a.end() ; ++it)
                out<<*it<<' ';
            return out;
        }
        friend inline std::istream& operator>>(std::istream& in, FArray& a) {
            for (iterator it = a.begin() ; it != a.end() ; ++it)
                in>>*it;
            return in;
        }
    };


}