QuantityArray.hpp

Go to the documentation of this file.

/*
 * This file is part of the DUDS project. It is subject to the BSD-style
 * license terms in the LICENSE file found in the top-level directory of this
 * distribution and at https://github.com/jjackowski/duds/blob/master/LICENSE.
 * No part of DUDS, including this file, may be copied, modified, propagated,
 * or distributed except according to the terms contained in the LICENSE file.
 *
 * Copyright (C) 2017  Jeff Jackowski
 */
#ifndef QUANTITYARRAY_HPP
#define QUANTITYARRAY_HPP

#include <duds/data/Quantity.hpp>
#include <duds/general/NddArray.hpp>
#include <array>

namespace duds { namespace data {

struct QuantityNddArray;

template <class I>
class QuantityIterator {
    I iter;
    Unit arrayUnit;
public:
    // iterator traits
    typedef Quantity value_type;
    typedef typename std::iterator_traits<I>::pointer  pointer;
    typedef typename std::iterator_traits<I>::reference  reference;
    typedef typename std::iterator_traits<I>::iterator_category  iterator_category;
    typedef void  difference_type;
    QuantityIterator() = default;
    QuantityIterator(const I &i, Unit u) : iter(i), arrayUnit(u) { }
    QuantityIterator &operator ++ () {
        ++iter;
        return *this;
    }
    QuantityIterator &operator ++ (int) {
        QuantityIterator i(iter);
        ++iter;
        return i;
    }
    QuantityIterator &operator -- () {
        --iter;
        return *this;
    }
    QuantityIterator &operator -- (int) {
        QuantityIterator i(iter);
        --iter;
        return i;
    }
    bool operator == (const QuantityIterator &it) const {
        return iter == it.iter;
    }
    bool operator != (const QuantityIterator &it) const {
        return iter != it.iter;
    }
    Quantity operator * () const {
        return Quantity(*iter, arrayUnit);
    }
    auto value() const {
        return *iter;
    }
    Unit unit() const {
        return arrayUnit;
    }
};

template <std::size_t L>
struct QuantityArray {
    typedef std::array<double, L>  Array;
    Array array;
    Unit unit;
    typedef QuantityIterator<typename Array::iterator>  iterator;
    typedef QuantityIterator<typename Array::const_iterator>  const_iterator;
    iterator begin() {
        return iterator(array.begin(), unit);
    }
    const_iterator begin() const {
        return const_iterator(array.begin(), unit);
    }
    const_iterator cbegin() const {
        return const_iterator(array.cbegin(), unit);
    }
    iterator end() {
        return iterator(array.end(), unit);
    }
    const_iterator end() const {
        return const_iterator(array.end(), unit);
    }
    const_iterator cend() const {
        return const_iterator(array.cend(), unit);
    }
    Quantity get(std::size_t pos) const {
        return Quantity(array.at(pos), unit);
    }
    void set(std::size_t pos, const Quantity &q) {
        if (unit != q.unit) {
            DUDS_THROW_EXCEPTION(UnitMismatch());
        }
        array.at(pos) = q.value;
    }
    QuantityArray &operator=(const QuantityArray &a) = default;
    template <std::size_t N>
    QuantityArray &copy(const QuantityArray<N> &a) {
        unit = a.unit;
        std::size_t loop = std::min(L, N);
        typename Array::iterator dest = array.begin();
        typename QuantityArray<N>::Array::const_iterator src = a.array.begin();
        for (; loop; ++dest, ++src, --loop) {
            *dest = *src;
        }
        return *this;
    }
    QuantityArray &operator=(const QuantityNddArray &a); // defined near EOF
};

struct QuantityXyz : public QuantityArray<3> {
    double &x() {
        return array[0];
    }
    const double &x() const {
        return array[0];
    }
    double &y() {
        return array[1];
    }
    const double &y() const {
        return array[1];
    }
    double &z() {
        return array[2];
    }
    const double &z() const {
        return array[2];
    }
    Quantity xQ() const {
        return get(0);
    }
    Quantity yQ() const {
        return get(1);
    }
    Quantity zQ() const {
        return get(2);
    }
};

struct QuantityNddArray {
    typedef duds::general::NddArray<double>  Array;
    Array array;
    Unit unit;
    QuantityNddArray() = default;
    QuantityNddArray(const QuantityNddArray &) = default;
    QuantityNddArray(QuantityNddArray &&q) noexcept :
    array(std::move(q.array)), unit(q.unit) { }
    QuantityNddArray &operator=(const QuantityNddArray &a) = default;
    QuantityNddArray &operator=(QuantityNddArray &&q) = default;
    template <std::size_t N>
    QuantityNddArray &operator=(const QuantityArray<N> &q) {
        array.copyFrom(q.array);
        unit = q.unit;
        return *this;
    }
    void clear() noexcept {
        array.clear();
        unit.clear();
    }
    bool empty() const {
        return array.empty();
    }
    typedef QuantityIterator<typename Array::iterator>  iterator;
    typedef QuantityIterator<typename Array::const_iterator>  const_iterator;
    iterator begin() {
        return iterator(array.begin(), unit);
    }
    const_iterator begin() const {
        return const_iterator(array.begin(), unit);
    }
    const_iterator cbegin() const {
        return const_iterator(array.cbegin(), unit);
    }
    iterator end() {
        return iterator(array.end(), unit);
    }
    const_iterator end() const {
        return const_iterator(array.end(), unit);
    }
    const_iterator cend() const {
        return const_iterator(array.cend(), unit);
    }
    template <class Dim>
    Quantity get(const Dim &pos) const {
        return Quantity(array.at<Dim>(pos), unit);
    }
    Quantity get(const Array::DimList &pos) const {
        return Quantity(array.at<Array::DimList>(pos), unit);
    }
    template <class Dim>
    void set(const Dim &pos, const Quantity &q) {
        if (unit != q.unit) {
            DUDS_THROW_EXCEPTION(UnitMismatch());
        }
        array.at<Dim>(pos) = q.value;
    }
    void set(const Array::DimList &pos, const Quantity &q) {
        if (unit != q.unit) {
            DUDS_THROW_EXCEPTION(UnitMismatch());
        }
        array.at<Array::DimList>(pos) = q.value;
    }

private:
    // serialization support
    friend class boost::serialization::access;
    template <class A>
    void serialize(A &a, const unsigned int) {
        a & BOOST_SERIALIZATION_NVP(array);
        a & BOOST_SERIALIZATION_NVP(unit);
    }
};

// documented above with the QuantityArray class
template <std::size_t L>
QuantityArray<L> &QuantityArray<L>::operator=(const QuantityNddArray &a) {
    unit = a.unit;
    a.array.copyTo(array);
    return *this;
}


} }

#endif        //  #ifndef QUANTITYARRAY_HPP