FXUnits.h

/********************************************************************************
*                                                                               *
*                        U n i t - C o n v e r s i o n s                        *
*                                                                               *
*********************************************************************************
* Copyright (C) 2026 by Jeroen van der Zijp.   All Rights Reserved.             *
*********************************************************************************
* This library 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 3 of the License, or             *
* (at your option) any later version.                                           *
*                                                                               *
* This library 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 this program.  If not, see <http://www.gnu.org/licenses/>          *
********************************************************************************/
#ifndef FXUNITS_H
#define FXUNITS_H

namespace FX {


class FXAPI FXUnits {
private:
  FXdouble m;           // Scale
  FXdouble a;           // Offset
public:
  enum {
    GRAM,               // Mass
    METER,              // Length
    AMPERE,             // Current
    CANDELA,            // Luminous flux
    MOLE,               // Mole
    RADIAN,             // Angles
    STERADIAN,          // Solid angles
    SECOND,             // Time
    KELVIN,             // Temperature / Kelvin
    CELSIUS,            // Temperature / Celsius
    FAHRENHEIT,         // Temperature / Fahrenheit
    RANKINE,            // Temperature / Rankine
    };
  enum {
    NumUnits=134        // Total number of units
    };
public:

  static const FXchar symbol[NumUnits][8];

  static const FXdouble factor[NumUnits];

  static const FXchar expression[NumUnits][16];
private:
  struct Conv;
  static const char* divex(const FXchar* unit,Conv& u);
  static const FXchar* unitex(const FXchar* unit,Conv& u);
  static const FXchar* scalex(const FXchar* unit,Conv& u);
  static const FXchar* powex(const FXchar* unit,Conv& u);
  static const FXchar* mulex(const FXchar* unit,Conv& u);
public:

  FXUnits():m(1.0),a(0.0){ }

  FXUnits(FXdouble mm,FXdouble aa=0.0):m(mm),a(aa){ }

  FXUnits(const FXUnits& org):m(org.m),a(org.a){ }

  operator FXbool() const { return (m || a); }

  void scale(FXdouble mm){ m=mm; }
  FXdouble scale() const { return m; }

  void offset(FXdouble aa){ a=aa; }
  FXdouble offset() const { return a; }

  FXUnits& operator=(const FXUnits& org){m=org.m;a=org.a;return *this;}

  FXdouble operator()(FXdouble x) const { return x*m+a; }

  FXUnits invert() const { return FXUnits(1.0/m,-a/m); }

  static FXint lookup(const FXchar* unit);
  static FXint lookup(const FXString& unit);

  static FXint span(const FXchar* unit);
  static FXint span(const FXString& unit);

  static FXulong dimensions(const FXchar* unit);
  static FXulong dimensions(const FXString& unit);

  static FXString canonical(FXulong dims);

  static FXString canonical(const FXchar* unit);
  static FXString canonical(const FXString& unit);

  static FXUnits convertFromTo(const FXchar* srcUnit,const FXchar* dstUnit=nullptr);
  static FXUnits convertFromTo(const FXString& srcUnit,const FXchar* dstUnit=nullptr);
  static FXUnits convertFromTo(const FXchar* srcUnit,const FXString& dstUnit);
  static FXUnits convertFromTo(const FXString& srcUnit,const FXString& dstUnit);

  static FXUnits convertToFrom(const FXchar* dstUnit,const FXchar* srcUnit=nullptr);
  static FXUnits convertToFrom(const FXString& dstUnit,const FXchar* srcUnit=nullptr);
  static FXUnits convertToFrom(const FXchar* dstUnit,const FXString& srcUnit);
  static FXUnits convertToFrom(const FXString& dstUnit,const FXString& srcUnit);

  static FXUnits convertFromToDims(const FXchar* srcUnit,FXulong dims);
  static FXUnits convertFromToDims(const FXString& srcUnit,FXulong dims);

  static FXUnits convertToFromDims(const FXchar* dstUnit,FXulong dims);
  static FXUnits convertToFromDims(const FXString& dstUnit,FXulong dims);

  };

}

#endif