gen_units_class_plugin.h

// Copyright 2015-2023:
//   GobySoft, LLC (2013-)
//   Community contributors (see AUTHORS file)
// File authors:
//   Toby Schneider <toby@gobysoft.org>
//   Stephanie Petillo <stephanie@gobysoft.org>
//
//
// This file is part of the Dynamic Compact Control Language Library
// ("DCCL").
//
// DCCL is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 2.1 of the License, or
// (at your option) any later version.
//
// DCCL is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with DCCL.  If not, see <http://www.gnu.org/licenses/>.
#ifndef GenUnitsClassPlugin20150310H
#define GenUnitsClassPlugin20150310H
 
#include <google/protobuf/descriptor.h>
 
#include <boost/config/warning_disable.hpp>
#include <boost/lambda/lambda.hpp>
 
#include <boost/phoenix/bind.hpp>
#include <boost/phoenix/core.hpp>
#include <boost/phoenix/operator.hpp>
#include <boost/phoenix/stl.hpp>
 
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/qi_expect.hpp>
#include <boost/spirit/include/qi_lit.hpp>
 
#include <boost/algorithm/string/replace.hpp>
 
#include <iostream>
#include <set>
#include <sstream>
#include <string>
#include <vector>
 
#include <boost/bimap.hpp>
 
// Parsing methods for protobuf messages' units fields:
// base_dimensions, derived_dimensions, unit_system
 
namespace dccl
{
namespace units
{
namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;
namespace phoenix = boost::phoenix;
 
// Create a bimap of the available base dimensions
inline boost::bimap<std::string, char> make_dim_bimap()
{
    typedef boost::bimap<std::string, char> dim_bimap;
    using dimension = dim_bimap::value_type;
 
    dim_bimap dims;
    dims.insert(dimension("length", 'L'));
    dims.insert(dimension("time", 'T'));
    dims.insert(dimension("mass", 'M'));
    dims.insert(dimension("plane_angle", 'A'));
    dims.insert(dimension("solid_angle", 'S'));
    dims.insert(dimension("current", 'I'));
    dims.insert(dimension("temperature", 'K'));
    dims.insert(dimension("amount", 'N'));
    dims.insert(dimension("luminous_intensity", 'J'));
    dims.insert(dimension("information", 'B'));
    dims.insert(dimension("dimensionless", '-'));
 
    return dims;
}
 
// Create vectors of base dimension long and short strings from short (char) inputs
inline void push_char_base(std::vector<std::string>& vc, std::vector<std::string>& vs,
                           const char& c)
{
    vc.emplace_back(1, c);
 
    using bimap_type = boost::bimap<std::string, char>;
    bimap_type dim_bimap = make_dim_bimap();
 
    bimap_type::right_const_iterator it_right = dim_bimap.right.find(c);
 
    vs.push_back(it_right->second);
}
 
// Create vectors of base dimension long and short strings from long (string) inputs
inline void push_string_base(std::vector<std::string>& vc, std::vector<std::string>& vs,
                             const std::string& s)
{
    vs.push_back(s);
 
    using bimap_type = boost::bimap<std::string, char>;
    bimap_type dim_bimap = make_dim_bimap();
 
    bimap_type::left_const_iterator it_left = dim_bimap.left.find(s);
 
    vc.emplace_back(1, it_left->second);
}
 
// Make a vector of strings from char inputs (for creating the derived_dimensions operator vector)
inline void push_char(std::vector<std::string>& vc, const char& c) { vc.emplace_back(1, c); }
 
// Make a vector of strings from vector<char> inputs (for creating the derived_dimensions vector of strings)
inline void push_char_vec(std::vector<std::string>& vc, const std::vector<char>& c)
{
    vc.emplace_back(c.begin(), c.end());
}
 
// Returns the set of base dimension names that the given unit system supports.
// Returns an empty set for general systems (si, cgs) that support all dimensions.
// Specialized single-dimension systems (angle, temperature) return only their
// supported base dimensions.
inline std::set<std::string> get_system_supported_base_dimensions(const std::string& sysname)
{
    if (sysname == "angle::degree" || sysname == "degree" || sysname == "angle::gradian" ||
        sysname == "gradian" || sysname == "angle::revolution" || sysname == "revolution")
        return {"plane_angle", "dimensionless"};
    else if (sysname == "temperature::celsius" || sysname == "celsius" ||
             sysname == "temperature::fahrenheit" || sysname == "fahrenheit")
        return {"temperature", "dimensionless"};
    else
        return {}; // empty = general system (si, cgs, angle::radian, etc.)
}
 
// Validates that all dimension names in dim_names are compatible with the given system.
// Throws std::runtime_error if an incompatible combination is detected.
//
// Specialized systems (angle::degree, temperature::celsius, etc.) only support their
// native base dimension. Compound Boost Units dimension names (e.g. "angular_velocity",
// "pressure") require multiple base dimensions and cannot be used reliably with
// specialized systems because the missing base dimensions are silently treated as
// dimensionless, causing incorrect unit conversions.
inline void validate_dimensions_for_system(const std::vector<std::string>& dim_names,
                                           const std::string& sysname)
{
    const auto supported = get_system_supported_base_dimensions(sysname);
    if (supported.empty())
        return; // General system — all dimensions are supported
 
    const auto bimap = make_dim_bimap();
 
    for (const auto& dim : dim_names)
    {
        const bool is_base_dim = bimap.left.find(dim) != bimap.left.end();
        if (!is_base_dim)
        {
            // Compound Boost Units dimension (e.g. "angular_velocity", "pressure").
            // These require multiple base dimensions and cannot work correctly with
            // specialized single-dimension systems.
            throw std::runtime_error(
                "Dimension '" + dim +
                "' is a compound Boost Units dimension that requires multiple base "
                "dimensions, but system '" + sysname +
                "' only supports single-dimension units. Use a "
                "general system such as \"si\" or define a new system that includes the appropriate dimensions.");
        }
        else if (supported.find(dim) == supported.end())
        {
            // Known base dimension but not supported by this specialized system.
            std::string supported_list;
            for (const auto& s : supported)
            {
                if (!supported_list.empty())
                    supported_list += ", ";
                supported_list += "'" + s + "'";
            }
            throw std::runtime_error("Dimension '" + dim + "' is not supported by system '" +
                                     sysname + "'. That system only supports: " + supported_list +
                                     ".");
        }
    }
}
 
// Parser for base_dimensions input
template <typename Iterator>
bool parse_base_dimensions(Iterator first, Iterator last, std::vector<double>& base_dim_powers,
                           std::vector<std::string>& base_dim_chars,
                           std::vector<std::string>& base_dim_strings)
{
    //base_dim_chars = vc;
    //base_dim_strings = vs;
    //base_dim_powers = v;
 
    using ascii::space;
    using phoenix::push_back;
    using qi::_1;
    using qi::char_;
    using qi::double_;
    using qi::eps;
    using qi::phrase_parse;
 
    try
    {
        bool r = phrase_parse(
            first, /* start iterator */
            last,  /* end iterator */
            +((char_("LTMASIKNJB-")[phoenix::bind(&push_char_base, phoenix::ref(base_dim_chars),
                                                  phoenix::ref(base_dim_strings), _1)] |
               ((ascii::string("length") | ascii::string("time") | ascii::string("mass") |
                 ascii::string("plane_angle") | ascii::string("solid_angle") |
                 ascii::string("current") | ascii::string("temperature") | ascii::string("amount") |
                 ascii::string("luminous_intensity") | ascii::string("information") |
                 ascii::string("dimensionless"))[phoenix::bind(
                   &push_string_base, phoenix::ref(base_dim_chars), phoenix::ref(base_dim_strings),
                   _1)])) >>
              -(ascii::string("_base_dimension")) >>
              (('^' > double_[push_back(phoenix::ref(base_dim_powers), _1)]) |
               eps[push_back(phoenix::ref(base_dim_powers), 1)])),
            space /* the skip-parser */
        );
 
        if (first != last) // fail if we did not get a full match
            return false;
        return r;
    }
    catch (const std::runtime_error& e)
    {
        return false;
    }
}
 
// Parser for derived_dimensions input
template <typename Iterator>
bool parse_derived_dimensions(Iterator first, Iterator last,
                              std::vector<std::string>& derived_dim_operators,
                              std::vector<std::string>& derived_dim_strings)
{
    using ascii::space;
    using phoenix::push_back;
    using qi::_1;
    using qi::char_;
    using qi::double_;
    using qi::eps;
    using qi::phrase_parse;
 
    try
    {
        std::vector<std::string> params;
        bool r = boost::spirit::qi::parse(
            first, last,
            +((+char_("a-z1_"))[phoenix::bind(&push_char_vec, boost::phoenix::ref(params), _1)] >>
              -(*char_(" ") >>
                (char_("*/")[phoenix::bind(&push_char, phoenix::ref(derived_dim_operators), _1)] |
                 eps[push_back(phoenix::ref(derived_dim_operators), std::string("*"))]) >>
                *char_(" "))));
 
        if (derived_dim_operators.size())
            derived_dim_operators.pop_back();
 
        for (auto& param : params)
        {
            std::string::size_type dim_pos = param.find("_dimension");
            if (dim_pos != std::string::npos)
                param = param.substr(0, dim_pos);
            //std::cout << *it << std::endl;
            derived_dim_strings.push_back(param);
        }
 
        if (first != last) // fail if we did not get a full match
            return false;
        return r;
    }
    catch (const std::runtime_error& e)
    {
        return false;
    }
}
 
// Extract field type name as string
inline std::string get_field_type_name(google::protobuf::FieldDescriptor::CppType type)
{
    switch (type)
    {
        case google::protobuf::FieldDescriptor::CPPTYPE_INT32: return "google::protobuf::int32";
        case google::protobuf::FieldDescriptor::CPPTYPE_INT64: return "google::protobuf::int64";
        case google::protobuf::FieldDescriptor::CPPTYPE_UINT32: return "google::protobuf::uint32";
        case google::protobuf::FieldDescriptor::CPPTYPE_UINT64: return "google::protobuf::uint64";
        case google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE: return "double";
        case google::protobuf::FieldDescriptor::CPPTYPE_FLOAT: return "float";
        default: return "double";
    }
}
 
} // namespace units
} // namespace dccl
 
// Print units class plugin pieces to some type of ostream
 
// Example:
// ClassName (Range)
// fieldname (distance)
// sysname (si)
// dimtype_dimension (length_dimension)
 
// Boost Units - Dimensions Reference:
// http://www.boost.org/doc/libs/1_57_0/doc/html/boost_units/Reference.html#dimensions_reference
 
// Generate necessary units systems headers
inline void include_units_headers(const std::string& sysname, std::ostream& os)
{
    os << std::endl;
    /* os <<std::endl; */
    /* os <<"//===================" <<std::endl; */
    /* os <<std::endl; */
 
    // pre-defined systems from boost units:
    // http://www.boost.org/doc/libs/1_54_0/boost/units/systems/
 
    if (sysname == "si" || sysname == "boost::units::si" || sysname == "angle::radian")
    {
        os << "#include <boost/units/systems/si.hpp>" << std::endl;
    }
    else if (sysname == "cgs" || sysname == "boost::units::cgs")
    {
        os << "#include <boost/units/systems/cgs.hpp>" << std::endl;
    }
    else if (sysname == "celsius" || sysname == "boost::units::celsius" ||
             sysname == "temperature::celsius")
    {
        os << "#include <boost/units/systems/temperature/celsius.hpp>" << std::endl;
    }
    else if (sysname == "fahrenheit" || sysname == "boost::units::fahrenheit" ||
             sysname == "temperature::fahrenheit")
    {
        os << "#include <boost/units/systems/temperature/fahrenheit.hpp>" << std::endl;
    }
    else if (sysname == "degree" || sysname == "boost::units::degree" || sysname == "angle::degree")
    {
        os << "#include <boost/units/systems/angle/degrees.hpp>" << std::endl;
    }
    else if (sysname == "gradian" || sysname == "boost::units::gradian" ||
             sysname == "angle::gradian")
    {
        os << "#include <boost/units/systems/angle/gradians.hpp>" << std::endl;
    }
    else if (sysname == "revolution" || sysname == "boost::units::revolution" ||
             sysname == "angle::revolution")
    {
        os << "#include <boost/units/systems/angle/revolutions.hpp>" << std::endl;
    }
    else
    {
        //include necessary non-boost-units system headers
        std::string sysname_sub = boost::replace_all_copy(sysname, "::", "/");
        os << "#include \"" << sysname_sub << ".hpp\"" << std::endl;
    }
}
 
// Generate necessary units systems headers for an individually defined base unit.
// Unit must be available in this list:
// http://www.boost.org/doc/libs/1_57_0/doc/html/boost_units/Reference.html#boost_units.Reference.alphabetical_listing_of_base_units
inline void include_base_unit_headers(const std::string& base_unit_category_and_name,
                                      std::ostream& os)
{
    os << std::endl;
    std::string cat_name_sub = boost::replace_all_copy(base_unit_category_and_name, "::", "/");
    os << "#include <boost/units/base_units/" << cat_name_sub << ".hpp>" << std::endl;
}
 
inline void include_custom_unit_headers(const std::string& header, std::ostream& os)
{
    os << std::endl;
    os << "#include \"" << header << "\"" << std::endl;
}
 
inline void add_absolute(std::string& before, std::string& after)
{
    before = "boost::units::absolute<" + before;
    after += "> ";
}
 
inline void add_prefix(const std::string& prefix, std::string& before, std::string& after)
{
    int power = 1;
    if (prefix == "yotta")
        power = 24;
    else if (prefix == "zetta")
        power = 21;
    else if (prefix == "exa")
        power = 18;
    else if (prefix == "peta")
        power = 15;
    else if (prefix == "tera")
        power = 12;
    else if (prefix == "giga")
        power = 9;
    else if (prefix == "mega")
        power = 6;
    else if (prefix == "kilo")
        power = 3;
    else if (prefix == "hecto")
        power = 2;
    else if (prefix == "deka")
        power = 1;
    else if (prefix == "deci")
        power = -1;
    else if (prefix == "centi")
        power = -2;
    else if (prefix == "milli")
        power = -3;
    else if (prefix == "micro")
        power = -6;
    else if (prefix == "nano")
        power = -9;
    else if (prefix == "pico")
        power = -12;
    else if (prefix == "femto")
        power = -15;
    else if (prefix == "atto")
        power = -18;
    else if (prefix == "zepto")
        power = -21;
    else if (prefix == "yocto")
        power = -24;
    else
        throw(std::runtime_error(std::string("Invalid SI prefix: " + prefix)));
 
    std::stringstream power_ss;
    power_ss << power;
 
    before = "boost::units::make_scaled_unit<" + before;
    after += ", boost::units::scale<10, boost::units::static_rational<" + power_ss.str() +
             "> > >::type ";
}
 
// Generate a unit typedef when given derived_ or base_dimensions
inline void construct_units_typedef_from_dimension(const std::string& fieldname,
                                                   const std::string& sysname, const bool& absolute,
                                                   const std::string& prefix, std::ostream& os)
{
    // Namespace the sysname if necessary
    std::string sysname_ns;
    if (sysname == "si" || sysname == "cgs" || sysname == "celsius" || sysname == "fahrenheit" ||
        sysname == "degree" || sysname == "gradian" || sysname == "revolution")
        sysname_ns = "boost::units::" + sysname + "::system";
    else if (sysname == "boost::units::si" || sysname == "boost::units::cgs")
        sysname_ns = sysname + "::system";
    else if (sysname == "temperature::celsius" || sysname == "temperature::fahrenheit")
        sysname_ns = boost::replace_all_copy(sysname, "temperature::", "boost::units::");
    else if (sysname == "angle::degree" || sysname == "angle::gradian" ||
             sysname == "angle::revolution")
        sysname_ns = boost::replace_all_copy(sysname, "angle::", "boost::units::") + "::system";
    else if (sysname == "angle::radian")
        sysname_ns = "boost::units::si::system";
    else
        sysname_ns = sysname;
 
    std::string before;
    std::string after;
 
    if (absolute && !prefix.empty())
        throw(std::runtime_error(
            std::string("'prefix' is not supported with an absolute temperature field")));
 
    if (absolute)
        add_absolute(before, after);
 
    if (!prefix.empty())
        add_prefix(prefix, before, after);
 
    // Typedef the unit
    os << "typedef " << before << "boost::units::unit<" << fieldname << "_dimension," << sysname_ns
       << "> " << after << fieldname << "_unit;" << std::endl;
    os << std::endl;
}
 
// Generate a dimension typedef when given base_dimensions
inline void construct_base_dims_typedef(const std::vector<std::string>& dim_vec,
                                        const std::vector<double>& power_vec,
                                        const std::string& fieldname, const std::string& sysname,
                                        const bool& rel_temperature, const std::string& prefix,
                                        std::ostream& os)
{
    bool temperature_dimension = false;
    if (dim_vec[0] == "temperature" && dim_vec.size() == 1)
        temperature_dimension = true;
    if (dim_vec[0] == "dimensionless" && dim_vec.size() == 1)
    {
        os << "typedef boost::units::dimensionless_type " << fieldname << "_dimension;"
           << std::endl;
        ;
    }
    else
    {
        os << "typedef boost::units::derived_dimension< ";
        for (std::size_t i = 0, n = dim_vec.size(); i < n; i++)
        {
            os << "boost::units::" << dim_vec[i] << "_base_dimension," << power_vec[i];
            if (i != dim_vec.size() - 1)
                os << ", ";
        }
        os << " >::type " << fieldname << "_dimension;" << std::endl;
    }
    os << std::endl;
 
    construct_units_typedef_from_dimension(fieldname, sysname,
                                           temperature_dimension && !rel_temperature, prefix, os);
}
 
// Generate a dimension typedef when given derived_dimensions
inline void construct_derived_dims_typedef(const std::vector<std::string>& dim_vec,
                                           const std::vector<std::string>& operator_vec,
                                           const std::string& fieldname, const std::string& sysname,
                                           const bool& rel_temperature, const std::string& prefix,
                                           std::ostream& os)
{
 
    bool temperature_dimension = false;
 
    if (dim_vec.size() == 1)
    {
        if (dim_vec[0] == "temperature")
            temperature_dimension = true;
        if (dim_vec[0] == "dimensionless")
            os << "typedef boost::units::dimensionless_type " << fieldname << "_dimension;"
               << std::endl;
        else
            os << "typedef boost::units::" << dim_vec[0] << "_dimension " << fieldname
               << "_dimension;" << std::endl;
    }
    else
    { //construct new dimension type with mpl divides/times calls based on operators and powers
        //see example here:
        //http://www.boost.org/doc/libs/1_57_0/doc/html/boost_units/Examples.html#boost_units.Examples.DimensionExample
        os << "typedef ";
        std::string result = dim_vec[0];
        for (std::size_t i = 0, n = operator_vec.size(); i < n; i++)
        {
            if (operator_vec[i] == "/")
                result = "boost::mpl::divides<boost::units::" + result +
                         "_dimension,boost::units::" + dim_vec[i + 1] + "_dimension>::type";
            else if (operator_vec[i] == "*")
                result = "boost::mpl::times<boost::units::" + result +
                         "_dimension,boost::units::" + dim_vec[i + 1] + "_dimension>::type";
        }
        os << result << " " << fieldname << "_dimension;" << std::endl;
    }
    os << std::endl;
 
    construct_units_typedef_from_dimension(fieldname, sysname,
                                           temperature_dimension && !rel_temperature, prefix, os);
}
 
//=============VVVV
 
//===========
// Generate a unit typedef when given base_unit
inline void construct_units_typedef_from_base_unit(const std::string& fieldname,
                                                   const std::string& base_unit_category_and_name,
                                                   const bool& rel_temperature,
                                                   const std::string& prefix, std::ostream& os)
{
    bool temperature_unit = false;
 
    //expect to see "temperature::celsius" or "temperature::fahrenheit" or "si::kelvin"
    if ((base_unit_category_and_name.find("temperature") != std::string::npos) ||
        (base_unit_category_and_name.find("kelvin") != std::string::npos))
        temperature_unit = true;
 
    bool absolute = temperature_unit && !rel_temperature;
 
    std::string before;
    std::string after;
    if (absolute)
        add_absolute(before, after);
 
    if (!prefix.empty())
        add_prefix(prefix, before, after);
 
    // Namespace and typedef the unit
    os << "typedef " << before << "boost::units::" << base_unit_category_and_name
       << "_base_unit::unit_type " << after << fieldname << "_unit;" << std::endl;
 
    os << std::endl;
}
 
//===========
// Generate a unit typedef when given custom unit
inline void construct_units_typedef_from_custom_unit(const std::string& fieldname,
                                                     const std::string& unit_name,
                                                     const bool& rel_temperature,
                                                     const std::string& prefix, std::ostream& os)
{
    bool temperature_unit = false;
 
    //expect to see "temperature::celsius" or "temperature::fahrenheit" or "si::kelvin"
    if ((unit_name.find("temperature") != std::string::npos) ||
        (unit_name.find("kelvin") != std::string::npos))
        temperature_unit = true;
 
    bool absolute = temperature_unit && !rel_temperature;
 
    std::string before;
    std::string after;
    if (absolute)
        add_absolute(before, after);
 
    if (!prefix.empty())
        add_prefix(prefix, before, after);
 
    // Namespace and typedef the unit
    os << "typedef " << before << unit_name << " " << after << fieldname << "_unit;" << std::endl;
    os << std::endl;
}
 
//===========
// Generate the body of the units plugin for the message class
inline void construct_field_class_plugin(const std::string& fieldname, std::ostream& os,
                                         const std::string& value_type, bool is_repeated)
{
 
    // Overloading set_fieldname to accept boost units, i.e. quantity<unit<fieldname_dimension,sysname::system> >
    os << "template<typename Quantity >" << std::endl;
    os << "  void set_" << fieldname << "_with_units(";
    if (is_repeated)
        os << "int index, ";
    os << "Quantity value_w_units)" << std::endl;
    os << "  { set_" << fieldname << "(";
    if (is_repeated)
        os << "index, ";
    os << "boost::units::quantity<" << fieldname << "_unit," << value_type
       << " >(value_w_units).value() ); };" << std::endl;
    os << std::endl;
 
    if (is_repeated)
    {
        os << "template<typename Quantity >" << std::endl;
        os << "  void add_" << fieldname << "_with_units(Quantity value_w_units)" << std::endl;
        os << "  { add_" << fieldname << "(boost::units::quantity<" << fieldname << "_unit,"
           << value_type << " >(value_w_units).value() ); };" << std::endl;
        os << std::endl;
    }
 
    //returns whatever units are requested
    os << "template<typename Quantity >" << std::endl;
    os << "  Quantity " << fieldname << "_with_units(";
    if (is_repeated)
        os << "int index";
    os << ") const" << std::endl;
    os << "  { return Quantity(" << fieldname << "(";
    if (is_repeated)
        os << "index";
    os << ") * " << fieldname << "_unit()); };" << std::endl;
    os << std::endl;
 
    //returns same units only
    os << "boost::units::quantity< " << fieldname << "_unit," << value_type << " > " << fieldname
       << "_with_units(";
    if (is_repeated)
        os << "int index";
    os << ") const" << std::endl;
    os << "  { return " << fieldname << "_with_units<boost::units::quantity< " << fieldname
       << "_unit," << value_type << " > >(";
    if (is_repeated)
        os << "index";
    os << "); };" << std::endl;
    os << std::endl;
}
 
//=============^^^^
 
#endif