Units.hxx

/*
 * Copyright (C) 2022 CERN
 *
 * This software is provided 'as-is', without any express or implied
 * warranty.  In no event will the authors be held liable for any damages
 * arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any purpose,
 * including commercial applications, and to alter it and redistribute it
 * freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you must not
 *    claim that you wrote the original software. If you use this software
 *    in a product, an acknowledgment in the product documentation would be
 *    appreciated but is not required.
 * 2. Altered source versions must be plainly marked as such, and must not be
 *    misrepresented as being the original software.
 * 3. This notice may not be removed or altered from any source distribution.
 *
 * Created on: 2022-02-09
 *     Author: Michal Mysior <mmysior> <michal.mysior@cern.ch>
 *
 */
 
#ifndef MOTION_CONTROLLER_UNITS_HXX__
#define MOTION_CONTROLLER_UNITS_HXX__
 
#include "Exception.hpp"
#include "Units.hpp"
#include <type_traits>
 
namespace smc {
namespace units {
 
template<class R, class P>
Value operator*(const Value &value, std::chrono::duration<R, P> duration)
{
    switch (value.unit)
    {
    case Unit::MILLIMETERS_PER_MINUTE:
        return Value{
            Unit::MILLIMETERS,
            (value.value *
             std::chrono::duration_cast<std::chrono::minutes>(duration).count())};
    case Unit::METERS_PER_SECOND:
        return Value{
            Unit::METERS,
            (value.value *
             std::chrono::duration_cast<std::chrono::seconds>(duration).count())};
    case Unit::MILLIMETERS_PER_SECOND:
        return Value{
            Unit::MILLIMETERS,
            (value.value *
             std::chrono::duration_cast<std::chrono::seconds>(duration).count())};
    case Unit::MILLIMETERS_PER_SECOND_SQUARED:
        return Value{
            Unit::MILLIMETERS_PER_SECOND,
            (value.value *
             std::chrono::duration_cast<std::chrono::seconds>(duration).count())};
    default: throw Exception{ErrorCode::IncompatibleUnits};
    }
}
 
template<class R, class P>
Value operator/(const Value &value, std::chrono::duration<R, P> duration)
{
    switch (value.unit)
    {
    case Unit::MILLIMETERS:
        if (std::is_same<typename std::chrono::duration<R, P>::period,
            std::chrono::minutes::period>::value)
        {
            return Value{
                Unit::MILLIMETERS_PER_MINUTE,
                (value.value / duration.count())};
        }
        else
        {
            // default to returning mm/s
            return Value{
                Unit::MILLIMETERS_PER_SECOND,
                (value.value /
                 std::chrono::duration_cast<std::chrono::seconds>(duration).count())};
        }
    case Unit::METERS:
        return Value{
            Unit::METERS_PER_SECOND,
            (value.value /
             std::chrono::duration_cast<std::chrono::seconds>(duration).count())};
    case Unit::MILLIMETERS_PER_SECOND:
        return Value{
            Unit::MILLIMETERS_PER_SECOND_SQUARED,
            (value.value /
             std::chrono::duration_cast<std::chrono::seconds>(duration).count())};
    default: throw Exception{ErrorCode::IncompatibleUnits};
    }
}
 
struct IOPort::reference
{
    reference(const reference &) = default;
    reference &operator=(const reference &) = delete;
    inline operator bool() const
    {
        return (const_cast<const IOPort &>(*m_port))[m_offset];
    }
    inline reference &operator=(bool value)
    {
        if (value)
            m_port->value |= (value_type(1) << m_offset);
        else
            m_port->value &= ~(value_type(1) << m_offset);
        return *this;
    }
 
    inline size_type offset() const { return m_offset; }
    bool operator==(const reference &ref) const
    {
        return m_offset == ref.m_offset && m_port == ref.m_port;
    }
    bool operator!=(const reference &ref) const { return !(ref == *this); }
 
protected:
    reference(size_type offset, IOPort *port) :
        m_offset{offset}, m_port{port} {};
 
    friend struct IOPort;
    friend struct const_reference;
    size_type m_offset;
    IOPort *m_port;
};
 
inline IOPort::reference IOPort::operator[](size_type offset)
{
    return reference{offset, this};
}
 
struct IOPort::const_reference
{
    const_reference(const reference &ref) :
        m_offset{ref.m_offset}, m_port{ref.m_port} {};
    const_reference(const const_reference &) = default;
    const_reference &operator=(const const_reference &) = delete;
    inline operator bool() const { return (*m_port)[m_offset]; }
    inline size_type offset() const { return m_offset; }
    bool operator==(const const_reference &ref) const
    {
        return m_offset == ref.m_offset && m_port == ref.m_port;
    }
    bool operator!=(const reference &ref) const { return !(ref == *this); }
 
protected:
    const_reference(size_type offset, const IOPort *port) :
        m_offset{offset}, m_port{port} {};
 
    friend struct IOPort;
    size_type m_offset;
    const IOPort *m_port;
};
 
struct IOPort::iterator
{
    iterator(reference &&ref) : _ref{ref} {}
    iterator() : _ref{0, nullptr} {}
 
    reference &operator*() { return _ref; }
    reference *operator->() { return &_ref; }
    bool operator==(const iterator &it) const { return _ref == it._ref; }
    bool operator!=(const iterator &it) const { return _ref != it._ref; }
 
    iterator &operator++()
    {
        ++_ref.m_offset;
        return *this;
    }
    iterator operator++(int)
    {
        iterator tmp = *this;
        ++_ref.m_offset;
        return tmp;
    }
    iterator &operator--()
    {
        --_ref.m_offset;
        return *this;
    }
    iterator operator--(int)
    {
        iterator tmp = *this;
        --_ref.m_offset;
        return tmp;
    }
 
protected:
    friend struct IOPort::const_iterator;
    reference _ref;
};
 
struct IOPort::const_iterator
{
    const_iterator(const_reference &&ref) : _ref{ref} {}
    const_iterator(const iterator &it) : _ref{it._ref} {}
    const_iterator() : _ref{0, nullptr} {}
 
    const_reference &operator*() { return _ref; }
    const_reference *operator->() { return &_ref; }
    bool operator==(const const_iterator &it) const { return it._ref == _ref; }
    bool operator!=(const const_iterator &it) const { return it._ref != _ref; }
 
    const_iterator &operator++()
    {
        ++_ref.m_offset;
        return *this;
    }
    const_iterator operator++(int)
    {
        const_iterator tmp = *this;
        ++_ref.m_offset;
        return tmp;
    }
    const_iterator &operator--()
    {
        --_ref.m_offset;
        return *this;
    }
    const_iterator operator--(int)
    {
        const_iterator tmp = *this;
        --_ref.m_offset;
        return tmp;
    }
 
protected:
    const_reference _ref;
};
 
inline IOPort::const_iterator IOPort::begin() const
{
    return const_iterator{const_reference{0, this}};
}
 
inline IOPort::const_iterator IOPort::end() const
{
    return const_iterator{const_reference{size, this}};
}
 
inline IOPort::const_iterator IOPort::const_begin() const
{
    return begin();
}
 
inline IOPort::const_iterator IOPort::const_end() const
{
    return end();
}
 
inline IOPort::iterator IOPort::begin()
{
    return iterator{reference{0, this}};
}
 
inline IOPort::iterator IOPort::end()
{
    return iterator{reference{size, this}};
}
 
} /* namespace units */
} /* namespace smc */
 
namespace std {
 
template<>
struct hash<smc::units::Unit>
{
    size_t operator()(const smc::units::Unit &x) const
    {
        using type = typename std::underlying_type<smc::units::Unit>::type;
        return std::hash<type>()(static_cast<type>(x));
    }
};
 
} /* namespace std */
 
#endif /* MOTION_CONTROLLER_UNITS_HXX__ */