Forward Declarations of recursive templates using Boost::Units

Question

as i am seeking to reduce the compile times of our code, i am currently trying to reduce heavy includes in header files. For this, i am forward declaring function parameters as in this example:

// Class A.h
class B;

class A
{
   ...
   void foo(B);
}

However, i did not find a way to forward declare our typedefinitions, that rely on boost units such as the definition of a length unit (Length.h) required as a function parameter in the file Object.h:

// Length.h
using meter_unit = boost::units::si::meter_base_unit::unit_type;
using Length = boost::units::quantity<meter_unit, double>;
BOOST_UNITS_STATIC_CONSTANT(Meter, meter_unit);
BOOST_UNITS_STATIC_CONSTANT(Meters, meter_unit)

// Object.h
#include <Length.h> // This include shall be avoided

class Position; 
class Object {
 ... 

    bool isNearby(Position pos, Length distance); 
}

Are there any suggestions on how i could achieve this?

What I Tried:

First Approach: I tried forward declaring the template boost::units::quantity<meter_unit, double>; but i struggeld to define the meter_unit that contains both template class meter_base_unit and unit_type inside the namespace of meter_unit.

The meter_base_unit is defined inside boost units as below (simplified) and i guess the unit_type is defined inside the macro BOOST_TYPEOF_REGISTER_TYPE.

// Boost ... Units/Meter.hpp
namespace boost::units::si {
    struct meter_base_unit : public base_unit<meter_base_unit, length_dimension, -9>
    {
        static std::string name()   { return("meter"); }
        static std::string symbol() { return("m"); }
        };
    }
}
BOOST_TYPEOF_REGISTER_TYPE(boost::units::si::meter_base_unit)

Is such a constellation even possible to forward declare? And if not, do alternatives exist that could have the same benefit (avoided include while still using the Boost Units Library).

Second Approach: Defining classes that inherit from the respective units such as:

class Length : public boost::units::quantity<meter_unit, double>

but the problem is, that i then have to create CTR for every possible unit that i try to initialize the Length unit with (Feet, Meter, Kilometer a.s.o), which is basically re-implementing the library.

Third Approach: Creating a class that contains only the length unit as a variable, which then leads to overloading all possible operators for that class.

I am happy for every contribution regarding my specific problem and every contribution leading to deeper understanding of template forward declarations.

Thanks in Advance

SegfaultCreator

Forward Declarations of recursive templates using Boost::Units

0 Answers0