1

#include "ai_vehiclelist_valuator.hpp"

     2

     3

namespace SQConvert {

     4

	/* Allow AIVehicleList_vLocation to be used as Squirrel parameter */

     5

	template <> AIVehicleList_vLocation *GetParam(ForceType<AIVehicleList_vLocation *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vLocation *)instance; }

     6

	template <> AIVehicleList_vLocation &GetParam(ForceType<AIVehicleList_vLocation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vLocation *)instance; }

     7

	template <> const AIVehicleList_vLocation *GetParam(ForceType<const AIVehicleList_vLocation *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vLocation *)instance; }

     8

	template <> const AIVehicleList_vLocation &GetParam(ForceType<const AIVehicleList_vLocation &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vLocation *)instance; }

     9

	template <> int Return<AIVehicleList_vLocation *>(HSQUIRRELVM vm, AIVehicleList_vLocation *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList_vLocation", res, NULL, DefSQDestructorCallback<AIVehicleList_vLocation>); return 1; }

    10

}; // namespace SQConvert

    11

    12

void SQAIVehicleList_vLocation_Register(Squirrel *engine) {

    13

	DefSQClass <AIVehicleList_vLocation> SQAIVehicleList_vLocation("AIVehicleList_vLocation");

    14

	SQAIVehicleList_vLocation.PreRegister(engine);

    15

	SQAIVehicleList_vLocation.AddConstructor<void (AIVehicleList_vLocation::*)(), 1>(engine, "x");

    16

    17

	SQAIVehicleList_vLocation.DefSQStaticMethod(engine, &AIVehicleList_vLocation::GetClassName, "GetClassName", 1, "x");

    18

    19

	SQAIVehicleList_vLocation.PostRegister(engine);

    20

}

    21

    22

namespace SQConvert {

    23

	/* Allow AIVehicleList_vEngineType to be used as Squirrel parameter */

    24

	template <> AIVehicleList_vEngineType *GetParam(ForceType<AIVehicleList_vEngineType *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vEngineType *)instance; }

    25

	template <> AIVehicleList_vEngineType &GetParam(ForceType<AIVehicleList_vEngineType &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vEngineType *)instance; }

    26

	template <> const AIVehicleList_vEngineType *GetParam(ForceType<const AIVehicleList_vEngineType *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vEngineType *)instance; }

    27

	template <> const AIVehicleList_vEngineType &GetParam(ForceType<const AIVehicleList_vEngineType &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vEngineType *)instance; }

    28

	template <> int Return<AIVehicleList_vEngineType *>(HSQUIRRELVM vm, AIVehicleList_vEngineType *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList_vEngineType", res, NULL, DefSQDestructorCallback<AIVehicleList_vEngineType>); return 1; }

    29

}; // namespace SQConvert

    30

    31

void SQAIVehicleList_vEngineType_Register(Squirrel *engine) {

    32

	DefSQClass <AIVehicleList_vEngineType> SQAIVehicleList_vEngineType("AIVehicleList_vEngineType");

    33

	SQAIVehicleList_vEngineType.PreRegister(engine);

    34

	SQAIVehicleList_vEngineType.AddConstructor<void (AIVehicleList_vEngineType::*)(), 1>(engine, "x");

    35

    36

	SQAIVehicleList_vEngineType.DefSQStaticMethod(engine, &AIVehicleList_vEngineType::GetClassName, "GetClassName", 1, "x");

    37

    38

	SQAIVehicleList_vEngineType.PostRegister(engine);

    39

}

    40

    41

namespace SQConvert {

    42

	/* Allow AIVehicleList_vUnitNumber to be used as Squirrel parameter */

    43

	template <> AIVehicleList_vUnitNumber *GetParam(ForceType<AIVehicleList_vUnitNumber *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vUnitNumber *)instance; }

    44

	template <> AIVehicleList_vUnitNumber &GetParam(ForceType<AIVehicleList_vUnitNumber &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vUnitNumber *)instance; }

    45

	template <> const AIVehicleList_vUnitNumber *GetParam(ForceType<const AIVehicleList_vUnitNumber *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vUnitNumber *)instance; }

    46

	template <> const AIVehicleList_vUnitNumber &GetParam(ForceType<const AIVehicleList_vUnitNumber &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vUnitNumber *)instance; }

    47

	template <> int Return<AIVehicleList_vUnitNumber *>(HSQUIRRELVM vm, AIVehicleList_vUnitNumber *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList_vUnitNumber", res, NULL, DefSQDestructorCallback<AIVehicleList_vUnitNumber>); return 1; }

    48

}; // namespace SQConvert

    49

    50

void SQAIVehicleList_vUnitNumber_Register(Squirrel *engine) {

    51

	DefSQClass <AIVehicleList_vUnitNumber> SQAIVehicleList_vUnitNumber("AIVehicleList_vUnitNumber");

    52

	SQAIVehicleList_vUnitNumber.PreRegister(engine);

    53

	SQAIVehicleList_vUnitNumber.AddConstructor<void (AIVehicleList_vUnitNumber::*)(), 1>(engine, "x");

    54

    55

	SQAIVehicleList_vUnitNumber.DefSQStaticMethod(engine, &AIVehicleList_vUnitNumber::GetClassName, "GetClassName", 1, "x");

    56

    57

	SQAIVehicleList_vUnitNumber.PostRegister(engine);

    58

}

    59

    60

namespace SQConvert {

    61

	/* Allow AIVehicleList_vAge to be used as Squirrel parameter */

    62

	template <> AIVehicleList_vAge *GetParam(ForceType<AIVehicleList_vAge *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vAge *)instance; }

    63

	template <> AIVehicleList_vAge &GetParam(ForceType<AIVehicleList_vAge &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vAge *)instance; }

    64

	template <> const AIVehicleList_vAge *GetParam(ForceType<const AIVehicleList_vAge *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vAge *)instance; }

    65

	template <> const AIVehicleList_vAge &GetParam(ForceType<const AIVehicleList_vAge &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vAge *)instance; }

    66

	template <> int Return<AIVehicleList_vAge *>(HSQUIRRELVM vm, AIVehicleList_vAge *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList_vAge", res, NULL, DefSQDestructorCallback<AIVehicleList_vAge>); return 1; }

    67

}; // namespace SQConvert

    68

    69

void SQAIVehicleList_vAge_Register(Squirrel *engine) {

    70

	DefSQClass <AIVehicleList_vAge> SQAIVehicleList_vAge("AIVehicleList_vAge");

    71

	SQAIVehicleList_vAge.PreRegister(engine);

    72

	SQAIVehicleList_vAge.AddConstructor<void (AIVehicleList_vAge::*)(), 1>(engine, "x");

    73

    74

	SQAIVehicleList_vAge.DefSQStaticMethod(engine, &AIVehicleList_vAge::GetClassName, "GetClassName", 1, "x");

    75

    76

	SQAIVehicleList_vAge.PostRegister(engine);

    77

}

    78

    79

namespace SQConvert {

    80

	/* Allow AIVehicleList_vMaxAge to be used as Squirrel parameter */

    81

	template <> AIVehicleList_vMaxAge *GetParam(ForceType<AIVehicleList_vMaxAge *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vMaxAge *)instance; }

    82

	template <> AIVehicleList_vMaxAge &GetParam(ForceType<AIVehicleList_vMaxAge &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vMaxAge *)instance; }

    83

	template <> const AIVehicleList_vMaxAge *GetParam(ForceType<const AIVehicleList_vMaxAge *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vMaxAge *)instance; }

    84

	template <> const AIVehicleList_vMaxAge &GetParam(ForceType<const AIVehicleList_vMaxAge &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vMaxAge *)instance; }

    85

	template <> int Return<AIVehicleList_vMaxAge *>(HSQUIRRELVM vm, AIVehicleList_vMaxAge *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList_vMaxAge", res, NULL, DefSQDestructorCallback<AIVehicleList_vMaxAge>); return 1; }

    86

}; // namespace SQConvert

    87

    88

void SQAIVehicleList_vMaxAge_Register(Squirrel *engine) {

    89

	DefSQClass <AIVehicleList_vMaxAge> SQAIVehicleList_vMaxAge("AIVehicleList_vMaxAge");

    90

	SQAIVehicleList_vMaxAge.PreRegister(engine);

    91

	SQAIVehicleList_vMaxAge.AddConstructor<void (AIVehicleList_vMaxAge::*)(), 1>(engine, "x");

    92

    93

	SQAIVehicleList_vMaxAge.DefSQStaticMethod(engine, &AIVehicleList_vMaxAge::GetClassName, "GetClassName", 1, "x");

    94

    95

	SQAIVehicleList_vMaxAge.PostRegister(engine);

    96

}

    97

    98

namespace SQConvert {

    99

	/* Allow AIVehicleList_vAgeLeft to be used as Squirrel parameter */

   100

	template <> AIVehicleList_vAgeLeft *GetParam(ForceType<AIVehicleList_vAgeLeft *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vAgeLeft *)instance; }

   101

	template <> AIVehicleList_vAgeLeft &GetParam(ForceType<AIVehicleList_vAgeLeft &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vAgeLeft *)instance; }

   102

	template <> const AIVehicleList_vAgeLeft *GetParam(ForceType<const AIVehicleList_vAgeLeft *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vAgeLeft *)instance; }

   103

	template <> const AIVehicleList_vAgeLeft &GetParam(ForceType<const AIVehicleList_vAgeLeft &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vAgeLeft *)instance; }

   104

	template <> int Return<AIVehicleList_vAgeLeft *>(HSQUIRRELVM vm, AIVehicleList_vAgeLeft *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList_vAgeLeft", res, NULL, DefSQDestructorCallback<AIVehicleList_vAgeLeft>); return 1; }

   105

}; // namespace SQConvert

   106

   107

void SQAIVehicleList_vAgeLeft_Register(Squirrel *engine) {

   108

	DefSQClass <AIVehicleList_vAgeLeft> SQAIVehicleList_vAgeLeft("AIVehicleList_vAgeLeft");

   109

	SQAIVehicleList_vAgeLeft.PreRegister(engine);

   110

	SQAIVehicleList_vAgeLeft.AddConstructor<void (AIVehicleList_vAgeLeft::*)(), 1>(engine, "x");

   111

   112

	SQAIVehicleList_vAgeLeft.DefSQStaticMethod(engine, &AIVehicleList_vAgeLeft::GetClassName, "GetClassName", 1, "x");

   113

   114

	SQAIVehicleList_vAgeLeft.PostRegister(engine);

   115

}

   116

   117

namespace SQConvert {

   137

	/* Allow AIVehicleList_vProfitThisYear to be used as Squirrel parameter */

   138

	template <> AIVehicleList_vProfitThisYear *GetParam(ForceType<AIVehicleList_vProfitThisYear *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vProfitThisYear *)instance; }

   139

	template <> AIVehicleList_vProfitThisYear &GetParam(ForceType<AIVehicleList_vProfitThisYear &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vProfitThisYear *)instance; }

   140

	template <> const AIVehicleList_vProfitThisYear *GetParam(ForceType<const AIVehicleList_vProfitThisYear *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vProfitThisYear *)instance; }

   141

	template <> const AIVehicleList_vProfitThisYear &GetParam(ForceType<const AIVehicleList_vProfitThisYear &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vProfitThisYear *)instance; }

   142

	template <> int Return<AIVehicleList_vProfitThisYear *>(HSQUIRRELVM vm, AIVehicleList_vProfitThisYear *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList_vProfitThisYear", res, NULL, DefSQDestructorCallback<AIVehicleList_vProfitThisYear>); return 1; }

   143

}; // namespace SQConvert

   144

   145

void SQAIVehicleList_vProfitThisYear_Register(Squirrel *engine) {

   146

	DefSQClass <AIVehicleList_vProfitThisYear> SQAIVehicleList_vProfitThisYear("AIVehicleList_vProfitThisYear");

   147

	SQAIVehicleList_vProfitThisYear.PreRegister(engine);

   148

	SQAIVehicleList_vProfitThisYear.AddConstructor<void (AIVehicleList_vProfitThisYear::*)(), 1>(engine, "x");

   149

   150

	SQAIVehicleList_vProfitThisYear.DefSQStaticMethod(engine, &AIVehicleList_vProfitThisYear::GetClassName, "GetClassName", 1, "x");

   151

   152

	SQAIVehicleList_vProfitThisYear.PostRegister(engine);

   153

}

   154

   155

namespace SQConvert {

   156

	/* Allow AIVehicleList_vProfitLastYear to be used as Squirrel parameter */

   157

	template <> AIVehicleList_vProfitLastYear *GetParam(ForceType<AIVehicleList_vProfitLastYear *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vProfitLastYear *)instance; }

   158

	template <> AIVehicleList_vProfitLastYear &GetParam(ForceType<AIVehicleList_vProfitLastYear &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vProfitLastYear *)instance; }

   159

	template <> const AIVehicleList_vProfitLastYear *GetParam(ForceType<const AIVehicleList_vProfitLastYear *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vProfitLastYear *)instance; }

   160

	template <> const AIVehicleList_vProfitLastYear &GetParam(ForceType<const AIVehicleList_vProfitLastYear &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vProfitLastYear *)instance; }

   161

	template <> int Return<AIVehicleList_vProfitLastYear *>(HSQUIRRELVM vm, AIVehicleList_vProfitLastYear *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList_vProfitLastYear", res, NULL, DefSQDestructorCallback<AIVehicleList_vProfitLastYear>); return 1; }

   162

}; // namespace SQConvert

   163

   164

void SQAIVehicleList_vProfitLastYear_Register(Squirrel *engine) {

   165

	DefSQClass <AIVehicleList_vProfitLastYear> SQAIVehicleList_vProfitLastYear("AIVehicleList_vProfitLastYear");

   166

	SQAIVehicleList_vProfitLastYear.PreRegister(engine);

   167

	SQAIVehicleList_vProfitLastYear.AddConstructor<void (AIVehicleList_vProfitLastYear::*)(), 1>(engine, "x");

   168

   169

	SQAIVehicleList_vProfitLastYear.DefSQStaticMethod(engine, &AIVehicleList_vProfitLastYear::GetClassName, "GetClassName", 1, "x");

   170

   171

	SQAIVehicleList_vProfitLastYear.PostRegister(engine);

   172

}

   173

   174

namespace SQConvert {

   175

	/* Allow AIVehicleList_vVehicleType to be used as Squirrel parameter */

   176

	template <> AIVehicleList_vVehicleType *GetParam(ForceType<AIVehicleList_vVehicleType *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vVehicleType *)instance; }

   177

	template <> AIVehicleList_vVehicleType &GetParam(ForceType<AIVehicleList_vVehicleType &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vVehicleType *)instance; }

   178

	template <> const AIVehicleList_vVehicleType *GetParam(ForceType<const AIVehicleList_vVehicleType *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIVehicleList_vVehicleType *)instance; }

   179

	template <> const AIVehicleList_vVehicleType &GetParam(ForceType<const AIVehicleList_vVehicleType &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIVehicleList_vVehicleType *)instance; }

   180

	template <> int Return<AIVehicleList_vVehicleType *>(HSQUIRRELVM vm, AIVehicleList_vVehicleType *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIVehicleList_vVehicleType", res, NULL, DefSQDestructorCallback<AIVehicleList_vVehicleType>); return 1; }

   181

}; // namespace SQConvert

   182

   183

void SQAIVehicleList_vVehicleType_Register(Squirrel *engine) {

   184

	DefSQClass <AIVehicleList_vVehicleType> SQAIVehicleList_vVehicleType("AIVehicleList_vVehicleType");

   185

	SQAIVehicleList_vVehicleType.PreRegister(engine);

   186

	SQAIVehicleList_vVehicleType.AddConstructor<void (AIVehicleList_vVehicleType::*)(), 1>(engine, "x");

   187

   188

	SQAIVehicleList_vVehicleType.DefSQStaticMethod(engine, &AIVehicleList_vVehicleType::GetClassName, "GetClassName", 1, "x");

   189

   190

	SQAIVehicleList_vVehicleType.PostRegister(engine);

   191

}