#ifndef REPOSITORY_H
#define REPOSITORY_H 1
//------------------------------------------------------------------------------

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

//------------------------------------------------------------------------------

class repository {
   void defaultVersion(double *d) { mtDV = d[0]; }

   void frontRPM(double *d) { lofRPM = d[0]; hifRPM = d[1]; rdfRPM = d[2]; }
   void frontMAP(double *d) { lofMAP = d[0]; hifMAP = d[1]; rdfMAP = d[2]; }
   void frontMAT(double *d) { lofMAT = d[0]; hifMAT = d[1]; rdfMAT = d[2]; }
   void frontTP (double *d) { lofTP  = d[0]; hifTP  = d[1]; rdfTP  = d[2]; }
   void frontPW (double *d) { lofPW  = d[0]; hifPW  = d[1]; rdfPW  = d[2]; }
   void frontDC (double *d) { lofDC  = d[0]; hifDC  = d[1]; rdfDC  = d[2]; }

   void runEGO(double *d) { lorEGO = d[0]; hirEGO = d[1]; }
   void runCT (double *d) { lorCT  = d[0]; hirCT  = d[1]; }
   void runBAT(double *d) { lorBAT = d[0]; hirBAT = d[1]; }
   void runTR (double *d) { lorTR  = d[0]; hirTR  = d[1]; }
   void runGE (double *d) { lorGE  = d[0]; hirGE  = d[1]; }
   void runMAP(double *d) { lorMAP = d[0]; hirMAP = d[1]; }
   void runMAT(double *d) { lorMAT = d[0]; hirMAT = d[1]; }
   void runRPM(double *d) { lorRPM = d[0]; hirRPM = d[1]; }
   void runPW (double *d) { lorPW  = d[0]; hirPW  = d[1]; }
   void runDC (double *d) { lorDC  = d[0]; hirDC  = d[1]; }
   void runEGC(double *d) { lorEGC = d[0]; hirEGC = d[1]; }
   void runBC (double *d) { lorBC  = d[0]; hirBC  = d[1]; }
   void runWC (double *d) { lorWC  = d[0]; hirWC  = d[1]; }
   void runADC(double *d) { lorADC = d[0]; hirADC = d[1]; }
   void runVE (double *d) { lorVE  = d[0]; hirVE  = d[1]; }
   void runACC(double *d) { lorACC = d[0]; hirACC = d[1]; }

   void tuneRPM(double *d) { lotRPM = d[0]; hitRPM = d[1]; rdtRPM = d[2]; }
   void tuneMAP(double *d) { lotMAP = d[0]; hitMAP = d[1]; rdtMAP = d[2]; }
   void tuneTR (double *d) { lotTR  = d[0]; hitTR  = d[1]; rdtTR  = d[2]; }
   void tuneEGO(double *d) { lotEGO = d[0]; hitEGO = d[1]; rdtEGO = d[2]; }
   void tuneWU (double *d) { lotWU  = d[0]; hitWU  = d[1]; rdtWU  = d[2]; }
   void tuneVEG(double *d) { lotVEG = d[0]; hitVEG = d[1]; rdtVEG = d[2]; }
   void tuneACE(double *d) { lotACE = d[0]; hitACE = d[1]; rdtACE = d[2]; }
   void tuneVEB(double *d) { lotVEB = d[0]; hitVEB = d[1];                }

   void readInit(); // Parses and processes megatune.ini.

public:
   repository();
   virtual ~repository();

   double mtDV; // Default version number when not connected.

   double lofRPM;
   double hifRPM;
   double rdfRPM;

   double lofMAP;
   double hifMAP;
   double rdfMAP;

   double lofMAT;
   double hifMAT;
   double rdfMAT;

   double lofTP;
   double hifTP;
   double rdfTP;

   double lofPW;
   double hifPW;
   double rdfPW;

   double lofDC;
   double hifDC;
   double rdfDC;

   double lorEGO;
   double hirEGO;

   double lorCT;
   double hirCT;

   double lorBAT;
   double hirBAT;

   double lorTR;
   double hirTR;

   double lorGE;
   double hirGE;

   double lorMAP;
   double hirMAP;

   double lorMAT;
   double hirMAT;

   double lorRPM;
   double hirRPM;

   double lorPW;
   double hirPW;

   double lorDC;
   double hirDC;

   double lorEGC;
   double hirEGC;

   double lorBC;
   double hirBC;

   double lorWC;
   double hirWC;

   double lorADC;
   double hirADC;

   double lorVE;
   double hirVE;

   double lorACC;
   double hirACC;

   double lotRPM;
   double hitRPM;
   double rdtRPM;

   double lotMAP;
   double hitMAP;
   double rdtMAP;

   double lotTR;
   double hitTR;
   double rdtTR;

   double lotEGO;
   double hitEGO;
   double rdtEGO;

   double lotWU;
   double hitWU;
   double rdtWU;

   double lotVEG;
   double hitVEG;
   double rdtVEG;

   double lotACE;
   double hitACE;
   double rdtACE;

   double lotVEB;
   double hitVEB;
};

//------------------------------------------------------------------------------
#endif