My current project has several coordinate systems.  These include Polar(azimuth, elevation, range) and LLA (latitude, longitude, altitude).  I've really enjoyed using boost units to allow the user to input the required unit system but converting them behind the scenes to the unit system I need.  I'm developing a function overload that lets the user call a single function but based on the coordinate system given the function behaves differently.  Unfortunately, the units for Polar and LLA are the same.  Both systems use two plane angles and a length.  A second problem is two different groups use two different ways of talking about the Polar coordinate system.  One group defines Polar as azimuth, elevation and range while the other group defines Polar as range, azimuth and elevation.  I want to give both group the ability to call the function with the Polar definition they are used to talking about.
 
I realize I could create a class for Polar and LLA and then pass that class to my overloaded function.  This just pushes off the second problem to the newly created classes.  Instead of creating classes for the coordinate systems I wanted to differentiate the different boost units from each other.  This would let me overload my function without the need to create larger classes for each coordinate system.
 
I ended up modifying the "true_typedef" class from StlSoft that wraps a type so it becomes incompatible with the same types.  This allowed me, for example, to wrap a boost unit plane angle into a longitude and latitude that wouldn't be compatible with each other. 
 
What I don't like about this process is having to define a structure type and then using it in the typedef.  Is there a boost library that would allow me to create this class in one pass without the two step process?
 
Ryan
 
 
#define STLSOFT_GEN_OPAQUE(type)  typedef struct __stlsoft_htype##{ int i; } const* type;
 
using namespace boost::units;
 
template<typename T, typename U>
class BoostUnitQuantityWrapper
{
  typedef T                               unit_type;
  typedef U                               unique_type;
  typedef BoostUnitQuantityWrapper<T, U>  class_type;
 
  quantity<unit_type>                     m_Value;
 
public:
  template<class System>
  explicit BoostUnitQuantityWrapper (
    quantity< unit< typename unit_type::dimension_type, System> > const& value)
    : m_Value(quantity<unit_type>(value)) {}
 
  BoostUnitQuantityWrapper(class_type const& rhs)
    : m_Value(rhs.m_Value) {}
 
  class_type const& operator= (class_type const& rhs) {
    m_Value = rhs.m_Value;
    return *this;
  }
 
  operator quantity<unit_type> () const { return m_Value; }
};
 
STLSOFT_GEN_OPAQUE(latitude_type);
STLSOFT_GEN_OPAQUE(longitude_type);
STLSOFT_GEN_OPAQUE(range_type);
STLSOFT_GEN_OPAQUE(altitude_type);
 
typedef BoostUnitQuantityWrapper<si::plane_angle, latitude_type>  Latitude;
typedef BoostUnitQuantityWrapper<si::plane_angle, longitude_type>  Longitude;
 
typedef BoostUnitQuantityWrapper<si::length, range_type> Range;
typedef BoostUnitQuantityWrapper<si::length, altitude_type> Altitude;