#ifndef hAlbumContractIDByAlbumIDTable
#define hAlbumContractIDByAlbumIDTable


#include "PackedTable.h"

#include <map>
using namespace std;

struct _albumIDAlbumContractID
{
private:
    unsigned long _album_id;
    unsigned long _album_contract_id;

    // Declaring these accessor methods will cause SWIG to provide
    // exactly the interface I want to use (i.e. $at->album_id() will return an album_id)
    //
public:
    unsigned long album_id() { return _album_id; }
    unsigned long album_contract_id() { return _album_contract_id; }

    friend class AlbumContractIDByAlbumIDTable;
};

class AlbumContractIDByAlbumIDTable : public PackedTableDynamic
{

protected:
    static const int kFieldAlbumID          = 0;
    static const int kFieldAlbumContractID  = 1;

    multimap<unsigned long, struct _albumIDAlbumContractID> _map;


    virtual const char* _maxIDQueryString() { return "SELECT MAX(album_id) FROM album_contract"; }
    virtual const char* _dataQueryString() { return "SELECT album_id,album_contract_id FROM album_contract ORDER BY album_id, album_contract_id";}
    virtual long _insertRowDynamic(MYSQL_ROW row)
    {
        long albumID;
        long albumContractID;
        PackedTable::_ParseLong(row[kFieldAlbumID], &albumID);
        PackedTable::_ParseLong(row[kFieldAlbumContractID], &albumContractID);

        struct _albumIDAlbumContractID newData;
        newData._album_id = albumID;
        newData._album_contract_id = albumContractID;

        _map.insert(pair<unsigned long, struct _albumIDAlbumContractID>(albumID, newData));

        return albumID;
    }


public:

    struct _albumIDAlbumContractID* nextItem() { return (struct _albumIDAlbumContractID*)_theIterator.next(); }

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

    virtual unsigned long _getDynamicElementSize() { return sizeof(struct _albumIDAlbumContractID); }

    virtual unsigned long _equalKeys(void* ptrA, void* ptrB)
    {
        struct _albumIDAlbumContractID* dataA = (struct _albumIDAlbumContractID*)ptrA;
        struct _albumIDAlbumContractID* dataB = (struct _albumIDAlbumContractID*)ptrB;
        return (dataA->_album_id == dataB->_album_id);
    }


    multimap<unsigned long, struct _albumIDAlbumContractID>::iterator _outputIterator;

    virtual void* _getFirstDynamicKeyValuePtr()
    {
        _outputIterator = _map.begin();
        if (_outputIterator == _map.end())
        {
            return NULL;
        }
        return (void*) &(_outputIterator);
    }

    virtual void* _getNextDynamicKeyValuePtr()
    {
        ++_outputIterator;
        if (_outputIterator == _map.end())
        {
            return NULL;
        }
        return (void*) &(_outputIterator);
    }

    virtual long _getKey(void* dynamicDataPtr)
    {
        multimap<unsigned long, struct _albumIDAlbumContractID>::iterator *i = (multimap<unsigned long, struct _albumIDAlbumContractID>::iterator *)dynamicDataPtr;
        if (NULL == i){ return 0; }
        return (**i).first;
    }
    virtual void* _getValue(void* dynamicDataPtr)
    {
        multimap<unsigned long, struct _albumIDAlbumContractID>::iterator *i = (multimap<unsigned long, struct _albumIDAlbumContractID>::iterator *)dynamicDataPtr;
        if (NULL == i){ return 0; }
        return (void*) &((**i).second);
    }
};

#endif