ROOT logo
#ifndef __TMrbVar_h__
#define __TMrbVar_h__

//_________________________________________________[C++ CLASS DEFINITION FILE]
//////////////////////////////////////////////////////////////////////////////
// Name:           utils/inc/TMrbVar.h
// Purpose:        Define named variables
// Classes:        TMrbVariable             -- base class for variables
//                 TMrbVarI                 -- user-defined variables:     integer
//                 TMrbVarF                 -- ... float/double
//                 TMrbVarS                 -- ... string
//                 TMrbVarB                 -- ... boolean
//                 TMrbVarArrayI            -- a variable containing an array of ints
//                 TMrbVarArrayF            -- ... floats/double
// Description:    Common class definitions to be used within MARaBOU
// Author:         R. Lutter
// Revision:       $Id: TMrbVar.h,v 1.5 2005-09-09 06:59:14 Rudolf.Lutter Exp $       
// Date:           
// Keywords:
//////////////////////////////////////////////////////////////////////////////

#include "TNamed.h"
#include "TArrayI.h"
#include "TArrayD.h"
#include "TString.h"
#include "TSystem.h"

#include "TMrbNamedX.h"
#include "TMrbLofNamedX.h"
#include "TMrbVarWdwCommon.h"

//______________________________________________________[C++ CLASS DEFINITION]
//////////////////////////////////////////////////////////////////////////////
// Name:           TMrbVariable
// Purpose:        Base class for user-defined variables
// Description:    Defines a variable or window and its methods.
// Keywords:       
//////////////////////////////////////////////////////////////////////////////

class TMrbVariable: public TNamed {

	public:
		TMrbVariable(); 			// default ctor
		~TMrbVariable();			// dtor

		inline UInt_t GetType() const { return(GetUniqueID() & kVarOrWindow); };
		inline UInt_t GetStatus() const { return(GetUniqueID() & kStatus); };
		inline Bool_t IsArray() const { return((GetUniqueID() & kVarIsArray) != 0); };
		inline Bool_t HasInitValues() const { return((GetUniqueID() & kHasInitValues) != 0); };
		inline Bool_t IsRangeChecked() const { return((GetUniqueID() & kIsRangeChecked) != 0); };
		inline Int_t GetSize() const { return(fSize); };

		void Initialize();								// initialize values
		virtual void Print(Option_t * Option = "") const;

		void SetRange(Bool_t Flag = kTRUE) {
			UInt_t varType = GetUniqueID();
			if (Flag) varType |= kIsRangeChecked; else varType &= ~kIsRangeChecked;
			SetUniqueID(varType);
		};

		inline void Help() { gSystem->Exec(Form("mrbHelp %s", this->ClassName())); };

	protected:
		void SetInitialType(UInt_t VarType);

	protected:
		Int_t fSize;				// number of elements if TMrbVarArrayX

	ClassDef(TMrbVariable, 1)		// [Utils] Base class for user-defined variables
};

//______________________________________________________[C++ CLASS DEFINITION]
//////////////////////////////////////////////////////////////////////////////
// Name:           TMrbVarI
// Purpose:        Base class for an integer variable
// Description:    Defines an integer variable and its methods.
// Keywords:       
//////////////////////////////////////////////////////////////////////////////

class TMrbVarI: public TMrbVariable {

	public:
		TMrbVarI() {};											// default ctor
		TMrbVarI(const Char_t * Name, Int_t Value = 0);			// ctor
		~TMrbVarI() {}; 										// dtor

		inline Int_t Clip(Int_t Value) const {						// clip value to range boundaries
			if (this->IsRangeChecked()) {
				if (Value < fLowerRange) return(fLowerRange);
				else if (Value > fUpperRange) return(fUpperRange);
				else return(Value);
			} else return(Value);
		};

		inline Int_t & operator[](UInt_t) { return(fValue); };

		inline void Set(Int_t Value) { fValue = Clip(Value); }; 		// set new value
		inline void SetInit(Int_t Value) { fInitValue = Clip(Value); };	// set init value

		inline Int_t Get() const { return(fValue); };

		inline Bool_t IsEQ(Int_t X) const { return(fValue == X); };	// compare vlues
		inline Bool_t IsNE(Int_t X) const { return(fValue != X); };
		inline Bool_t IsLT(Int_t X) const { return(fValue < X); };
		inline Bool_t IsLE(Int_t X) const { return(fValue <= X); };
		inline Bool_t IsGT(Int_t X) const { return(fValue > X); };
		inline Bool_t IsGE(Int_t X) const { return(fValue >= X); };

		inline void Initialize() { fValue = Clip(fInitValue); };	// reset to initial value

		void SetRange(Int_t Xlower, Int_t Xupper) { 			// define range
			SetUniqueID(GetUniqueID() | kIsRangeChecked);
			fLowerRange = Xlower;
			fUpperRange = Xupper;
		};

		virtual void Print(Option_t * Option = "") const;

		inline void Help() { gSystem->Exec(Form("mrbHelp %s", this->ClassName())); };

 	protected:
		Int_t fValue;						// current value
		Int_t fInitValue; 					// initial value
		Int_t fLowerRange;					// lower range limit
		Int_t fUpperRange;					// upper range limit

	ClassDef(TMrbVarI, 1)		// [Utils] A used-defined integer variable
};

//______________________________________________________[C++ CLASS DEFINITION]
//////////////////////////////////////////////////////////////////////////////
// Name:           TMrbVarF
// Purpose:        Base class for an float variable
// Description:    Defines an float variable and its methods.
// Keywords:       
//////////////////////////////////////////////////////////////////////////////

class TMrbVarF: public TMrbVariable {

	public:
		TMrbVarF() {};												// default ctor
		TMrbVarF(const Char_t * Name, Double_t Value = 0.); 		// ctor

		~TMrbVarF() {}; 											// dtor

		inline Double_t Clip(Double_t Value) const {			// clip value to range boundaries
			if (this->IsRangeChecked()) {
				if (Value < fLowerRange) return(fLowerRange);
				else if (Value > fUpperRange) return(fUpperRange);
				else return(Value);
			} else return(Value);
		};

		inline Double_t & operator[](UInt_t) { return(fValue); };

		inline void Set(Double_t Value) { fValue = Clip(Value); };					// set new value

		inline Double_t Get() const { return(fValue); };

		inline Bool_t IsEQ(Double_t X) const { return(fValue == X); };	// compare vlues
		inline Bool_t IsNE(Double_t X) const { return(fValue != X); };
		inline Bool_t IsLT(Double_t X) const { return(fValue < X); };
		inline Bool_t IsLE(Double_t X) const { return(fValue <= X); };
		inline Bool_t IsGT(Double_t X) const { return(fValue > X); };
		inline Bool_t IsGE(Double_t X) const { return(fValue >= X); };

		inline void Initialize() { fValue = Clip(fInitValue); };	// reset to initial value

		void SetRange(Double_t Xlower, Double_t Xupper) {			// define range
			SetUniqueID(GetUniqueID() | kIsRangeChecked);
			fLowerRange = Xlower;
			fUpperRange = Xupper;
		};

		virtual void Print(Option_t * Option = "") const;

		inline void Help() { gSystem->Exec(Form("mrbHelp %s", this->ClassName())); };

 	protected:
		Double_t fValue;							// current value
		Double_t fInitValue; 					// initial value
		Double_t fLowerRange;					// lower range limit
		Double_t fUpperRange;					// upper range limit

	ClassDef(TMrbVarF, 1)		// [Utils] A used-defined double/float variable
};

//______________________________________________________[C++ CLASS DEFINITION]
//////////////////////////////////////////////////////////////////////////////
// Name:           TMrbVarS
// Purpose:        Base class for a string variable
// Description:    Defines a string variable and its methods.
// Keywords:       
//////////////////////////////////////////////////////////////////////////////

class TMrbVarS: public TMrbVariable {

	public:
		TMrbVarS() {};												// default ctor
		TMrbVarS(const Char_t * Name, const Char_t * Value = "");	// ctor

		~TMrbVarS() {}; 								// dtor

		inline void Set(const Char_t * Value) { fValue = Value; };	// set new value

		inline const Char_t * Get() const { return(fValue.Data()); };

		inline Bool_t IsEQ(Char_t * X) const { return(fValue.CompareTo(X) == 0); };	// compare values
		inline Bool_t IsNE(Char_t * X) const { return(fValue.CompareTo(X) != 0); };
		inline Bool_t IsLT(Char_t * X) const { return(fValue.CompareTo(X) < 0); };
		inline Bool_t IsLE(Char_t * X) const { return(fValue.CompareTo(X) <= 0); };
		inline Bool_t IsGT(Char_t * X) const { return(fValue.CompareTo(X) > 0); };
		inline Bool_t IsGE(Char_t * X) const { return(fValue.CompareTo(X) >= 0); };

		inline void Initialize() { fValue = fInitValue; };		// reset to initial value

		virtual void Print(Option_t * Option = "") const;

		inline void Help() { gSystem->Exec(Form("mrbHelp %s", this->ClassName())); };

 	protected:
		TString fValue;						// current value
		TString fInitValue; 				// initial value

	ClassDef(TMrbVarS, 1)		// [Utils] A used-defined string variable
};

//______________________________________________________[C++ CLASS DEFINITION]
//////////////////////////////////////////////////////////////////////////////
// Name:           TMrbVarB
// Purpose:        Base class for a boolean variable
// Description:    Defines a boolean variable and its methods.
// Keywords:       
//////////////////////////////////////////////////////////////////////////////

class TMrbVarB: public TMrbVariable {

	public:
		TMrbVarB() {};												// default ctor
		TMrbVarB(const Char_t * Name, Bool_t Value = kFALSE);		// ctor

		~TMrbVarB() {}; 											// dtor

		inline void Set(Bool_t Value) { fValue = Value; };	// set new value

		inline Bool_t Get() const { return(fValue); };

		inline Bool_t IsTrue() const { return(fValue); };

		inline void Initialize() { fValue = fInitValue; };		// reset to initial value

		virtual void Print(Option_t * Option = "") const;

		inline void Help() { gSystem->Exec(Form("mrbHelp %s", this->ClassName())); };

 	protected:
		Bool_t fValue;						// current value
		Bool_t fInitValue;	 				// initial value

	ClassDef(TMrbVarB, 1)		// [Utils] A used-defined booleant variable
};

//______________________________________________________[C++ CLASS DEFINITION]
//////////////////////////////////////////////////////////////////////////////
// Name:           TMrbVarArrayI
// Purpose:        Base class for an array of integer variables
// Description:    Defines an array of integer variables and its methods.
// Keywords:       
//////////////////////////////////////////////////////////////////////////////

class TMrbVarArrayI: public TMrbVariable {

	public:
		TMrbVarArrayI() {};													// default ctor
		TMrbVarArrayI(const Char_t * Name, Int_t Size, Int_t Value = 0);	// explicit ctor
 
		~TMrbVarArrayI() {};												// dtor

		inline Int_t Clip(Int_t Value) const {				// clip value to range boundaries
			if (this->IsRangeChecked()) {
				if (Value < fLowerRange) return(fLowerRange);
				else if (Value > fUpperRange) return(fUpperRange);
				else return(Value);
			} else return(Value);
		};

		inline Int_t & operator[](UInt_t i) { return(fValue[i]); };

		inline void Set(UInt_t Index, Int_t Value) { fValue[Index] = Clip(Value); };	// set new value
		inline void SetInit(UInt_t Index, Int_t Value) { fInitValue[Index] = Clip(Value); };	// set init val

		inline Int_t Get(UInt_t Index) const { return(fValue[Index]); };

		inline Bool_t IsEQ(UInt_t Index, Int_t X) const { return(fValue[Index] == X); };	// compare values
		inline Bool_t IsNE(UInt_t Index, Int_t X) const { return(fValue[Index] != X); };
		inline Bool_t IsLT(UInt_t Index, Int_t X) const { return(fValue[Index] < X); };
		inline Bool_t IsLE(UInt_t Index, Int_t X) const { return(fValue[Index] <= X); };
		inline Bool_t IsGT(UInt_t Index, Int_t X) const { return(fValue[Index] > X); };
		inline Bool_t IsGE(UInt_t Index, Int_t X) const { return(fValue[Index] >= X); };

		void SetRange(Int_t Xlower, Int_t Xupper) {		// define range
			SetUniqueID(GetUniqueID() | kIsRangeChecked);
			fLowerRange = Xlower;
			fUpperRange = Xupper;
		};

		void Initialize() { for (Int_t i = 0; i < fSize; i++) fValue[i] = fInitValue[i]; };

		virtual void Print(Option_t * Option = "") const;

		inline void Help() { gSystem->Exec(Form("mrbHelp %s", this->ClassName())); };

 	protected:
		TArrayI fValue;						// current values
		TArrayI fInitValue; 				// initial values
		Int_t fLowerRange;					// lower range limit
		Int_t fUpperRange;					// upper range limit

	ClassDef(TMrbVarArrayI, 1)		// [Utils] A used-defined array of integer variables
};

//______________________________________________________[C++ CLASS DEFINITION]
//////////////////////////////////////////////////////////////////////////////
// Name:           TMrbVarArrayF
// Purpose:        Base class for an array of float variables
// Description:    Defines an array of integer variables and its methods.
// Keywords:       
//////////////////////////////////////////////////////////////////////////////

class TMrbVarArrayF: public TMrbVariable {

	public:
		TMrbVarArrayF() {};										// default ctor
		TMrbVarArrayF(const Char_t * Name, Int_t Size, Double_t Value = 0.);	// explicit ctor
 
		~TMrbVarArrayF() {};									// dtor

		inline Double_t Clip(Double_t Value) const {				// clip value to range boundaries
			if (this->IsRangeChecked()) {
				if (Value < fLowerRange) return(fLowerRange);
				else if (Value > fUpperRange) return(fUpperRange);
				else return(Value);
			} else return(Value);
		};

		inline Double_t & operator[](UInt_t i) { return(fValue[i]); };

		inline void Set(UInt_t Index, Double_t Value) { fValue[Index] = Clip(Value); };	// set new value
		inline void SetInit(UInt_t Index, Double_t Value) { fInitValue[Index] = Clip(Value); };	// set init val

		inline Double_t Get(UInt_t Index) const { return(fValue[Index]); };

		inline Bool_t IsEQ(UInt_t Index, Double_t X) const { return(fValue[Index] == X); };	// compare vlues
		inline Bool_t IsNE(UInt_t Index, Double_t X) const { return(fValue[Index] != X); };
		inline Bool_t IsLT(UInt_t Index, Double_t X) const { return(fValue[Index] < X); };
		inline Bool_t IsLE(UInt_t Index, Double_t X) const { return(fValue[Index] <= X); };
		inline Bool_t IsGT(UInt_t Index, Double_t X) const { return(fValue[Index] > X); };
		inline Bool_t IsGE(UInt_t Index, Double_t X) const { return(fValue[Index] >= X); };

		void SetRange(Double_t Xlower, Double_t Xupper) {		// define range
			SetUniqueID(GetUniqueID() | kIsRangeChecked);
			fLowerRange = Xlower;
			fUpperRange = Xupper;
		};

		void Initialize() { for (Int_t i = 0; i < fSize; i++) fValue[i] = fInitValue[i]; };

		virtual void Print(Option_t * Option = "") const;

		inline void Help() { gSystem->Exec(Form("mrbHelp %s", this->ClassName())); };

 	protected:
		TArrayD fValue;							// current values
		TArrayD fInitValue; 					// initial values
		Double_t fLowerRange;					// lower range limit
		Double_t fUpperRange;					// upper range limit

	ClassDef(TMrbVarArrayF, 1)		// [Utils] A used-defined array double/float variables
};

#endif
 TMrbVar.h:1
 TMrbVar.h:2
 TMrbVar.h:3
 TMrbVar.h:4
 TMrbVar.h:5
 TMrbVar.h:6
 TMrbVar.h:7
 TMrbVar.h:8
 TMrbVar.h:9
 TMrbVar.h:10
 TMrbVar.h:11
 TMrbVar.h:12
 TMrbVar.h:13
 TMrbVar.h:14
 TMrbVar.h:15
 TMrbVar.h:16
 TMrbVar.h:17
 TMrbVar.h:18
 TMrbVar.h:19
 TMrbVar.h:20
 TMrbVar.h:21
 TMrbVar.h:22
 TMrbVar.h:23
 TMrbVar.h:24
 TMrbVar.h:25
 TMrbVar.h:26
 TMrbVar.h:27
 TMrbVar.h:28
 TMrbVar.h:29
 TMrbVar.h:30
 TMrbVar.h:31
 TMrbVar.h:32
 TMrbVar.h:33
 TMrbVar.h:34
 TMrbVar.h:35
 TMrbVar.h:36
 TMrbVar.h:37
 TMrbVar.h:38
 TMrbVar.h:39
 TMrbVar.h:40
 TMrbVar.h:41
 TMrbVar.h:42
 TMrbVar.h:43
 TMrbVar.h:44
 TMrbVar.h:45
 TMrbVar.h:46
 TMrbVar.h:47
 TMrbVar.h:48
 TMrbVar.h:49
 TMrbVar.h:50
 TMrbVar.h:51
 TMrbVar.h:52
 TMrbVar.h:53
 TMrbVar.h:54
 TMrbVar.h:55
 TMrbVar.h:56
 TMrbVar.h:57
 TMrbVar.h:58
 TMrbVar.h:59
 TMrbVar.h:60
 TMrbVar.h:61
 TMrbVar.h:62
 TMrbVar.h:63
 TMrbVar.h:64
 TMrbVar.h:65
 TMrbVar.h:66
 TMrbVar.h:67
 TMrbVar.h:68
 TMrbVar.h:69
 TMrbVar.h:70
 TMrbVar.h:71
 TMrbVar.h:72
 TMrbVar.h:73
 TMrbVar.h:74
 TMrbVar.h:75
 TMrbVar.h:76
 TMrbVar.h:77
 TMrbVar.h:78
 TMrbVar.h:79
 TMrbVar.h:80
 TMrbVar.h:81
 TMrbVar.h:82
 TMrbVar.h:83
 TMrbVar.h:84
 TMrbVar.h:85
 TMrbVar.h:86
 TMrbVar.h:87
 TMrbVar.h:88
 TMrbVar.h:89
 TMrbVar.h:90
 TMrbVar.h:91
 TMrbVar.h:92
 TMrbVar.h:93
 TMrbVar.h:94
 TMrbVar.h:95
 TMrbVar.h:96
 TMrbVar.h:97
 TMrbVar.h:98
 TMrbVar.h:99
 TMrbVar.h:100
 TMrbVar.h:101
 TMrbVar.h:102
 TMrbVar.h:103
 TMrbVar.h:104
 TMrbVar.h:105
 TMrbVar.h:106
 TMrbVar.h:107
 TMrbVar.h:108
 TMrbVar.h:109
 TMrbVar.h:110
 TMrbVar.h:111
 TMrbVar.h:112
 TMrbVar.h:113
 TMrbVar.h:114
 TMrbVar.h:115
 TMrbVar.h:116
 TMrbVar.h:117
 TMrbVar.h:118
 TMrbVar.h:119
 TMrbVar.h:120
 TMrbVar.h:121
 TMrbVar.h:122
 TMrbVar.h:123
 TMrbVar.h:124
 TMrbVar.h:125
 TMrbVar.h:126
 TMrbVar.h:127
 TMrbVar.h:128
 TMrbVar.h:129
 TMrbVar.h:130
 TMrbVar.h:131
 TMrbVar.h:132
 TMrbVar.h:133
 TMrbVar.h:134
 TMrbVar.h:135
 TMrbVar.h:136
 TMrbVar.h:137
 TMrbVar.h:138
 TMrbVar.h:139
 TMrbVar.h:140
 TMrbVar.h:141
 TMrbVar.h:142
 TMrbVar.h:143
 TMrbVar.h:144
 TMrbVar.h:145
 TMrbVar.h:146
 TMrbVar.h:147
 TMrbVar.h:148
 TMrbVar.h:149
 TMrbVar.h:150
 TMrbVar.h:151
 TMrbVar.h:152
 TMrbVar.h:153
 TMrbVar.h:154
 TMrbVar.h:155
 TMrbVar.h:156
 TMrbVar.h:157
 TMrbVar.h:158
 TMrbVar.h:159
 TMrbVar.h:160
 TMrbVar.h:161
 TMrbVar.h:162
 TMrbVar.h:163
 TMrbVar.h:164
 TMrbVar.h:165
 TMrbVar.h:166
 TMrbVar.h:167
 TMrbVar.h:168
 TMrbVar.h:169
 TMrbVar.h:170
 TMrbVar.h:171
 TMrbVar.h:172
 TMrbVar.h:173
 TMrbVar.h:174
 TMrbVar.h:175
 TMrbVar.h:176
 TMrbVar.h:177
 TMrbVar.h:178
 TMrbVar.h:179
 TMrbVar.h:180
 TMrbVar.h:181
 TMrbVar.h:182
 TMrbVar.h:183
 TMrbVar.h:184
 TMrbVar.h:185
 TMrbVar.h:186
 TMrbVar.h:187
 TMrbVar.h:188
 TMrbVar.h:189
 TMrbVar.h:190
 TMrbVar.h:191
 TMrbVar.h:192
 TMrbVar.h:193
 TMrbVar.h:194
 TMrbVar.h:195
 TMrbVar.h:196
 TMrbVar.h:197
 TMrbVar.h:198
 TMrbVar.h:199
 TMrbVar.h:200
 TMrbVar.h:201
 TMrbVar.h:202
 TMrbVar.h:203
 TMrbVar.h:204
 TMrbVar.h:205
 TMrbVar.h:206
 TMrbVar.h:207
 TMrbVar.h:208
 TMrbVar.h:209
 TMrbVar.h:210
 TMrbVar.h:211
 TMrbVar.h:212
 TMrbVar.h:213
 TMrbVar.h:214
 TMrbVar.h:215
 TMrbVar.h:216
 TMrbVar.h:217
 TMrbVar.h:218
 TMrbVar.h:219
 TMrbVar.h:220
 TMrbVar.h:221
 TMrbVar.h:222
 TMrbVar.h:223
 TMrbVar.h:224
 TMrbVar.h:225
 TMrbVar.h:226
 TMrbVar.h:227
 TMrbVar.h:228
 TMrbVar.h:229
 TMrbVar.h:230
 TMrbVar.h:231
 TMrbVar.h:232
 TMrbVar.h:233
 TMrbVar.h:234
 TMrbVar.h:235
 TMrbVar.h:236
 TMrbVar.h:237
 TMrbVar.h:238
 TMrbVar.h:239
 TMrbVar.h:240
 TMrbVar.h:241
 TMrbVar.h:242
 TMrbVar.h:243
 TMrbVar.h:244
 TMrbVar.h:245
 TMrbVar.h:246
 TMrbVar.h:247
 TMrbVar.h:248
 TMrbVar.h:249
 TMrbVar.h:250
 TMrbVar.h:251
 TMrbVar.h:252
 TMrbVar.h:253
 TMrbVar.h:254
 TMrbVar.h:255
 TMrbVar.h:256
 TMrbVar.h:257
 TMrbVar.h:258
 TMrbVar.h:259
 TMrbVar.h:260
 TMrbVar.h:261
 TMrbVar.h:262
 TMrbVar.h:263
 TMrbVar.h:264
 TMrbVar.h:265
 TMrbVar.h:266
 TMrbVar.h:267
 TMrbVar.h:268
 TMrbVar.h:269
 TMrbVar.h:270
 TMrbVar.h:271
 TMrbVar.h:272
 TMrbVar.h:273
 TMrbVar.h:274
 TMrbVar.h:275
 TMrbVar.h:276
 TMrbVar.h:277
 TMrbVar.h:278
 TMrbVar.h:279
 TMrbVar.h:280
 TMrbVar.h:281
 TMrbVar.h:282
 TMrbVar.h:283
 TMrbVar.h:284
 TMrbVar.h:285
 TMrbVar.h:286
 TMrbVar.h:287
 TMrbVar.h:288
 TMrbVar.h:289
 TMrbVar.h:290
 TMrbVar.h:291
 TMrbVar.h:292
 TMrbVar.h:293
 TMrbVar.h:294
 TMrbVar.h:295
 TMrbVar.h:296
 TMrbVar.h:297
 TMrbVar.h:298
 TMrbVar.h:299
 TMrbVar.h:300
 TMrbVar.h:301
 TMrbVar.h:302
 TMrbVar.h:303
 TMrbVar.h:304
 TMrbVar.h:305
 TMrbVar.h:306
 TMrbVar.h:307
 TMrbVar.h:308
 TMrbVar.h:309
 TMrbVar.h:310
 TMrbVar.h:311
 TMrbVar.h:312
 TMrbVar.h:313
 TMrbVar.h:314
 TMrbVar.h:315
 TMrbVar.h:316
 TMrbVar.h:317
 TMrbVar.h:318
 TMrbVar.h:319
 TMrbVar.h:320
 TMrbVar.h:321
 TMrbVar.h:322
 TMrbVar.h:323
 TMrbVar.h:324
 TMrbVar.h:325
 TMrbVar.h:326
 TMrbVar.h:327
 TMrbVar.h:328
 TMrbVar.h:329
 TMrbVar.h:330
 TMrbVar.h:331
 TMrbVar.h:332
 TMrbVar.h:333
 TMrbVar.h:334
 TMrbVar.h:335
 TMrbVar.h:336
 TMrbVar.h:337
 TMrbVar.h:338
 TMrbVar.h:339
 TMrbVar.h:340
 TMrbVar.h:341
 TMrbVar.h:342
 TMrbVar.h:343
 TMrbVar.h:344
 TMrbVar.h:345
 TMrbVar.h:346
 TMrbVar.h:347
 TMrbVar.h:348
 TMrbVar.h:349
 TMrbVar.h:350
 TMrbVar.h:351
 TMrbVar.h:352
 TMrbVar.h:353
 TMrbVar.h:354
 TMrbVar.h:355
 TMrbVar.h:356
 TMrbVar.h:357
 TMrbVar.h:358
 TMrbVar.h:359
 TMrbVar.h:360
 TMrbVar.h:361
 TMrbVar.h:362
 TMrbVar.h:363
 TMrbVar.h:364
 TMrbVar.h:365
 TMrbVar.h:366
 TMrbVar.h:367
 TMrbVar.h:368
 TMrbVar.h:369
 TMrbVar.h:370
 TMrbVar.h:371
 TMrbVar.h:372
 TMrbVar.h:373
 TMrbVar.h:374
 TMrbVar.h:375
 TMrbVar.h:376
 TMrbVar.h:377
 TMrbVar.h:378
 TMrbVar.h:379
 TMrbVar.h:380
 TMrbVar.h:381
 TMrbVar.h:382