FArray1D.h

Go to the documentation of this file.

#ifndef CLASSIC_FArray1D_HH
#define CLASSIC_FArray1D_HH

// ------------------------------------------------------------------------
// $RCSfile: FArray1D.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1.2.3 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Template class: FArray1D<T,N>
//
// ------------------------------------------------------------------------
// Class category: FixedAlgebra
// ------------------------------------------------------------------------
//
// $Date: 2004/11/18 22:18:06 $
// $Author: jsberg $
//
// ------------------------------------------------------------------------

#include "Utilities/CLRangeError.h"
#include "Utilities/SizeError.h"
#include <algorithm>
#include <initializer_list>
#include <ostream>


// Template class FArray1D<T,N>
// ------------------------------------------------------------------------
//  This version has fixed dimensions.
//  It implements array access, but contains no arithmetic operations.
//  The destructor generated by the compiler performs the correct operation.
//  For speed reasons it is not implemented.

template<class T, int N>
class FArray1D {

public:

    typedef T value_type;

    typedef T *iterator;

    typedef const T *const_iterator;

    //  Constructs a zero array.
    FArray1D();

    //  Set all array elements to [b]t[/b].
    explicit FArray1D(const T &t);

    FArray1D(const FArray1D &);

    FArray1D(const std::initializer_list<T>&);
    
    const FArray1D &operator=(const FArray1D &);

    //  Return a reference to element [b]n[/b].
    //  Throw RangeError, if [b]n[/b] is out of range.
    T &operator()(int n);

    //  Return a constant reference to element [b]n[/b].
    //  Throw RangeError, if [b]n[/b] is out of range.
    const T &operator()(int n) const;

    //  Return a reference to element [b]n[/b].
    //  Result is undefined, if [b]n[/b] is out of range.
    T &operator[](int n);

    //  Return a reference to element [b]n[/b].
    //  Result is undefined, if [b]n[/b] is out of range.
    const T &operator[](int n) const;

    //  Version for non-constant array.
    iterator begin();

    //  Version for non-constant array.
    iterator end();

    //  Version for constant array.
    const_iterator begin() const;

    //  Version for constant array.
    const_iterator end() const;

    int size() const;

protected:

    // The array data.
    T data[N];
};


// Template function implementation.
// ------------------------------------------------------------------------

template<class T, int N>
FArray1D<T, N>::FArray1D() {
    std::fill(begin(), end(), T(0));
}


template<class T, int N>
FArray1D<T, N>::FArray1D(const FArray1D &rhs) {
    std::copy(rhs.begin(), rhs.end(), begin());
}


template<class T, int N>
FArray1D<T, N>::FArray1D(const T &val) {
    std::fill(begin(), end(), val);
}

#include <iostream>

template<class T, int N>
FArray1D<T, N>::FArray1D(const std::initializer_list<T>& init) {
    
    
    if (init.size() > N) {
        throw SizeError("FArray1D<T,N>(const std::initializer_list<T>&)","Size exceeds array dimension.");
    }
    
    // copy list to array
    std::copy(init.begin(), init.end(), begin());
    
    // if initializer list smaller than array dimension, fill rest with zero
    if (init.size() < N) {
        std::fill(begin()+init.size(), end(), T(0));
    }
}

template<class T, int N>
const FArray1D<T, N> &FArray1D<T, N>::operator=(const FArray1D &rhs) {
    std::copy(rhs.begin(), rhs.end(), begin());
    return *this;
}


template<class T, int N> inline
T &FArray1D<T, N>::operator[](int i) {
    return data[i];
}


template<class T, int N> inline
const T &FArray1D<T, N>::operator[](int i) const {
    return data[i];
}


template<class T, int N>
T &FArray1D<T, N>::operator()(int i) {
    if(i >= N) {
        throw CLRangeError("FArray1D::operator()", "Index out of range.");
    }
    return data[i];
}


template<class T, int N>
const T &FArray1D<T, N>::operator()(int i) const {
    if(i >= N) {
        throw CLRangeError("FArray1D::operator()", "Index out of range.");
    }
    return data[i];
}


template<class T, int N> inline
typename FArray1D<T, N>::iterator FArray1D<T, N>::begin() {
    return data;
}


template<class T, int N> inline
typename FArray1D<T, N>::iterator FArray1D<T, N>::end() {
    return data + N;
}


template<class T, int N> inline
typename FArray1D<T, N>::const_iterator FArray1D<T, N>::begin() const {
    return data;
}


template<class T, int N> inline
typename FArray1D<T, N>::const_iterator FArray1D<T, N>::end() const {
    return data + N;
}


template<class T, int N> inline
int FArray1D<T, N>::size() const {
    return N;
}


template <class T, int N>
std::ostream &operator<<(std::ostream &os, const FArray1D<T, N> &v) {
    for(int i = 0; i < N; ++i) {
        os << v[i] << " ";
    }

    os << std::endl;
    return os;
}

#endif // CLASSIC_FArray1D_HH