#ifndef hArtistContractTermTable
#define hArtistContractTermTable

#include "PackedTable.h"


struct _artistContractTerm
{
private:
    static const int kDecimalFieldSize = 16;

    long _artist_contract_term_id;
    long _artist_contract_id;
    char _priority;
    long _income_source_id;
    long _contract_term_source_id;
    char _region_id;
    char _channel_id;
    char _price_level_id;
    char _contract_rate_type_id;
    char _rate[kDecimalFieldSize];
    char _rate_reduction[kDecimalFieldSize];
    char _percentage_of_sales[kDecimalFieldSize];
    char _packaging_deduction[kDecimalFieldSize];
    char _free_goods_deduction[kDecimalFieldSize];
    char _inactive;

public:
    long artist_contract_term_id()    { return _artist_contract_term_id; }
    long artist_contract_id()         { return _artist_contract_id; }
    int priority()                    { return _priority; }
    long income_source_id()           { return _income_source_id; }
    long contract_term_source_id()    { return _contract_term_source_id; }
    int region_id()                   { return _region_id; }
    int channel_id()                  { return _channel_id; }
    int price_level_id()              { return _price_level_id; }
    int contract_rate_type_id()       { return _contract_rate_type_id; }
    char* rate()                      { return _rate; }
    char* rate_reduction()            { return _rate_reduction; }
    char* percentage_of_sales()       { return _percentage_of_sales; }
    char* packaging_deduction()       { return _packaging_deduction; }
    char* free_goods_deduction()      { return _free_goods_deduction; }
    int inactive()                    { return _inactive; }

    friend class ArtistContractTermTable;
};


class ArtistContractTermTable : public PackedTableFlat
{
public:
    struct _artistContractTerm* getIndexedData(const long index) { return (struct _artistContractTerm*)this->_getIndexedData(index); }

protected:
    enum Field 
    {
        kArtistContractTermID = 0,
        kArtistContractID,
        kPriority,
        kIncomeSourceID,
        kContractTermSourceID,
        kRegionID,
        kChannelID,
        kPriceLevelID,
        kContractRateTypeID,
        kRate,
        kRateReduction,
        kPercentageOfSales,
        kPackagingDeduction,
        kFreeGoodsDeduction,
        kInactive 
    };

    PackedTable::SharedMemoryHandler _dataFileHandler;
    virtual DataFileHandler* _getDataFileHandler() { return &_dataFileHandler; }

    virtual long _dataFlatElementSize() { return sizeof(struct _artistContractTerm); }

    virtual const char* _maxIDQueryString() { return "SELECT MAX(artist_contract_term_id) FROM new_artist_contract_term"; }

    virtual const char* _dataQueryString() { return  "SELECT artist_contract_term_id,artist_contract_id,priority,income_source_id,contract_term_source_id,region_id,channel_id,price_level_id,contract_rate_type_id,rate,rate_reduction,percentage_of_sales,packaging_deduction,free_goods_deduction,inactive FROM new_artist_contract_term ORDER BY artist_contract_term_id"; }

    virtual void _readDataRow(MYSQL_ROW row)
    {
        // cast the data block to an array of the right type.
        //
        struct _artistContractTerm *array = (struct _artistContractTerm*)this->_dataFlatRAM;

        // First we need to determine the id, which will give us
        // the correct index into the array to store everything.
        //
        long artistContractTermID;
        PackedTable::_ParseLong(row[kArtistContractTermID], &artistContractTermID);

        long i = artistContractTermID;
        array[i]._artist_contract_term_id = artistContractTermID;

        PackedTable::_ParseLong(row[kArtistContractID], &(array[i]._artist_contract_id));
        PackedTable::_ParseByte(row[kPriority], &(array[i]._priority));
        PackedTable::_ParseLong(row[kIncomeSourceID], &(array[i]._income_source_id));
        PackedTable::_ParseLong(row[kContractTermSourceID], &(array[i]._contract_term_source_id));
        PackedTable::_ParseByte(row[kRegionID], &(array[i]._region_id));
        PackedTable::_ParseByte(row[kChannelID], &(array[i]._channel_id));
        PackedTable::_ParseByte(row[kPriceLevelID], &(array[i]._price_level_id));
        PackedTable::_ParseByte(row[kContractRateTypeID], &(array[i]._contract_rate_type_id));
        PackedTable::_ParseString(row[kRate], (char*)&(array[i]._rate), _artistContractTerm::kDecimalFieldSize);
        PackedTable::_ParseString(row[kRateReduction], (char*)&(array[i]._rate_reduction), _artistContractTerm::kDecimalFieldSize);
        PackedTable::_ParseString(row[kPercentageOfSales], (char*)&(array[i]._percentage_of_sales), _artistContractTerm::kDecimalFieldSize);
        PackedTable::_ParseString(row[kPackagingDeduction], (char*)&(array[i]._packaging_deduction), _artistContractTerm::kDecimalFieldSize);
        PackedTable::_ParseString(row[kFreeGoodsDeduction], (char*)&(array[i]._free_goods_deduction), _artistContractTerm::kDecimalFieldSize);
        PackedTable::_ParseByte(row[kInactive], &(array[i]._inactive));
    }
};

#endif