/////////////////////////////////////////////////////////
// tunit.h: Units class definition
// This class provides for a units type class permiting
// I/O and calculations with physical units. Internal
// representation of the class defaults to SI. Other
// units provided by member functions.
// Copyright(c) 1993 J.N.Hinckel. All rights reserved.
/////////////////////////////////////////////////////////

#ifndef TUNIT_H
#define TUNIT_H

#include <iostream>
#include <string>
#include <vector>

// defines a structure to hold a double and a string

using namespace std;
struct cv {

double cvalue;
string unit;
};

class Tunit {
    //  stream I/O operators
    friend ostream & operator << (ostream &, const Tunit &);

    // console input interface
    friend Tunit & CLInput(Tunit & tu, string msg );

public:
	// Constructors and assignment
    Tunit(const Tunit &);               // copy constructor
    Tunit& operator=(const Tunit &);    // assignment operator
    Tunit &operator[](int L) {index = L; return *this;};  // change default unit
    virtual double operator()(int L) const;   // returns value in given unit
    operator double () {return value;};    // returns value in SI
    void SetIndex(int i){index = i;}       // change unit type
    virtual void SetValue(double v);       // set value of unit
    void GetStringVector(vector <string> &); // set a vector with strings

protected:

    double value;
    int index;
    cv *table;
    Tunit(double val, int ind, cv *tbl) :
        value(val),
        index(ind),
        table(tbl)
    {};
};


class Tlength : public Tunit {

public:

	// define enum tag to select proper unit//
	enum LENGTH {m,mm,cm,km,in,ft,yd,mile,nm,au};

	// constructor
	Tlength(double val=0, LENGTH L=m):
	Tunit(val*Length[L].cvalue,L,Length) {}
	
private:

	static cv* Length;
};


class Tmass : public Tunit {

	
public:

	enum MASS {kg,g,lb,slug,ton};
	
	Tmass(double val=0, MASS M = kg):
	Tunit(val*Mass[M].cvalue,M,Mass) {}

private:

	static cv* Mass;
};

class TmassFlux : public Tunit {

	
public:

    enum MASSFLUX {kgpmsqps,gpcmsqps,lbpinsqps,lbpftsqps};

TmassFlux(double val=0, MASSFLUX enm = kgpmsqps):
    Tunit(val*Massflux[enm].cvalue,enm,Massflux) {}
	
private:

    static cv* Massflux;
};

class TmassFlowRate : public Tunit {

	
public:

    enum MASSFLOWRATE {kgps,gps,lbps};
	
    TmassFlowRate(double val=0, MASSFLOWRATE enm = kgps):
    Tunit(val*Massflowrate[enm].cvalue,enm,Massflowrate) {}
	
private:

    static cv *Massflowrate;
};

class Ttime : public Tunit {

	
public:

    enum TIME {s,min,hr,day,yr};
	
 Ttime(double val=0, TIME enm = s):
     Tunit(val*Time[enm].cvalue,enm,Time) {}

private:

    static cv *Time;
};

class Tarea : public Tunit {

	
public:
    enum AREA {msq,cmsq,mmsq,insq,ftsq};

Tarea(double val=0, AREA enm = msq):
    Tunit(val*Area[enm].cvalue,enm,Area) {}

private:

    static cv *Area;
};

class TspecificArea : public Tunit {

	
public:
    enum SPECIFICAREA {msqpmcb,cmsqpcmcb,insqpincb,ftsqpftcb};

TspecificArea(double val=0, SPECIFICAREA enm = msqpmcb):
    Tunit(val*Specificarea[enm].cvalue,enm,Specificarea) {}
	
private:

    static cv *Specificarea;
};

class Tvolume : public Tunit {

	
public:
    enum VOLUME {mcb,l,cmcb,incb,ftcb,gal};

Tvolume(double val=0, VOLUME enm = mcb):
    Tunit(val*Volume[enm].cvalue,enm,Volume) {}
	
private:

    static cv *Volume;
};

class Tacceleration : public Tunit {

	
public:
    enum ACCELERATION {mpssq,ftpssq,inpssq};

Tacceleration(double val=0, ACCELERATION enm = mpssq):
    Tunit(val*Acceleration[enm].cvalue,enm,Acceleration) {}
	
private:

    static cv *Acceleration;
};

class Tvelocity : public Tunit {

	
public:
    enum VELOCITY {mps,ftps,kmps,kmphr,milephr};

Tvelocity(double val=0, VELOCITY enm = mps):
    Tunit(val*Velocity[enm].cvalue,enm,Velocity) {}
private:

    static cv *Velocity;

};

class Tdensity : public Tunit {

	
public:
    enum DENSITY {kgpmcb,gpcmcb,lbpincb,lbpftcb,slugpftcb};

Tdensity(double val=0, DENSITY enm = kgpmcb):
    Tunit(val*Density[enm].cvalue,enm,Density) {}
	
    static cv *Density;
};

class Tenergy : public Tunit {

	
public:
    enum ENERGY {J,erg,cal,cal_th,Btu,Btu_th,ftlb,Whr,kWhr};

Tenergy(double val=0, ENERGY enm = J):
    Tunit(val*Energy[enm].cvalue,enm,Energy) {}

private:

    static cv *Energy;
};

class TenergyFlux : public Tunit {

	
public:
    enum ENERGYFLUX {Wpmsq,ergpcmsqps,ergpspcmsq=ergpcmsqps,
    calpcmsqps,cal_thpcmsqps,Btupftsqps,Btupftsqphr};

TenergyFlux(double val=0, ENERGYFLUX enm = Wpmsq):
    Tunit(val*Energyflux[enm].cvalue,enm,Energyflux) {}
	
private:

    static cv *Energyflux;
};

class Tforce : public Tunit {

	
public:
    enum FORCE {N,kN,dyne,kgf,lbf,ton};

Tforce(double val=0, FORCE enm = N):
    Tunit(val*Force[enm].cvalue,enm,Force) {}

private:

    static cv *Force;
};

class TheatTransferCoefficient : public Tunit {

	
public:
    enum HEATTRANSFERCOEFFICIENT {WpmsqpK,calpcmsqpspK,BtupftsqpspR,BtupftsqphrpR};

TheatTransferCoefficient(double val=0, HEATTRANSFERCOEFFICIENT enm = WpmsqpK):
    Tunit(val*Heattransfercoefficient[enm].cvalue,enm,Heattransfercoefficient) {}
	
private:

	static cv *Heattransfercoefficient;
};

class TkinematicViscosity : public Tunit {

	
public:
    enum KINEMATICVISCOSITY {msqps,centistoke,stoke,insqps,ftsqps};

TkinematicViscosity(double val=0, KINEMATICVISCOSITY enm = msqps):
    Tunit(val*Kinematicviscosity[enm].cvalue,enm,Kinematicviscosity) {}

private:

    static cv *Kinematicviscosity;
};

class Tpower : public Tunit {

	
public:
    enum POWER {W,kW,calps,Btuphr,Btups,ftlbfps,hp};

Tpower(double val=0, POWER enm = W):
    Tunit(val*Power[enm].cvalue,enm,Power) {}

private:

    static cv *Power;
};

class Tpressure : public Tunit {

	
public:
    enum PRESSURE {Pa,kPa,MPa,Bar,dynepcmsq,psi,lbfpftsq,torr,mmHg=torr,mmH2O,atm};

Tpressure(double val=0, PRESSURE enm = Pa):
    Tunit(val*Pressure[enm].cvalue,enm,Pressure) {}

private:

    static cv *Pressure;
};

class TspecificEnergy : public Tunit {

	
public:
    enum SPECIFICENERGY {Jpkg,kJpkg,calpg,kcalpkg,Btuplb};

TspecificEnergy(double val=0, SPECIFICENERGY enm = Jpkg):
    Tunit(val*Specificenergy[enm].cvalue,enm,Specificenergy) {}

private:

    static cv *Specificenergy;
};

class TspecificHeat : public Tunit {

	
public:
    enum SPECIFICHEAT {JpkgpK,kJpkgpK,calpgpK,BtuplbpR};

TspecificHeat(double val=0, SPECIFICHEAT enm = JpkgpK):
    Tunit(val*Specificheat[enm].cvalue,enm,Specificheat) {}

private:

    static cv *Specificheat;
};

class TthermalConductivity : public Tunit {

	
public:
    enum THERMALCONDUCTIVITY {WpmpK,calpspcmpK,calpcmpspK=calpspcmpK,
    BtuphrpftpR,kcalphrpmpK};

TthermalConductivity(double val=0, THERMALCONDUCTIVITY enm = WpmpK):
    Tunit(val*Thermalconductivity[enm].cvalue,enm,Thermalconductivity) {}

private:

    static cv *Thermalconductivity;
};

class Tviscosity : public Tunit {

	
public:
    enum VISCOSITY {Pas,cP,poise,lbpinps,lbpftps,lbpftphr};

Tviscosity(double val=0, VISCOSITY enm = Pas):
    Tunit(val*Viscosity[enm].cvalue,enm,Viscosity) {}

private:

    static cv *Viscosity;
};

class TvolumeFlowRate : public Tunit {

	
public:
    enum VOLUMEFLOWRATE {mcbps,lps,ftcbps,ftcbpmin,gpm};

TvolumeFlowRate(double val=0, VOLUMEFLOWRATE enm = mcbps):
    Tunit(val*Volumeflowrate[enm].cvalue,enm,Volumeflowrate) {}

private:

    static cv *Volumeflowrate;
};

class Ttemperature : public Tunit {

public:
    enum TEMPERATURE {K,C,R,F};

Ttemperature(double val =0, TEMPERATURE enm = K):
    Tunit((val+toffset[enm])*Temperature[enm].cvalue,enm,Temperature) {}
    double operator () (int enm ) const;
    virtual void SetValue(double v);

private:

    static cv *Temperature;
    static double *toffset;

};


#endif // TUNIT_H