quantity_io.hpp

Go to the documentation of this file.

#ifndef PHYS_UNITS_QUANTITY_IO_HPP_INCLUDED
#define PHYS_UNITS_QUANTITY_IO_HPP_INCLUDED

#include "corsika/framework/units/quantity.hpp"

#include <algorithm>
#include <iosfwd>
#include <map>
#include <stdexcept>
#include <string>
#include <sstream>


namespace phys {


namespace units {


struct quantity_error : public std::runtime_error
{
    quantity_error( std::string const text )
        : std::runtime_error( text )  { }
};


struct prefix_error : public quantity_error
{
    prefix_error( std::string const text )
        : quantity_error( text ) { }
};


inline Rep prefix( std::string const prefix_ )
{
    std::map<std::string, Rep> table
    {
        { "m", milli },
        { "k", kilo  },
        { "u", micro },
        { "M", mega  },
        { "n", nano  },
        { "G", giga  },
        { "p", pico  },
        { "T", tera  },
        { "f", femto },
        { "P", peta  },
        { "a", atto  },
        { "E", exa   },
        { "z", zepto },
        { "Z", zetta },
        { "y", yocto },
        { "Y", yotta },
        { "h", hecto },
        { "da", deka },
        { "d", deci  },
        { "c", centi },
        { "r", ronto },
        { "q", quecto },
        { "R", ronna },
        { "Q", quetta },
    };

    auto pos = table.find( prefix_ );

    if ( pos == table.end() )
    {
        throw prefix_error( "quantity: unrecognized prefix '" + prefix_ + "'" );
    }

    return pos->second;
}

template <typename Dims>
struct unit_info
{

    static bool single()
    {
        return Dims::is_base;
    }


    static std::string name()
    {
        return symbol();
    }


    static std::string symbol()
    {
        std::ostringstream os;

        bool first = true;

        emit_dim( os, "m",   Dims::dim1, first );
        emit_dim( os, "kg",  Dims::dim2, first );
        emit_dim( os, "s",   Dims::dim3, first );
        emit_dim( os, "A",   Dims::dim4, first );
        emit_dim( os, "K",   Dims::dim5, first );
        emit_dim( os, "mol", Dims::dim6, first );
        emit_dim( os, "cd",  Dims::dim7, first );
        emit_dim( os, "eV",  Dims::dim8, first );

        return os.str();
    }


    static void emit_dim( std::ostream & os, const char * label, int exp, bool & first )
    {
        if( exp == 0 )
            return;

        if ( first )
            first = false;
        else
            os << " ";

        os << label;

        if( exp > 1 )
            os << "+";

        if( exp != 1 )
            os << exp;
    }
};

}} // namespace phys::units

#include "quantity_io_meter.hpp"
#include "quantity_io_kilogram.hpp"
#include "quantity_io_second.hpp"
#include "quantity_io_ampere.hpp"
#include "quantity_io_mole.hpp"
#include "quantity_io_candela.hpp"

/*
 * User must choose celsius or kelvin, either by defining
 * QUANTITY_USE_CELSIUS or QUANTITY_USE_KELVIN, or by
 * including the desired include file.
 */
#if defined(QUANTITY_USE_CELSIUS) && defined(QUANTITY_USE_KELVIN)
# error At most define one of QUANTITY_USE_CELSIUS, QUANTITY_USE_KELVIN
#endif
#ifdef QUANTITY_USE_CELSIUS
# include "quantity_io_celsius.hpp"
#endif
#ifdef QUANTITY_USE_KELVIN
# include "quantity_io_kelvin.hpp"
#endif

namespace phys { namespace units {


template< typename  Dims, typename T >
std::string to_magnitude( quantity<Dims, T> const & q )
{
    std::ostringstream os;
    os << q.magnitude();
    return os.str();
}


template< typename Dims, typename T >
std::string to_unit_name( quantity<Dims, T> const & /* q  */)
{
    return unit_info<Dims>::name();
}


template< typename Dims, typename T >
std::string to_unit_symbol( quantity<Dims, T> const & /* q */)
{
    return unit_info<Dims>::symbol();
}


inline std::string to_string( long double const value )
{
    std::ostringstream os;
    os << value;
    return os.str();
}


namespace io {


template< typename Dims, typename T >
std::ostream & operator<<( std::ostream & os, quantity<Dims, T> const & q )
{
    return os << q.magnitude() << " " << to_unit_symbol( q );
}


template< typename Dims, typename T >
std::string to_string( quantity<Dims, T> const & q )
{
    std::ostringstream os;
    os << q;
    return os.str();
}

} // namespace io

}} // namespace phys::units

#endif // PHYS_UNITS_QUANTITY_IO_HPP_INCLUDED

/*
 * end of file
 */