From 0e3901ece9b7537c04cfb94bb087cd69c588a3f1 Mon Sep 17 00:00:00 2001 From: CodeCodon Date: Sun, 12 Jul 2015 14:55:53 -0500 Subject: [PATCH] readd missing generated code --- .../src/shared/generated/Decoder_cpp.template | 3380 +++++++++ .../src/shared/generated/Encoder_cpp.template | 2690 ++++++++ .../shared/generated/LoadObject_cpp.template | 542 ++ .../generated/ObjectQueries_cpp.template | 6083 +++++++++++++++++ .../shared/generated/ObjectQueries_h.template | 1341 ++++ .../src/shared/generated/Schema_h.template | 2870 ++++++++ 6 files changed, 16906 insertions(+) diff --git a/game/server/application/SwgDatabaseServer/src/shared/generated/Decoder_cpp.template b/game/server/application/SwgDatabaseServer/src/shared/generated/Decoder_cpp.template index 7005f139..4c1e0e2d 100644 --- a/game/server/application/SwgDatabaseServer/src/shared/generated/Decoder_cpp.template +++ b/game/server/application/SwgDatabaseServer/src/shared/generated/Decoder_cpp.template @@ -49,4 +49,3384 @@ #pragma warning(disable : 4100) //!!!BEGIN GENERATED DECODER +void SwgSnapshot::decodeSharedBattlefieldMarkerObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 13) + { + decodeSharedTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::BattlefieldMarkerObjectBufferRow *row=m_battlefieldMarkerObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_battlefieldMarkerObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedBattlefieldMarkerObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerBattlefieldMarkerObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 16) + { + decodeServerTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::BattlefieldMarkerObjectBufferRow *row=m_battlefieldMarkerObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_battlefieldMarkerObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 16: + { + std::string temp; + Archive::get(data,temp); + row->region_name=temp; + break; + } + case 17: + { + decodeBattlefieldParticipants(objectId,data,isBaseline); + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerBattlefieldMarkerObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientBattlefieldMarkerObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::BattlefieldMarkerObjectBufferRow *row=m_battlefieldMarkerObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_battlefieldMarkerObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientBattlefieldMarkerObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedBuildingObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 13) + { + decodeSharedTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::BuildingObjectBufferRow *row=m_buildingObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_buildingObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedBuildingObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerBuildingObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 16) + { + decodeServerTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::BuildingObjectBufferRow *row=m_buildingObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_buildingObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 16: + { + decodePropertyList(objectId,PropertyListBuffer::LI_Allowed,data,isBaseline); + break; + } + case 17: + { + decodePropertyList(objectId,PropertyListBuffer::LI_Banned,data,isBaseline); + break; + } + case 18: + { + bool temp; + Archive::get(data,temp); + row->is_public=temp; + break; + } + case 19: + { + int temp; + Archive::get(data,temp); + row->maintenance_cost=temp; + break; + } + case 20: + { + real temp; + Archive::get(data,temp); + row->time_last_checked=temp; + break; + } + case 21: + { + int temp; + Archive::get(data,temp); + row->city_id=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerBuildingObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientBuildingObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::BuildingObjectBufferRow *row=m_buildingObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_buildingObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientBuildingObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedCellObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 4) + { + decodeSharedServerObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::CellObjectBufferRow *row=m_cellObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_cellObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 4: + { + bool temp; + Archive::get(data,temp); + row->is_public=temp; + break; + } + case 5: + { + int temp; + Archive::get(data,temp); + row->cell_number=temp; + WARNING_STRICT_FATAL(temp==-1,("Received CellObject %s with cell number -1.\n",objectId.getValueString().c_str())); + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedCellObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerCellObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 11) + { + decodeServerServerObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::CellObjectBufferRow *row=m_cellObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_cellObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 11: + { + decodePropertyList(objectId,PropertyListBuffer::LI_Allowed,data,isBaseline); + break; + } + case 12: + { + decodePropertyList(objectId,PropertyListBuffer::LI_Banned,data,isBaseline); + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerCellObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientCellObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientServerObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::CellObjectBufferRow *row=m_cellObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_cellObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientCellObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedCityObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 4) + { + decodeSharedUniverseObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::CityObjectBufferRow *row=m_cityObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_cityObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedCityObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerCityObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 11) + { + decodeServerUniverseObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::CityObjectBufferRow *row=m_cityObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_cityObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 11: + { + decodePropertyList(objectId,PropertyListBuffer::LI_Cities,data,isBaseline); + break; + } + case 12: + { + decodePropertyList(objectId,PropertyListBuffer::LI_Citizens,data,isBaseline); + break; + } + case 13: + { + decodePropertyList(objectId,PropertyListBuffer::LI_CityStructures,data,isBaseline); + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerCityObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientCityObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientUniverseObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::CityObjectBufferRow *row=m_cityObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_cityObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientCityObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedCreatureObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 13) + { + decodeSharedTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::CreatureObjectBufferRow *row=m_creatureObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_creatureObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 13: + { + Postures::Enumerator temp; + Archive::get(data,temp); + row->posture=temp; + break; + } + case 14: + { + uint8 temp; + Archive::get(data,temp); + row->rank=temp; + break; + } + case 15: + { + NetworkId temp; + Archive::get(data,temp); + row->master_id=temp; + break; + } + case 16: + { + float temp; + Archive::get(data,temp); + row->scale_factor=temp; + break; + } + case 17: + { + int temp; + Archive::get(data,temp); + row->shock_wounds=temp; + break; + } + case 18: + { + uint64 temp; + Archive::get(data,temp); + row->states=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedCreatureObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerCreatureObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 16) + { + decodeServerTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::CreatureObjectBufferRow *row=m_creatureObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_creatureObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 16: + { + decodeAttributes(objectId,data,isBaseline,0); + break; + } + case 17: + { + float temp; + Archive::get(data,temp); + row->base_run_speed=temp; + break; + } + case 18: + { + float temp; + Archive::get(data,temp); + row->base_walk_speed=temp; + break; + } + case 19: + { + decodePersistedBuffs(data,row->persisted_buffs); + break; + } + case 20: + { + float temp; + Archive::get(data,temp); + row->ws_x=temp; + break; + } + case 21: + { + float temp; + Archive::get(data,temp); + row->ws_y=temp; + break; + } + case 22: + { + float temp; + Archive::get(data,temp); + row->ws_z=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerCreatureObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientCreatureObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::CreatureObjectBufferRow *row=m_creatureObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_creatureObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 2: + { + decodeAttributes(objectId,data,isBaseline,9); + break; + } + case 3: + { + decodePropertyList(objectId,PropertyListBuffer::LI_Skills,data,isBaseline); + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientCreatureObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedFactoryObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 13) + { + decodeSharedTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::FactoryObjectBufferRow *row=m_factoryObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_factoryObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedFactoryObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerFactoryObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 16) + { + decodeServerTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::FactoryObjectBufferRow *row=m_factoryObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_factoryObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerFactoryObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientFactoryObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::FactoryObjectBufferRow *row=m_factoryObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_factoryObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientFactoryObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedGuildObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 4) + { + decodeSharedUniverseObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::GuildObjectBufferRow *row=m_guildObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_guildObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 4: + { + decodePropertyList(objectId,PropertyListBuffer::LI_GuildAbbrevs,data,isBaseline); + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedGuildObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerGuildObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 11) + { + decodeServerUniverseObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::GuildObjectBufferRow *row=m_guildObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_guildObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 11: + { + decodePropertyList(objectId,PropertyListBuffer::LI_GuildNames,data,isBaseline); + break; + } + case 12: + { + decodePropertyList(objectId,PropertyListBuffer::LI_GuildLeaders,data,isBaseline); + break; + } + case 13: + { + decodePropertyList(objectId,PropertyListBuffer::LI_GuildMembers,data,isBaseline); + break; + } + case 14: + { + decodePropertyList(objectId,PropertyListBuffer::LI_GuildEnemies,data,isBaseline); + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerGuildObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientGuildObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientUniverseObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::GuildObjectBufferRow *row=m_guildObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_guildObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientGuildObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedHarvesterInstallationObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 16) + { + decodeSharedInstallationObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::HarvesterInstallationObjectBufferRow *row=m_harvesterInstallationObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_harvesterInstallationObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedHarvesterInstallationObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerHarvesterInstallationObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 19) + { + decodeServerInstallationObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::HarvesterInstallationObjectBufferRow *row=m_harvesterInstallationObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_harvesterInstallationObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 19: + { + float temp; + Archive::get(data,temp); + row->installed_efficiency=temp; + break; + } + case 20: + { + NetworkId temp; + Archive::get(data,temp); + row->resource_type=temp; + break; + } + case 21: + { + int temp; + Archive::get(data,temp); + row->max_extraction_rate=temp; + break; + } + case 22: + { + float temp; + Archive::get(data,temp); + row->current_extraction_rate=temp; + break; + } + case 23: + { + int temp; + Archive::get(data,temp); + row->max_hopper_amount=temp; + break; + } + case 24: + { + NetworkId temp; + Archive::get(data,temp); + row->hopper_resource=temp; + break; + } + case 25: + { + float temp; + Archive::get(data,temp); + row->hopper_amount=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerHarvesterInstallationObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientHarvesterInstallationObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientInstallationObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::HarvesterInstallationObjectBufferRow *row=m_harvesterInstallationObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_harvesterInstallationObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientHarvesterInstallationObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedInstallationObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 13) + { + decodeSharedTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::InstallationObjectBufferRow *row=m_installationObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_installationObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 13: + { + bool temp; + Archive::get(data,temp); + row->activated=temp; + break; + } + case 14: + { + float temp; + Archive::get(data,temp); + row->power=temp; + break; + } + case 15: + { + float temp; + Archive::get(data,temp); + row->power_rate=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedInstallationObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerInstallationObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 16) + { + decodeServerTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::InstallationObjectBufferRow *row=m_installationObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_installationObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 16: + { + int32 temp; + Archive::get(data,temp); + row->installation_type=temp; + break; + } + case 17: + { + float temp; + Archive::get(data,temp); + row->tick_count=temp; + break; + } + case 18: + { + float temp; + Archive::get(data,temp); + row->activate_start_time=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerInstallationObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientInstallationObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::InstallationObjectBufferRow *row=m_installationObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_installationObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientInstallationObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedIntangibleObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 4) + { + decodeSharedServerObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::IntangibleObjectBufferRow *row=m_intangibleObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_intangibleObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 4: + { + int temp; + Archive::get(data,temp); + row->count=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedIntangibleObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerIntangibleObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 11) + { + decodeServerServerObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::IntangibleObjectBufferRow *row=m_intangibleObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_intangibleObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerIntangibleObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientIntangibleObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientServerObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::IntangibleObjectBufferRow *row=m_intangibleObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_intangibleObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientIntangibleObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedManufactureInstallationObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 16) + { + decodeSharedInstallationObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::ManufactureInstallationObjectBufferRow *row=m_manufactureInstallationObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_manufactureInstallationObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedManufactureInstallationObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerManufactureInstallationObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 19) + { + decodeServerInstallationObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::ManufactureInstallationObjectBufferRow *row=m_manufactureInstallationObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_manufactureInstallationObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerManufactureInstallationObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientManufactureInstallationObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientInstallationObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::ManufactureInstallationObjectBufferRow *row=m_manufactureInstallationObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_manufactureInstallationObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientManufactureInstallationObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedManufactureSchematicObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 5) + { + decodeSharedIntangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::ManufactureSchematicObjectBufferRow *row=m_manufactureSchematicObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_manufactureSchematicObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 5: + { + decodeManufactureSchematicAttributes(objectId,data,isBaseline); + break; + } + case 6: + { + int temp; + Archive::get(data,temp); + row->items_per_container=temp; + break; + } + case 7: + { + float temp; + Archive::get(data,temp); + row->manufacture_time=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedManufactureSchematicObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerManufactureSchematicObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 11) + { + decodeServerIntangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::ManufactureSchematicObjectBufferRow *row=m_manufactureSchematicObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_manufactureSchematicObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 11: + { + int temp; + Archive::get(data,temp); + row->draft_schematic=temp; + break; + } + case 12: + { + NetworkId temp; + Archive::get(data,temp); + row->creator_id=temp; + break; + } + case 13: + { + Unicode::String temp; + Archive::get(data,temp); + row->creator_name=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerManufactureSchematicObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientManufactureSchematicObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientIntangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::ManufactureSchematicObjectBufferRow *row=m_manufactureSchematicObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_manufactureSchematicObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientManufactureSchematicObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedMissionObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 5) + { + decodeSharedIntangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::MissionObjectBufferRow *row=m_missionObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_missionObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 5: + { + int temp; + Archive::get(data,temp); + row->difficulty=temp; + break; + } + case 6: + { + decodeLocation(data,row->end_x,row->end_y,row->end_z,row->end_cell,row->end_scene); + break; + } + case 7: + { + Unicode::String temp; + Archive::get(data,temp); + row->mission_creator=temp; + break; + } + case 8: + { + int temp; + Archive::get(data,temp); + row->reward=temp; + break; + } + case 9: + { + decodeLocation(data,row->start_x,row->start_y,row->start_z,row->start_cell,row->start_scene); + break; + } + case 10: + { + uint32 temp; + Archive::get(data,temp); + row->target_appearance=temp; + break; + } + case 11: + { + decodeStringId(data,row->description_table,row->description_text); + break; + } + case 12: + { + decodeStringId(data,row->title_table,row->title_text); + break; + } + case 13: + { + int temp; + Archive::get(data,temp); + row->status=temp; + break; + } + case 14: + { + uint32 temp; + Archive::get(data,temp); + row->mission_type=temp; + break; + } + case 15: + { + std::string temp; + Archive::get(data,temp); + row->target_name=temp; + break; + } + case 16: + { + decodeSingleWaypoint(objectId,data,isBaseline); + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedMissionObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerMissionObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 11) + { + decodeServerIntangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::MissionObjectBufferRow *row=m_missionObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_missionObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 11: + { + std::string temp; + Archive::get(data,temp); + row->root_script_name=temp; + break; + } + case 12: + { + NetworkId temp; + Archive::get(data,temp); + row->mission_holder_id=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerMissionObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientMissionObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientIntangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::MissionObjectBufferRow *row=m_missionObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_missionObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientMissionObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedPlanetObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 4) + { + decodeSharedUniverseObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::PlanetObjectBufferRow *row=m_planetObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_planetObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedPlanetObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerPlanetObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 11) + { + decodeServerUniverseObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::PlanetObjectBufferRow *row=m_planetObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_planetObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 11: + { + std::string temp; + Archive::get(data,temp); + row->planet_name=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerPlanetObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientPlanetObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientUniverseObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::PlanetObjectBufferRow *row=m_planetObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_planetObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientPlanetObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedPlayerObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 5) + { + decodeSharedIntangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::PlayerObjectBufferRow *row=m_playerObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_playerObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 5: + { + decodeMatchMakingId(data,row->character_profile_id); + break; + } + case 6: + { + decodeMatchMakingId(data,row->personal_profile_id); + break; + } + case 7: + { + NullEncodedStandardString temp; + Archive::get(data,temp); + row->skill_title=temp; + break; + } + case 8: + { + int temp; + Archive::get(data,temp); + row->born_date=temp; + break; + } + case 9: + { + int temp; + Archive::get(data,temp); + row->played_time=temp; + break; + } + case 10: + { + int temp; + Archive::get(data,temp); + row->role_icon_choice=temp; + break; + } + case 11: + { + std::string temp; + Archive::get(data,temp); + row->skill_template=temp; + break; + } + case 12: + { + int32 temp; + Archive::get(data,temp); + row->current_gcw_points=temp; + break; + } + case 13: + { + int32 temp; + Archive::get(data,temp); + row->current_pvp_kills=temp; + break; + } + case 14: + { + int64 temp; + Archive::get(data,temp); + row->lifetime_gcw_points=temp; + break; + } + case 15: + { + int32 temp; + Archive::get(data,temp); + row->lifetime_pvp_kills=temp; + break; + } + case 16: + { + BitArray temp; + Archive::get(data,temp); + row->collections=temp; + break; + } + case 17: + { + BitArray temp; + Archive::get(data,temp); + row->collections2=temp; + break; + } + case 18: + { + bool temp; + Archive::get(data,temp); + row->show_backpack=temp; + break; + } + case 19: + { + bool temp; + Archive::get(data,temp); + row->show_helmet=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedPlayerObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerPlayerObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 11) + { + decodeServerIntangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::PlayerObjectBufferRow *row=m_playerObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_playerObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 11: + { + StationId temp; + Archive::get(data,temp); + row->station_id=temp; + break; + } + case 12: + { + NetworkId temp; + Archive::get(data,temp); + row->house_id=temp; + break; + } + case 13: + { + int temp; + Archive::get(data,temp); + row->account_num_lots=temp; + break; + } + case 14: + { + int temp; + Archive::get(data,temp); + row->account_max_lots_adjustment=temp; + break; + } + case 15: + { + bool temp; + Archive::get(data,temp); + row->account_is_outcast=temp; + break; + } + case 16: + { + float temp; + Archive::get(data,temp); + row->account_cheater_level=temp; + break; + } + case 17: + { + float temp; + Archive::get(data,temp); + row->force_regen_rate=temp; + break; + } + case 18: + { + int32 temp; + Archive::get(data,temp); + row->current_gcw_rating=temp; + break; + } + case 19: + { + int32 temp; + Archive::get(data,temp); + row->max_gcw_imperial_rating=temp; + break; + } + case 20: + { + int32 temp; + Archive::get(data,temp); + row->max_gcw_rebel_rating=temp; + break; + } + case 21: + { + int32 temp; + Archive::get(data,temp); + row->next_gcw_rating_calc_time=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerPlayerObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientPlayerObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientIntangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::PlayerObjectBufferRow *row=m_playerObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_playerObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientPlayerObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedPlayerQuestObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 13) + { + decodeSharedTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::PlayerQuestObjectBufferRow *row=m_playerQuestObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_playerQuestObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 13: + { + std::string temp; + Archive::get(data,temp); + row->title=temp; + break; + } + case 14: + { + std::string temp; + Archive::get(data,temp); + row->description=temp; + break; + } + case 15: + { + NetworkId temp; + Archive::get(data,temp); + row->creator=temp; + break; + } + case 16: + { + int temp; + Archive::get(data,temp); + row->total_tasks=temp; + break; + } + case 17: + { + int temp; + Archive::get(data,temp); + row->difficulty=temp; + break; + } + case 18: + { + std::string temp; + Archive::get(data,temp); + row->task_title1=temp; + break; + } + case 19: + { + std::string temp; + Archive::get(data,temp); + row->task_description1=temp; + break; + } + case 20: + { + std::string temp; + Archive::get(data,temp); + row->task_title2=temp; + break; + } + case 21: + { + std::string temp; + Archive::get(data,temp); + row->task_description2=temp; + break; + } + case 22: + { + std::string temp; + Archive::get(data,temp); + row->task_title3=temp; + break; + } + case 23: + { + std::string temp; + Archive::get(data,temp); + row->task_description3=temp; + break; + } + case 24: + { + std::string temp; + Archive::get(data,temp); + row->task_title4=temp; + break; + } + case 25: + { + std::string temp; + Archive::get(data,temp); + row->task_description4=temp; + break; + } + case 26: + { + std::string temp; + Archive::get(data,temp); + row->task_title5=temp; + break; + } + case 27: + { + std::string temp; + Archive::get(data,temp); + row->task_description5=temp; + break; + } + case 28: + { + std::string temp; + Archive::get(data,temp); + row->task_title6=temp; + break; + } + case 29: + { + std::string temp; + Archive::get(data,temp); + row->task_description6=temp; + break; + } + case 30: + { + std::string temp; + Archive::get(data,temp); + row->task_title7=temp; + break; + } + case 31: + { + std::string temp; + Archive::get(data,temp); + row->task_description7=temp; + break; + } + case 32: + { + std::string temp; + Archive::get(data,temp); + row->task_title8=temp; + break; + } + case 33: + { + std::string temp; + Archive::get(data,temp); + row->task_description8=temp; + break; + } + case 34: + { + std::string temp; + Archive::get(data,temp); + row->task_title9=temp; + break; + } + case 35: + { + std::string temp; + Archive::get(data,temp); + row->task_description9=temp; + break; + } + case 36: + { + std::string temp; + Archive::get(data,temp); + row->task_title10=temp; + break; + } + case 37: + { + std::string temp; + Archive::get(data,temp); + row->task_description10=temp; + break; + } + case 38: + { + std::string temp; + Archive::get(data,temp); + row->task_title11=temp; + break; + } + case 39: + { + std::string temp; + Archive::get(data,temp); + row->task_description11=temp; + break; + } + case 40: + { + std::string temp; + Archive::get(data,temp); + row->task_title12=temp; + break; + } + case 41: + { + std::string temp; + Archive::get(data,temp); + row->task_description12=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedPlayerQuestObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerPlayerQuestObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 16) + { + decodeServerTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::PlayerQuestObjectBufferRow *row=m_playerQuestObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_playerQuestObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerPlayerQuestObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientPlayerQuestObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::PlayerQuestObjectBufferRow *row=m_playerQuestObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_playerQuestObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientPlayerQuestObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedResourceContainerObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 13) + { + decodeSharedTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::ResourceContainerObjectBufferRow *row=m_resourceContainerObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_resourceContainerObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 13: + { + int temp; + Archive::get(data,temp); + row->quantity=temp; + break; + } + case 14: + { + NetworkId temp; + Archive::get(data,temp); + row->resource_type=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedResourceContainerObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerResourceContainerObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 16) + { + decodeServerTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::ResourceContainerObjectBufferRow *row=m_resourceContainerObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_resourceContainerObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 16: + { + NetworkId temp; + Archive::get(data,temp); + row->source=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerResourceContainerObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientResourceContainerObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::ResourceContainerObjectBufferRow *row=m_resourceContainerObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_resourceContainerObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientResourceContainerObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedServerObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + DBSchema::ObjectBufferRow *row=m_objectTableBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_objectTableBuffer.addEmptyRow(objectId); + + switch(index) + { + case 0: + { + float temp; + Archive::get(data,temp); + row->complexity=temp; + break; + } + case 1: + { + decodeStringId(data,row->name_string_table,row->name_string_text); + break; + } + case 2: + { + NullEncodedUnicodeString temp; + Archive::get(data,temp); + row->object_name=temp; + break; + } + case 3: + { + int temp; + Archive::get(data,temp); + row->volume=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedServerObject. Index is %hu.\n",index)); + } +} + +void SwgSnapshot::decodeServerServerObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + DBSchema::ObjectBufferRow *row=m_objectTableBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_objectTableBuffer.addEmptyRow(objectId); + + switch(index) + { + case 0: + { + int temp; + Archive::get(data,temp); + row->cache_version=temp; + break; + } + case 1: + { + bool temp; + Archive::get(data,temp); + row->load_contents=temp; + break; + } + case 2: + { + decodeObjVarFreeFlags(objectId,data,isBaseline); + break; + } + case 3: + { + decodeObjVars(objectId,data,isBaseline); + break; + } + case 4: + { + ignorePersistedFlag(objectId,data); + break; + } + case 5: + { + bool temp; + Archive::get(data,temp); + row->player_controlled=temp; + break; + } + case 6: + { + std::string temp; + Archive::get(data,temp); + row->scene_id=temp; + break; + } + case 7: + { + decodeScriptObject(objectId,data,isBaseline); + break; + } + case 8: + { + int temp; + Archive::get(data,temp); + row->conversion_id=temp; + break; + } + case 9: + { + std::string temp; + Archive::get(data,temp); + row->static_item_name=temp; + break; + } + case 10: + { + int temp; + Archive::get(data,temp); + row->static_item_version=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerServerObject. Index is %hu.\n",index)); + } +} + +void SwgSnapshot::decodeClientServerObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + DBSchema::ObjectBufferRow *row=m_objectTableBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_objectTableBuffer.addEmptyRow(objectId); + + switch(index) + { + case 0: + { + int temp; + Archive::get(data,temp); + row->bank_balance=temp; + break; + } + case 1: + { + int temp; + Archive::get(data,temp); + row->cash_balance=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientServerObject. Index is %hu.\n",index)); + } +} + +void SwgSnapshot::decodeSharedShipObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 13) + { + decodeSharedTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::ShipObjectBufferRow *row=m_shipObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_shipObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 13: + { + float temp; + Archive::get(data,temp); + row->slide_dampener=temp; + break; + } + case 14: + { + float temp; + Archive::get(data,temp); + row->current_chassis_hit_points=temp; + break; + } + case 15: + { + float temp; + Archive::get(data,temp); + row->maximum_chassis_hit_points=temp; + break; + } + case 16: + { + uint32 temp; + Archive::get(data,temp); + row->chassis_type=temp; + break; + } + case 17: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->cmp_armor_hp_maximum=packedValue; + break; + } + case 18: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->cmp_armor_hp_current=packedValue; + break; + } + case 19: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->cmp_hp_current=packedValue; + break; + } + case 20: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->cmp_hp_maximum=packedValue; + break; + } + case 21: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->cmp_flags=packedValue; + break; + } + case 22: + { + float temp; + Archive::get(data,temp); + row->shield_hp_front_maximum=temp; + break; + } + case 23: + { + float temp; + Archive::get(data,temp); + row->shield_hp_back_maximum=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedShipObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerShipObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 16) + { + decodeServerTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::ShipObjectBufferRow *row=m_shipObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_shipObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 16: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->cmp_crc=packedValue; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerShipObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientShipObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::ShipObjectBufferRow *row=m_shipObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_shipObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 2: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->cmp_efficiency_general=packedValue; + break; + } + case 3: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->cmp_efficiency_eng=packedValue; + break; + } + case 4: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->cmp_eng_maintenance=packedValue; + break; + } + case 5: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->cmp_mass=packedValue; + break; + } + case 6: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->cmp_names=packedValue; + break; + } + case 7: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->cmp_creators=packedValue; + break; + } + case 8: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->weapon_damage_maximum=packedValue; + break; + } + case 9: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->weapon_damage_minimum=packedValue; + break; + } + case 10: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->weapon_effectiveness_shields=packedValue; + break; + } + case 11: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->weapon_effectiveness_armor=packedValue; + break; + } + case 12: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->weapon_eng_per_shot=packedValue; + break; + } + case 13: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->weapon_refire_rate=packedValue; + break; + } + case 14: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->weapon_ammo_current=packedValue; + break; + } + case 15: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->weapon_ammo_maximum=packedValue; + break; + } + case 16: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->weapon_ammo_type=packedValue; + break; + } + case 17: + { + float temp; + Archive::get(data,temp); + row->chassis_cmp_mass_maximum=temp; + break; + } + case 18: + { + float temp; + Archive::get(data,temp); + row->shield_recharge_rate=temp; + break; + } + case 19: + { + float temp; + Archive::get(data,temp); + row->capacitor_eng_maximum=temp; + break; + } + case 20: + { + float temp; + Archive::get(data,temp); + row->capacitor_eng_recharge_rate=temp; + break; + } + case 21: + { + float temp; + Archive::get(data,temp); + row->engine_acc_rate=temp; + break; + } + case 22: + { + float temp; + Archive::get(data,temp); + row->engine_deceleration_rate=temp; + break; + } + case 23: + { + float temp; + Archive::get(data,temp); + row->engine_pitch_acc_rate=temp; + break; + } + case 24: + { + float temp; + Archive::get(data,temp); + row->engine_yaw_acc_rate=temp; + break; + } + case 25: + { + float temp; + Archive::get(data,temp); + row->engine_roll_acc_rate=temp; + break; + } + case 26: + { + float temp; + Archive::get(data,temp); + row->engine_pitch_rate_maximum=temp; + break; + } + case 27: + { + float temp; + Archive::get(data,temp); + row->engine_yaw_rate_maximum=temp; + break; + } + case 28: + { + float temp; + Archive::get(data,temp); + row->engine_roll_rate_maximum=temp; + break; + } + case 29: + { + float temp; + Archive::get(data,temp); + row->engine_speed_maximum=temp; + break; + } + case 30: + { + float temp; + Archive::get(data,temp); + row->reactor_eng_generation_rate=temp; + break; + } + case 31: + { + float temp; + Archive::get(data,temp); + row->booster_eng_maximum=temp; + break; + } + case 32: + { + float temp; + Archive::get(data,temp); + row->booster_eng_recharge_rate=temp; + break; + } + case 33: + { + float temp; + Archive::get(data,temp); + row->booster_eng_consumption_rate=temp; + break; + } + case 34: + { + float temp; + Archive::get(data,temp); + row->booster_acc=temp; + break; + } + case 35: + { + float temp; + Archive::get(data,temp); + row->booster_speed_maximum=temp; + break; + } + case 36: + { + float temp; + Archive::get(data,temp); + row->droid_if_cmd_speed=temp; + break; + } + case 37: + { + NetworkId temp; + Archive::get(data,temp); + row->installed_dcd=temp; + break; + } + case 38: + { + int temp; + Archive::get(data,temp); + row->cargo_hold_contents_maximum=temp; + break; + } + case 39: + { + int temp; + Archive::get(data,temp); + row->cargo_hold_contents_current=temp; + break; + } + case 40: + { + std::string packedValue; + Archive::AutoDeltaPackedMap::unpack(data,packedValue); + row->cargo_hold_contents=packedValue; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientShipObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedStaticObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 4) + { + decodeSharedServerObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::StaticObjectBufferRow *row=m_staticObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_staticObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedStaticObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerStaticObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 11) + { + decodeServerServerObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::StaticObjectBufferRow *row=m_staticObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_staticObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerStaticObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientStaticObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientServerObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::StaticObjectBufferRow *row=m_staticObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_staticObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientStaticObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedTangibleObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 4) + { + decodeSharedServerObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::TangibleObjectBufferRow *row=m_tangibleObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_tangibleObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 4: + { + uint32 temp; + Archive::get(data,temp); + row->pvp_faction=temp; + break; + } + case 5: + { + int temp; + Archive::get(data,temp); + row->pvp_type=temp; + break; + } + case 6: + { + std::string temp; + Archive::get(data,temp); + row->appearance_data=temp; + break; + } + case 7: + { + decodeComponents(objectId,data,isBaseline); + break; + } + case 8: + { + int temp; + Archive::get(data,temp); + row->condition=temp; + break; + } + case 9: + { + int temp; + Archive::get(data,temp); + row->count=temp; + break; + } + case 10: + { + int temp; + Archive::get(data,temp); + row->damage_taken=temp; + break; + } + case 11: + { + int temp; + Archive::get(data,temp); + row->max_hit_points=temp; + break; + } + case 12: + { + bool temp; + Archive::get(data,temp); + row->visible=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedTangibleObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerTangibleObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 11) + { + decodeServerServerObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::TangibleObjectBufferRow *row=m_tangibleObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_tangibleObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 11: + { + std::string temp; + Archive::get(data,temp); + row->custom_appearance=temp; + break; + } + case 12: + { + decodeLocationDataList(objectId,1,data,isBaseline); + break; + } + case 13: + { + NetworkId temp; + Archive::get(data,temp); + row->owner_id=temp; + break; + } + case 14: + { + NetworkId temp; + Archive::get(data,temp); + row->creator_id=temp; + break; + } + case 15: + { + uint32 temp; + Archive::get(data,temp); + row->source_draft_schematic=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerTangibleObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientTangibleObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientServerObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::TangibleObjectBufferRow *row=m_tangibleObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_tangibleObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientTangibleObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedUniverseObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 4) + { + decodeSharedServerObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::UniverseObjectBufferRow *row=m_universeObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_universeObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedUniverseObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerUniverseObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 11) + { + decodeServerServerObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::UniverseObjectBufferRow *row=m_universeObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_universeObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerUniverseObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientUniverseObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientServerObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::UniverseObjectBufferRow *row=m_universeObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_universeObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientUniverseObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedVehicleObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 13) + { + decodeSharedTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::VehicleObjectBufferRow *row=m_vehicleObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_vehicleObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedVehicleObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerVehicleObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 16) + { + decodeServerTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::VehicleObjectBufferRow *row=m_vehicleObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_vehicleObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 16: + { + int temp; + Archive::get(data,temp); + row->bogus=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerVehicleObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientVehicleObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::VehicleObjectBufferRow *row=m_vehicleObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_vehicleObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientVehicleObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeSharedWeaponObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 13) + { + decodeSharedTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::WeaponObjectBufferRow *row=m_weaponObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_weaponObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 13: + { + float temp; + Archive::get(data,temp); + row->attack_speed=temp; + break; + } + case 14: + { + int temp; + Archive::get(data,temp); + row->accuracy=temp; + break; + } + case 15: + { + float temp; + Archive::get(data,temp); + row->min_range=temp; + break; + } + case 16: + { + float temp; + Archive::get(data,temp); + row->max_range=temp; + break; + } + case 17: + { + int temp; + Archive::get(data,temp); + row->damage_type=temp; + break; + } + case 18: + { + int temp; + Archive::get(data,temp); + row->elemental_type=temp; + break; + } + case 19: + { + int temp; + Archive::get(data,temp); + row->elemental_value=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeSharedWeaponObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeServerWeaponObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 16) + { + decodeServerTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::WeaponObjectBufferRow *row=m_weaponObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_weaponObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 16: + { + int temp; + Archive::get(data,temp); + row->min_damage=temp; + break; + } + case 17: + { + int temp; + Archive::get(data,temp); + row->max_damage=temp; + break; + } + case 18: + { + float temp; + Archive::get(data,temp); + row->wound_chance=temp; + break; + } + case 19: + { + int temp; + Archive::get(data,temp); + row->attack_cost=temp; + break; + } + case 20: + { + float temp; + Archive::get(data,temp); + row->damage_radius=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeServerWeaponObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeClientWeaponObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + if (index < 2) + { + decodeClientTangibleObject(objectId,index,data, isBaseline); + } + else + { + DBSchema::WeaponObjectBufferRow *row=m_weaponObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_weaponObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeClientWeaponObject. Index is %hu.\n",index)); + } + } +} + +void SwgSnapshot::decodeParentClientPlayerObject(NetworkId const & objectId, uint16 index, Archive::ReadIterator &data, bool isBaseline) +{ + UNREF(isBaseline); + + DBSchema::PlayerObjectBufferRow *row=m_playerObjectBuffer.findRowByIndex(objectId); + if (row==NULL) + row=m_playerObjectBuffer.addEmptyRow(objectId); + + switch(index) + { + case 0: + { + decodeExperience(objectId,data,isBaseline); + break; + } + case 1: + { + decodeWaypoints(objectId,data,isBaseline); + break; + } + case 2: + { + int temp; + Archive::get(data,temp); + row->force_power=temp; + break; + } + case 3: + { + int temp; + Archive::get(data,temp); + row->max_force_power=temp; + break; + } + case 4: + { + BitArray temp; + Archive::get(data,temp); + row->completed_quests=temp; + break; + } + case 5: + { + BitArray temp; + Archive::get(data,temp); + row->active_quests=temp; + break; + } + case 6: + { + uint32 temp; + Archive::get(data,temp); + row->current_quest=temp; + break; + } + case 7: + { + decodeQuests(objectId,data,row->quests,row->quests2,row->quests3,row->quests4); + break; + } + case 8: + { + std::string temp; + Archive::get(data,temp); + row->working_skill=temp; + break; + } + default: + DEBUG_REPORT_LOG(true,("Fell through cases in decodeParentClientPlayerObject. Index is %hu.\n",index)); + } +} + +void SwgSnapshot::decodeServerData(NetworkId const & objectId, Tag typeId, uint16 index, Archive::ReadIterator &bs, bool isBaseline) +{ + switch(typeId) + { + case ServerBattlefieldMarkerObjectTemplate::ServerBattlefieldMarkerObjectTemplate_tag: + decodeServerBattlefieldMarkerObject(objectId, index, bs, isBaseline); + break; + case ServerBuildingObjectTemplate::ServerBuildingObjectTemplate_tag: + decodeServerBuildingObject(objectId, index, bs, isBaseline); + break; + case ServerCellObjectTemplate::ServerCellObjectTemplate_tag: + decodeServerCellObject(objectId, index, bs, isBaseline); + break; + case ServerCityObjectTemplate::ServerCityObjectTemplate_tag: + decodeServerCityObject(objectId, index, bs, isBaseline); + break; + case ServerCreatureObjectTemplate::ServerCreatureObjectTemplate_tag: + decodeServerCreatureObject(objectId, index, bs, isBaseline); + break; + case ServerFactoryObjectTemplate::ServerFactoryObjectTemplate_tag: + decodeServerFactoryObject(objectId, index, bs, isBaseline); + break; + case ServerGuildObjectTemplate::ServerGuildObjectTemplate_tag: + decodeServerGuildObject(objectId, index, bs, isBaseline); + break; + case ServerHarvesterInstallationObjectTemplate::ServerHarvesterInstallationObjectTemplate_tag: + decodeServerHarvesterInstallationObject(objectId, index, bs, isBaseline); + break; + case ServerInstallationObjectTemplate::ServerInstallationObjectTemplate_tag: + decodeServerInstallationObject(objectId, index, bs, isBaseline); + break; + case ServerIntangibleObjectTemplate::ServerIntangibleObjectTemplate_tag: + decodeServerIntangibleObject(objectId, index, bs, isBaseline); + break; + case ServerManufactureInstallationObjectTemplate::ServerManufactureInstallationObjectTemplate_tag: + decodeServerManufactureInstallationObject(objectId, index, bs, isBaseline); + break; + case ServerManufactureSchematicObjectTemplate::ServerManufactureSchematicObjectTemplate_tag: + decodeServerManufactureSchematicObject(objectId, index, bs, isBaseline); + break; + case ServerMissionObjectTemplate::ServerMissionObjectTemplate_tag: + decodeServerMissionObject(objectId, index, bs, isBaseline); + break; + case ServerPlanetObjectTemplate::ServerPlanetObjectTemplate_tag: + decodeServerPlanetObject(objectId, index, bs, isBaseline); + break; + case ServerPlayerObjectTemplate::ServerPlayerObjectTemplate_tag: + decodeServerPlayerObject(objectId, index, bs, isBaseline); + break; + case ServerPlayerQuestObjectTemplate::ServerPlayerQuestObjectTemplate_tag: + decodeServerPlayerQuestObject(objectId, index, bs, isBaseline); + break; + case ServerResourceContainerObjectTemplate::ServerResourceContainerObjectTemplate_tag: + decodeServerResourceContainerObject(objectId, index, bs, isBaseline); + break; + case ServerObjectTemplate::ServerObjectTemplate_tag: + decodeServerServerObject(objectId, index, bs, isBaseline); + break; + case ServerShipObjectTemplate::ServerShipObjectTemplate_tag: + decodeServerShipObject(objectId, index, bs, isBaseline); + break; + case ServerStaticObjectTemplate::ServerStaticObjectTemplate_tag: + decodeServerStaticObject(objectId, index, bs, isBaseline); + break; + case ServerTangibleObjectTemplate::ServerTangibleObjectTemplate_tag: + decodeServerTangibleObject(objectId, index, bs, isBaseline); + break; + case ServerUniverseObjectTemplate::ServerUniverseObjectTemplate_tag: + decodeServerUniverseObject(objectId, index, bs, isBaseline); + break; + case ServerVehicleObjectTemplate::ServerVehicleObjectTemplate_tag: + decodeServerVehicleObject(objectId, index, bs, isBaseline); + break; + case ServerWeaponObjectTemplate::ServerWeaponObjectTemplate_tag: + decodeServerWeaponObject(objectId, index, bs, isBaseline); + break; + } +} + +void SwgSnapshot::decodeSharedData(NetworkId const & objectId, Tag typeId, uint16 index, Archive::ReadIterator &bs, bool isBaseline) +{ + switch(typeId) + { + case ServerBattlefieldMarkerObjectTemplate::ServerBattlefieldMarkerObjectTemplate_tag: + decodeSharedBattlefieldMarkerObject(objectId, index, bs, isBaseline); + break; + case ServerBuildingObjectTemplate::ServerBuildingObjectTemplate_tag: + decodeSharedBuildingObject(objectId, index, bs, isBaseline); + break; + case ServerCellObjectTemplate::ServerCellObjectTemplate_tag: + decodeSharedCellObject(objectId, index, bs, isBaseline); + break; + case ServerCityObjectTemplate::ServerCityObjectTemplate_tag: + decodeSharedCityObject(objectId, index, bs, isBaseline); + break; + case ServerCreatureObjectTemplate::ServerCreatureObjectTemplate_tag: + decodeSharedCreatureObject(objectId, index, bs, isBaseline); + break; + case ServerFactoryObjectTemplate::ServerFactoryObjectTemplate_tag: + decodeSharedFactoryObject(objectId, index, bs, isBaseline); + break; + case ServerGuildObjectTemplate::ServerGuildObjectTemplate_tag: + decodeSharedGuildObject(objectId, index, bs, isBaseline); + break; + case ServerHarvesterInstallationObjectTemplate::ServerHarvesterInstallationObjectTemplate_tag: + decodeSharedHarvesterInstallationObject(objectId, index, bs, isBaseline); + break; + case ServerInstallationObjectTemplate::ServerInstallationObjectTemplate_tag: + decodeSharedInstallationObject(objectId, index, bs, isBaseline); + break; + case ServerIntangibleObjectTemplate::ServerIntangibleObjectTemplate_tag: + decodeSharedIntangibleObject(objectId, index, bs, isBaseline); + break; + case ServerManufactureInstallationObjectTemplate::ServerManufactureInstallationObjectTemplate_tag: + decodeSharedManufactureInstallationObject(objectId, index, bs, isBaseline); + break; + case ServerManufactureSchematicObjectTemplate::ServerManufactureSchematicObjectTemplate_tag: + decodeSharedManufactureSchematicObject(objectId, index, bs, isBaseline); + break; + case ServerMissionObjectTemplate::ServerMissionObjectTemplate_tag: + decodeSharedMissionObject(objectId, index, bs, isBaseline); + break; + case ServerPlanetObjectTemplate::ServerPlanetObjectTemplate_tag: + decodeSharedPlanetObject(objectId, index, bs, isBaseline); + break; + case ServerPlayerObjectTemplate::ServerPlayerObjectTemplate_tag: + decodeSharedPlayerObject(objectId, index, bs, isBaseline); + break; + case ServerPlayerQuestObjectTemplate::ServerPlayerQuestObjectTemplate_tag: + decodeSharedPlayerQuestObject(objectId, index, bs, isBaseline); + break; + case ServerResourceContainerObjectTemplate::ServerResourceContainerObjectTemplate_tag: + decodeSharedResourceContainerObject(objectId, index, bs, isBaseline); + break; + case ServerObjectTemplate::ServerObjectTemplate_tag: + decodeSharedServerObject(objectId, index, bs, isBaseline); + break; + case ServerShipObjectTemplate::ServerShipObjectTemplate_tag: + decodeSharedShipObject(objectId, index, bs, isBaseline); + break; + case ServerStaticObjectTemplate::ServerStaticObjectTemplate_tag: + decodeSharedStaticObject(objectId, index, bs, isBaseline); + break; + case ServerTangibleObjectTemplate::ServerTangibleObjectTemplate_tag: + decodeSharedTangibleObject(objectId, index, bs, isBaseline); + break; + case ServerUniverseObjectTemplate::ServerUniverseObjectTemplate_tag: + decodeSharedUniverseObject(objectId, index, bs, isBaseline); + break; + case ServerVehicleObjectTemplate::ServerVehicleObjectTemplate_tag: + decodeSharedVehicleObject(objectId, index, bs, isBaseline); + break; + case ServerWeaponObjectTemplate::ServerWeaponObjectTemplate_tag: + decodeSharedWeaponObject(objectId, index, bs, isBaseline); + break; + } +} + +void SwgSnapshot::decodeClientData(NetworkId const & objectId, Tag typeId, uint16 index, Archive::ReadIterator &bs, bool isBaseline) +{ + switch(typeId) + { + case ServerBattlefieldMarkerObjectTemplate::ServerBattlefieldMarkerObjectTemplate_tag: + decodeClientBattlefieldMarkerObject(objectId, index, bs, isBaseline); + break; + case ServerBuildingObjectTemplate::ServerBuildingObjectTemplate_tag: + decodeClientBuildingObject(objectId, index, bs, isBaseline); + break; + case ServerCellObjectTemplate::ServerCellObjectTemplate_tag: + decodeClientCellObject(objectId, index, bs, isBaseline); + break; + case ServerCityObjectTemplate::ServerCityObjectTemplate_tag: + decodeClientCityObject(objectId, index, bs, isBaseline); + break; + case ServerCreatureObjectTemplate::ServerCreatureObjectTemplate_tag: + decodeClientCreatureObject(objectId, index, bs, isBaseline); + break; + case ServerFactoryObjectTemplate::ServerFactoryObjectTemplate_tag: + decodeClientFactoryObject(objectId, index, bs, isBaseline); + break; + case ServerGuildObjectTemplate::ServerGuildObjectTemplate_tag: + decodeClientGuildObject(objectId, index, bs, isBaseline); + break; + case ServerHarvesterInstallationObjectTemplate::ServerHarvesterInstallationObjectTemplate_tag: + decodeClientHarvesterInstallationObject(objectId, index, bs, isBaseline); + break; + case ServerInstallationObjectTemplate::ServerInstallationObjectTemplate_tag: + decodeClientInstallationObject(objectId, index, bs, isBaseline); + break; + case ServerIntangibleObjectTemplate::ServerIntangibleObjectTemplate_tag: + decodeClientIntangibleObject(objectId, index, bs, isBaseline); + break; + case ServerManufactureInstallationObjectTemplate::ServerManufactureInstallationObjectTemplate_tag: + decodeClientManufactureInstallationObject(objectId, index, bs, isBaseline); + break; + case ServerManufactureSchematicObjectTemplate::ServerManufactureSchematicObjectTemplate_tag: + decodeClientManufactureSchematicObject(objectId, index, bs, isBaseline); + break; + case ServerMissionObjectTemplate::ServerMissionObjectTemplate_tag: + decodeClientMissionObject(objectId, index, bs, isBaseline); + break; + case ServerPlanetObjectTemplate::ServerPlanetObjectTemplate_tag: + decodeClientPlanetObject(objectId, index, bs, isBaseline); + break; + case ServerPlayerObjectTemplate::ServerPlayerObjectTemplate_tag: + decodeClientPlayerObject(objectId, index, bs, isBaseline); + break; + case ServerPlayerQuestObjectTemplate::ServerPlayerQuestObjectTemplate_tag: + decodeClientPlayerQuestObject(objectId, index, bs, isBaseline); + break; + case ServerResourceContainerObjectTemplate::ServerResourceContainerObjectTemplate_tag: + decodeClientResourceContainerObject(objectId, index, bs, isBaseline); + break; + case ServerObjectTemplate::ServerObjectTemplate_tag: + decodeClientServerObject(objectId, index, bs, isBaseline); + break; + case ServerShipObjectTemplate::ServerShipObjectTemplate_tag: + decodeClientShipObject(objectId, index, bs, isBaseline); + break; + case ServerStaticObjectTemplate::ServerStaticObjectTemplate_tag: + decodeClientStaticObject(objectId, index, bs, isBaseline); + break; + case ServerTangibleObjectTemplate::ServerTangibleObjectTemplate_tag: + decodeClientTangibleObject(objectId, index, bs, isBaseline); + break; + case ServerUniverseObjectTemplate::ServerUniverseObjectTemplate_tag: + decodeClientUniverseObject(objectId, index, bs, isBaseline); + break; + case ServerVehicleObjectTemplate::ServerVehicleObjectTemplate_tag: + decodeClientVehicleObject(objectId, index, bs, isBaseline); + break; + case ServerWeaponObjectTemplate::ServerWeaponObjectTemplate_tag: + decodeClientWeaponObject(objectId, index, bs, isBaseline); + break; + } +} + +void SwgSnapshot::decodeParentClientData(NetworkId const & objectId, Tag typeId, uint16 index, Archive::ReadIterator &bs, bool isBaseline) +{ + switch(typeId) + { + case ServerPlayerObjectTemplate::ServerPlayerObjectTemplate_tag: + decodeParentClientPlayerObject(objectId, index, bs, isBaseline); + break; + } +} + //!!!END GENERATED DECODER diff --git a/game/server/application/SwgDatabaseServer/src/shared/generated/Encoder_cpp.template b/game/server/application/SwgDatabaseServer/src/shared/generated/Encoder_cpp.template index 494b6ce0..1dba75a4 100644 --- a/game/server/application/SwgDatabaseServer/src/shared/generated/Encoder_cpp.template +++ b/game/server/application/SwgDatabaseServer/src/shared/generated/Encoder_cpp.template @@ -50,4 +50,2694 @@ #include //!!!BEGIN GENERATED ENCODER +bool SwgSnapshot::encodeSharedBattlefieldMarkerObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=13; + Archive::put(data,temp); + } + encodeSharedTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedBattlefieldMarkerObject"); + + const DBSchema::BattlefieldMarkerObjectBufferRow *row=m_battlefieldMarkerObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no BattlefieldMarkerObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeServerBattlefieldMarkerObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=18; + Archive::put(data,temp); + } + encodeServerTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerBattlefieldMarkerObject"); + + const DBSchema::BattlefieldMarkerObjectBufferRow *row=m_battlefieldMarkerObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no BattlefieldMarkerObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + std::string temp; + row->region_name.getValue(temp); + Archive::put(data,temp); + } + encodeBattlefieldParticipants(objectId,data); + return true; +} + +bool SwgSnapshot::encodeClientBattlefieldMarkerObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientBattlefieldMarkerObject"); + + const DBSchema::BattlefieldMarkerObjectBufferRow *row=m_battlefieldMarkerObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no BattlefieldMarkerObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedBuildingObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=13; + Archive::put(data,temp); + } + encodeSharedTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedBuildingObject"); + + const DBSchema::BuildingObjectBufferRow *row=m_buildingObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no BuildingObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeServerBuildingObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=22; + Archive::put(data,temp); + } + encodeServerTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerBuildingObject"); + + const DBSchema::BuildingObjectBufferRow *row=m_buildingObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no BuildingObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + encodePropertyList(objectId,PropertyListBuffer::LI_Allowed,data); + encodePropertyList(objectId,PropertyListBuffer::LI_Banned,data); + { + bool temp; + row->is_public.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->maintenance_cost.getValue(temp); + Archive::put(data,temp); + } + { + real temp; + row->time_last_checked.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->city_id.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeClientBuildingObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientBuildingObject"); + + const DBSchema::BuildingObjectBufferRow *row=m_buildingObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no BuildingObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedCellObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=6; + Archive::put(data,temp); + } + encodeSharedServerObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedCellObject"); + + const DBSchema::CellObjectBufferRow *row=m_cellObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no CellObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + bool temp; + row->is_public.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->cell_number.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeServerCellObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=13; + Archive::put(data,temp); + } + encodeServerServerObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerCellObject"); + + const DBSchema::CellObjectBufferRow *row=m_cellObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no CellObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + encodePropertyList(objectId,PropertyListBuffer::LI_Allowed,data); + encodePropertyList(objectId,PropertyListBuffer::LI_Banned,data); + return true; +} + +bool SwgSnapshot::encodeClientCellObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientServerObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientCellObject"); + + const DBSchema::CellObjectBufferRow *row=m_cellObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no CellObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedCityObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=4; + Archive::put(data,temp); + } + encodeSharedUniverseObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedCityObject"); + + const DBSchema::CityObjectBufferRow *row=m_cityObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no CityObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeServerCityObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=14; + Archive::put(data,temp); + } + encodeServerUniverseObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerCityObject"); + + const DBSchema::CityObjectBufferRow *row=m_cityObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no CityObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + encodePropertyList(objectId,PropertyListBuffer::LI_Cities,data); + encodePropertyList(objectId,PropertyListBuffer::LI_Citizens,data); + encodePropertyList(objectId,PropertyListBuffer::LI_CityStructures,data); + return true; +} + +bool SwgSnapshot::encodeClientCityObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientUniverseObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientCityObject"); + + const DBSchema::CityObjectBufferRow *row=m_cityObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no CityObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedCreatureObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=19; + Archive::put(data,temp); + } + encodeSharedTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedCreatureObject"); + + const DBSchema::CreatureObjectBufferRow *row=m_creatureObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no CreatureObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + Postures::Enumerator temp; + row->posture.getValue(temp); + Archive::put(data,temp); + } + { + uint8 temp; + row->rank.getValue(temp); + Archive::put(data,temp); + } + { + NetworkId temp; + row->master_id.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->scale_factor.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->shock_wounds.getValue(temp); + Archive::put(data,temp); + } + { + uint64 temp; + row->states.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeServerCreatureObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=23; + Archive::put(data,temp); + } + encodeServerTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerCreatureObject"); + + const DBSchema::CreatureObjectBufferRow *row=m_creatureObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no CreatureObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + encodeAttributes(objectId,data,0); + { + float temp; + row->base_run_speed.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->base_walk_speed.getValue(temp); + Archive::put(data,temp); + } + encodePersistedBuffs(data,row->persisted_buffs); + { + float temp; + row->ws_x.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->ws_y.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->ws_z.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeClientCreatureObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=4; + Archive::put(data,temp); + } + encodeClientTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientCreatureObject"); + + const DBSchema::CreatureObjectBufferRow *row=m_creatureObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no CreatureObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + encodeAttributes(objectId,data,9); + encodePropertyList(objectId,PropertyListBuffer::LI_Skills,data); + return true; +} + +bool SwgSnapshot::encodeSharedFactoryObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=13; + Archive::put(data,temp); + } + encodeSharedTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedFactoryObject"); + + const DBSchema::FactoryObjectBufferRow *row=m_factoryObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no FactoryObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeServerFactoryObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=16; + Archive::put(data,temp); + } + encodeServerTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerFactoryObject"); + + const DBSchema::FactoryObjectBufferRow *row=m_factoryObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no FactoryObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeClientFactoryObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientFactoryObject"); + + const DBSchema::FactoryObjectBufferRow *row=m_factoryObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no FactoryObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedGuildObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=5; + Archive::put(data,temp); + } + encodeSharedUniverseObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedGuildObject"); + + const DBSchema::GuildObjectBufferRow *row=m_guildObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no GuildObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + encodePropertyList(objectId,PropertyListBuffer::LI_GuildAbbrevs,data); + return true; +} + +bool SwgSnapshot::encodeServerGuildObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=15; + Archive::put(data,temp); + } + encodeServerUniverseObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerGuildObject"); + + const DBSchema::GuildObjectBufferRow *row=m_guildObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no GuildObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + encodePropertyList(objectId,PropertyListBuffer::LI_GuildNames,data); + encodePropertyList(objectId,PropertyListBuffer::LI_GuildLeaders,data); + encodePropertyList(objectId,PropertyListBuffer::LI_GuildMembers,data); + encodePropertyList(objectId,PropertyListBuffer::LI_GuildEnemies,data); + return true; +} + +bool SwgSnapshot::encodeClientGuildObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientUniverseObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientGuildObject"); + + const DBSchema::GuildObjectBufferRow *row=m_guildObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no GuildObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedHarvesterInstallationObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=16; + Archive::put(data,temp); + } + encodeSharedInstallationObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedHarvesterInstallationObject"); + + const DBSchema::HarvesterInstallationObjectBufferRow *row=m_harvesterInstallationObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no HarvesterInstallationObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeServerHarvesterInstallationObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=26; + Archive::put(data,temp); + } + encodeServerInstallationObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerHarvesterInstallationObject"); + + const DBSchema::HarvesterInstallationObjectBufferRow *row=m_harvesterInstallationObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no HarvesterInstallationObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + float temp; + row->installed_efficiency.getValue(temp); + Archive::put(data,temp); + } + { + NetworkId temp; + row->resource_type.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->max_extraction_rate.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->current_extraction_rate.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->max_hopper_amount.getValue(temp); + Archive::put(data,temp); + } + { + NetworkId temp; + row->hopper_resource.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->hopper_amount.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeClientHarvesterInstallationObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientInstallationObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientHarvesterInstallationObject"); + + const DBSchema::HarvesterInstallationObjectBufferRow *row=m_harvesterInstallationObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no HarvesterInstallationObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedInstallationObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=16; + Archive::put(data,temp); + } + encodeSharedTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedInstallationObject"); + + const DBSchema::InstallationObjectBufferRow *row=m_installationObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no InstallationObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + bool temp; + row->activated.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->power.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->power_rate.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeServerInstallationObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=19; + Archive::put(data,temp); + } + encodeServerTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerInstallationObject"); + + const DBSchema::InstallationObjectBufferRow *row=m_installationObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no InstallationObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + int32 temp; + row->installation_type.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->tick_count.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->activate_start_time.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeClientInstallationObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientInstallationObject"); + + const DBSchema::InstallationObjectBufferRow *row=m_installationObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no InstallationObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedIntangibleObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=5; + Archive::put(data,temp); + } + encodeSharedServerObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedIntangibleObject"); + + const DBSchema::IntangibleObjectBufferRow *row=m_intangibleObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no IntangibleObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + int temp; + row->count.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeServerIntangibleObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=11; + Archive::put(data,temp); + } + encodeServerServerObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerIntangibleObject"); + + const DBSchema::IntangibleObjectBufferRow *row=m_intangibleObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no IntangibleObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeClientIntangibleObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientServerObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientIntangibleObject"); + + const DBSchema::IntangibleObjectBufferRow *row=m_intangibleObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no IntangibleObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedManufactureInstallationObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=16; + Archive::put(data,temp); + } + encodeSharedInstallationObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedManufactureInstallationObject"); + + const DBSchema::ManufactureInstallationObjectBufferRow *row=m_manufactureInstallationObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no ManufactureInstallationObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeServerManufactureInstallationObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=19; + Archive::put(data,temp); + } + encodeServerInstallationObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerManufactureInstallationObject"); + + const DBSchema::ManufactureInstallationObjectBufferRow *row=m_manufactureInstallationObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no ManufactureInstallationObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeClientManufactureInstallationObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientInstallationObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientManufactureInstallationObject"); + + const DBSchema::ManufactureInstallationObjectBufferRow *row=m_manufactureInstallationObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no ManufactureInstallationObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedManufactureSchematicObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=8; + Archive::put(data,temp); + } + encodeSharedIntangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedManufactureSchematicObject"); + + const DBSchema::ManufactureSchematicObjectBufferRow *row=m_manufactureSchematicObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no ManufactureSchematicObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + encodeManufactureSchematicAttributes(objectId,data); + { + int temp; + row->items_per_container.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->manufacture_time.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeServerManufactureSchematicObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=14; + Archive::put(data,temp); + } + encodeServerIntangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerManufactureSchematicObject"); + + const DBSchema::ManufactureSchematicObjectBufferRow *row=m_manufactureSchematicObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no ManufactureSchematicObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + int temp; + row->draft_schematic.getValue(temp); + Archive::put(data,temp); + } + { + NetworkId temp; + row->creator_id.getValue(temp); + Archive::put(data,temp); + } + { + Unicode::String temp; + row->creator_name.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeClientManufactureSchematicObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientIntangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientManufactureSchematicObject"); + + const DBSchema::ManufactureSchematicObjectBufferRow *row=m_manufactureSchematicObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no ManufactureSchematicObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedMissionObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=17; + Archive::put(data,temp); + } + encodeSharedIntangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedMissionObject"); + + const DBSchema::MissionObjectBufferRow *row=m_missionObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no MissionObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + int temp; + row->difficulty.getValue(temp); + Archive::put(data,temp); + } + encodeLocation(data,row->end_x,row->end_y,row->end_z,row->end_cell,row->end_scene); + { + Unicode::String temp; + row->mission_creator.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->reward.getValue(temp); + Archive::put(data,temp); + } + encodeLocation(data,row->start_x,row->start_y,row->start_z,row->start_cell,row->start_scene); + { + uint32 temp; + row->target_appearance.getValue(temp); + Archive::put(data,temp); + } + encodeStringId(data,row->description_table,row->description_text); + encodeStringId(data,row->title_table,row->title_text); + { + int temp; + row->status.getValue(temp); + Archive::put(data,temp); + } + { + uint32 temp; + row->mission_type.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->target_name.getValue(temp); + Archive::put(data,temp); + } + encodeSingleWaypoint(objectId,data); + return true; +} + +bool SwgSnapshot::encodeServerMissionObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=13; + Archive::put(data,temp); + } + encodeServerIntangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerMissionObject"); + + const DBSchema::MissionObjectBufferRow *row=m_missionObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no MissionObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + std::string temp; + row->root_script_name.getValue(temp); + Archive::put(data,temp); + } + { + NetworkId temp; + row->mission_holder_id.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeClientMissionObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientIntangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientMissionObject"); + + const DBSchema::MissionObjectBufferRow *row=m_missionObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no MissionObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedPlanetObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=4; + Archive::put(data,temp); + } + encodeSharedUniverseObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedPlanetObject"); + + const DBSchema::PlanetObjectBufferRow *row=m_planetObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no PlanetObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeServerPlanetObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=12; + Archive::put(data,temp); + } + encodeServerUniverseObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerPlanetObject"); + + const DBSchema::PlanetObjectBufferRow *row=m_planetObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no PlanetObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + std::string temp; + row->planet_name.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeClientPlanetObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientUniverseObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientPlanetObject"); + + const DBSchema::PlanetObjectBufferRow *row=m_planetObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no PlanetObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedPlayerObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=20; + Archive::put(data,temp); + } + encodeSharedIntangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedPlayerObject"); + + const DBSchema::PlayerObjectBufferRow *row=m_playerObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no PlayerObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + encodeMatchMakingId(data,row->character_profile_id); + encodeMatchMakingId(data,row->personal_profile_id); + { + NullEncodedStandardString temp; + row->skill_title.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->born_date.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->played_time.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->role_icon_choice.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->skill_template.getValue(temp); + Archive::put(data,temp); + } + { + int32 temp; + row->current_gcw_points.getValue(temp); + Archive::put(data,temp); + } + { + int32 temp; + row->current_pvp_kills.getValue(temp); + Archive::put(data,temp); + } + { + int64 temp; + row->lifetime_gcw_points.getValue(temp); + Archive::put(data,temp); + } + { + int32 temp; + row->lifetime_pvp_kills.getValue(temp); + Archive::put(data,temp); + } + { + BitArray temp; + row->collections.getValue(temp); + Archive::put(data,temp); + } + { + BitArray temp; + row->collections2.getValue(temp); + Archive::put(data,temp); + } + { + bool temp; + row->show_backpack.getValue(temp); + Archive::put(data,temp); + } + { + bool temp; + row->show_helmet.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeServerPlayerObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=22; + Archive::put(data,temp); + } + encodeServerIntangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerPlayerObject"); + + const DBSchema::PlayerObjectBufferRow *row=m_playerObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no PlayerObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + StationId temp; + row->station_id.getValue(temp); + Archive::put(data,temp); + } + { + NetworkId temp; + row->house_id.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->account_num_lots.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->account_max_lots_adjustment.getValue(temp); + Archive::put(data,temp); + } + { + bool temp; + row->account_is_outcast.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->account_cheater_level.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->force_regen_rate.getValue(temp); + Archive::put(data,temp); + } + { + int32 temp; + row->current_gcw_rating.getValue(temp); + Archive::put(data,temp); + } + { + int32 temp; + row->max_gcw_imperial_rating.getValue(temp); + Archive::put(data,temp); + } + { + int32 temp; + row->max_gcw_rebel_rating.getValue(temp); + Archive::put(data,temp); + } + { + int32 temp; + row->next_gcw_rating_calc_time.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeClientPlayerObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientIntangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientPlayerObject"); + + const DBSchema::PlayerObjectBufferRow *row=m_playerObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no PlayerObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedPlayerQuestObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=42; + Archive::put(data,temp); + } + encodeSharedTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedPlayerQuestObject"); + + const DBSchema::PlayerQuestObjectBufferRow *row=m_playerQuestObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no PlayerQuestObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + std::string temp; + row->title.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->description.getValue(temp); + Archive::put(data,temp); + } + { + NetworkId temp; + row->creator.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->total_tasks.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->difficulty.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_title1.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_description1.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_title2.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_description2.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_title3.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_description3.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_title4.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_description4.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_title5.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_description5.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_title6.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_description6.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_title7.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_description7.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_title8.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_description8.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_title9.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_description9.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_title10.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_description10.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_title11.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_description11.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_title12.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->task_description12.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeServerPlayerQuestObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=16; + Archive::put(data,temp); + } + encodeServerTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerPlayerQuestObject"); + + const DBSchema::PlayerQuestObjectBufferRow *row=m_playerQuestObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no PlayerQuestObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeClientPlayerQuestObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientPlayerQuestObject"); + + const DBSchema::PlayerQuestObjectBufferRow *row=m_playerQuestObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no PlayerQuestObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedResourceContainerObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=15; + Archive::put(data,temp); + } + encodeSharedTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedResourceContainerObject"); + + const DBSchema::ResourceContainerObjectBufferRow *row=m_resourceContainerObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no ResourceContainerObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + int temp; + row->quantity.getValue(temp); + Archive::put(data,temp); + } + { + NetworkId temp; + row->resource_type.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeServerResourceContainerObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=17; + Archive::put(data,temp); + } + encodeServerTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerResourceContainerObject"); + + const DBSchema::ResourceContainerObjectBufferRow *row=m_resourceContainerObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no ResourceContainerObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + NetworkId temp; + row->source.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeClientResourceContainerObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientResourceContainerObject"); + + const DBSchema::ResourceContainerObjectBufferRow *row=m_resourceContainerObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no ResourceContainerObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedServerObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=4; + Archive::put(data,temp); + } + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedServerObject"); + + const DBSchema::ObjectBufferRow *row=m_objectTableBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no ObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + float temp; + row->complexity.getValue(temp); + Archive::put(data,temp); + } + encodeStringId(data,row->name_string_table,row->name_string_text); + { + NullEncodedUnicodeString temp; + row->object_name.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->volume.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeServerServerObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=11; + Archive::put(data,temp); + } + PROFILER_AUTO_BLOCK_DEFINE("encodeServerServerObject"); + + const DBSchema::ObjectBufferRow *row=m_objectTableBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no ObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + int temp; + row->cache_version.getValue(temp); + Archive::put(data,temp); + } + { + bool temp; + row->load_contents.getValue(temp); + Archive::put(data,temp); + } + encodeObjVarFreeFlags(objectId,data); + encodeObjVars(objectId,data); + Archive::put(data,true); + { + bool temp; + row->player_controlled.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->scene_id.getValue(temp); + Archive::put(data,temp); + } + encodeScriptObject(objectId,data); + { + int temp; + row->conversion_id.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->static_item_name.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->static_item_version.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeClientServerObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + PROFILER_AUTO_BLOCK_DEFINE("encodeClientServerObject"); + + const DBSchema::ObjectBufferRow *row=m_objectTableBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no ObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + int temp; + row->bank_balance.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->cash_balance.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeSharedShipObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=24; + Archive::put(data,temp); + } + encodeSharedTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedShipObject"); + + const DBSchema::ShipObjectBufferRow *row=m_shipObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no ShipObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + float temp; + row->slide_dampener.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->current_chassis_hit_points.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->maximum_chassis_hit_points.getValue(temp); + Archive::put(data,temp); + } + { + uint32 temp; + row->chassis_type.getValue(temp); + Archive::put(data,temp); + } + { + std::string packedValue; + row->cmp_armor_hp_maximum.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + std::string packedValue; + row->cmp_armor_hp_current.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + std::string packedValue; + row->cmp_hp_current.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + std::string packedValue; + row->cmp_hp_maximum.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + std::string packedValue; + row->cmp_flags.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + float temp; + row->shield_hp_front_maximum.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->shield_hp_back_maximum.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeServerShipObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=17; + Archive::put(data,temp); + } + encodeServerTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerShipObject"); + + const DBSchema::ShipObjectBufferRow *row=m_shipObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no ShipObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + std::string packedValue; + row->cmp_crc.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + return true; +} + +bool SwgSnapshot::encodeClientShipObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=41; + Archive::put(data,temp); + } + encodeClientTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientShipObject"); + + const DBSchema::ShipObjectBufferRow *row=m_shipObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no ShipObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + std::string packedValue; + row->cmp_efficiency_general.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + std::string packedValue; + row->cmp_efficiency_eng.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + std::string packedValue; + row->cmp_eng_maintenance.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + std::string packedValue; + row->cmp_mass.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + std::string packedValue; + row->cmp_names.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + std::string packedValue; + row->cmp_creators.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + std::string packedValue; + row->weapon_damage_maximum.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + std::string packedValue; + row->weapon_damage_minimum.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + std::string packedValue; + row->weapon_effectiveness_shields.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + std::string packedValue; + row->weapon_effectiveness_armor.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + std::string packedValue; + row->weapon_eng_per_shot.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + std::string packedValue; + row->weapon_refire_rate.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + std::string packedValue; + row->weapon_ammo_current.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + std::string packedValue; + row->weapon_ammo_maximum.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + std::string packedValue; + row->weapon_ammo_type.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + { + float temp; + row->chassis_cmp_mass_maximum.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->shield_recharge_rate.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->capacitor_eng_maximum.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->capacitor_eng_recharge_rate.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->engine_acc_rate.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->engine_deceleration_rate.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->engine_pitch_acc_rate.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->engine_yaw_acc_rate.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->engine_roll_acc_rate.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->engine_pitch_rate_maximum.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->engine_yaw_rate_maximum.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->engine_roll_rate_maximum.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->engine_speed_maximum.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->reactor_eng_generation_rate.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->booster_eng_maximum.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->booster_eng_recharge_rate.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->booster_eng_consumption_rate.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->booster_acc.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->booster_speed_maximum.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->droid_if_cmd_speed.getValue(temp); + Archive::put(data,temp); + } + { + NetworkId temp; + row->installed_dcd.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->cargo_hold_contents_maximum.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->cargo_hold_contents_current.getValue(temp); + Archive::put(data,temp); + } + { + std::string packedValue; + row->cargo_hold_contents.getValue(packedValue); + Archive::AutoDeltaPackedMap::pack(data, packedValue); + } + return true; +} + +bool SwgSnapshot::encodeSharedStaticObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=4; + Archive::put(data,temp); + } + encodeSharedServerObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedStaticObject"); + + const DBSchema::StaticObjectBufferRow *row=m_staticObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no StaticObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeServerStaticObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=11; + Archive::put(data,temp); + } + encodeServerServerObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerStaticObject"); + + const DBSchema::StaticObjectBufferRow *row=m_staticObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no StaticObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeClientStaticObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientServerObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientStaticObject"); + + const DBSchema::StaticObjectBufferRow *row=m_staticObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no StaticObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedTangibleObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=13; + Archive::put(data,temp); + } + encodeSharedServerObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedTangibleObject"); + + const DBSchema::TangibleObjectBufferRow *row=m_tangibleObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no TangibleObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + uint32 temp; + row->pvp_faction.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->pvp_type.getValue(temp); + Archive::put(data,temp); + } + { + std::string temp; + row->appearance_data.getValue(temp); + Archive::put(data,temp); + } + encodeComponents(objectId,data); + { + int temp; + row->condition.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->count.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->damage_taken.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->max_hit_points.getValue(temp); + Archive::put(data,temp); + } + { + bool temp; + row->visible.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeServerTangibleObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=16; + Archive::put(data,temp); + } + encodeServerServerObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerTangibleObject"); + + const DBSchema::TangibleObjectBufferRow *row=m_tangibleObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no TangibleObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + std::string temp; + row->custom_appearance.getValue(temp); + Archive::put(data,temp); + } + encodeLocationDataList(objectId,1,data); + { + NetworkId temp; + row->owner_id.getValue(temp); + Archive::put(data,temp); + } + { + NetworkId temp; + row->creator_id.getValue(temp); + Archive::put(data,temp); + } + { + uint32 temp; + row->source_draft_schematic.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeClientTangibleObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientServerObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientTangibleObject"); + + const DBSchema::TangibleObjectBufferRow *row=m_tangibleObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no TangibleObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedUniverseObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=4; + Archive::put(data,temp); + } + encodeSharedServerObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedUniverseObject"); + + const DBSchema::UniverseObjectBufferRow *row=m_universeObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no UniverseObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeServerUniverseObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=11; + Archive::put(data,temp); + } + encodeServerServerObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerUniverseObject"); + + const DBSchema::UniverseObjectBufferRow *row=m_universeObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no UniverseObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeClientUniverseObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientServerObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientUniverseObject"); + + const DBSchema::UniverseObjectBufferRow *row=m_universeObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no UniverseObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedVehicleObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=13; + Archive::put(data,temp); + } + encodeSharedTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedVehicleObject"); + + const DBSchema::VehicleObjectBufferRow *row=m_vehicleObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no VehicleObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeServerVehicleObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=17; + Archive::put(data,temp); + } + encodeServerTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerVehicleObject"); + + const DBSchema::VehicleObjectBufferRow *row=m_vehicleObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no VehicleObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + int temp; + row->bogus.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeClientVehicleObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientVehicleObject"); + + const DBSchema::VehicleObjectBufferRow *row=m_vehicleObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no VehicleObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeSharedWeaponObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=20; + Archive::put(data,temp); + } + encodeSharedTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeSharedWeaponObject"); + + const DBSchema::WeaponObjectBufferRow *row=m_weaponObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no WeaponObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + float temp; + row->attack_speed.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->accuracy.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->min_range.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->max_range.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->damage_type.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->elemental_type.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->elemental_value.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeServerWeaponObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=21; + Archive::put(data,temp); + } + encodeServerTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeServerWeaponObject"); + + const DBSchema::WeaponObjectBufferRow *row=m_weaponObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no WeaponObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + { + int temp; + row->min_damage.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->max_damage.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->wound_chance.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->attack_cost.getValue(temp); + Archive::put(data,temp); + } + { + float temp; + row->damage_radius.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeClientWeaponObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=2; + Archive::put(data,temp); + } + encodeClientTangibleObject(objectId, data, false); + + PROFILER_AUTO_BLOCK_DEFINE("encodeClientWeaponObject"); + + const DBSchema::WeaponObjectBufferRow *row=m_weaponObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no WeaponObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + return true; +} + +bool SwgSnapshot::encodeParentClientPlayerObject(NetworkId const & objectId, Archive::ByteStream &data, bool addCount) const +{ + if (addCount) + { + uint16 temp=9; + Archive::put(data,temp); + } + PROFILER_AUTO_BLOCK_DEFINE("encodeParentClientPlayerObject"); + + const DBSchema::PlayerObjectBufferRow *row=m_playerObjectBuffer.findConstRowByIndex(objectId); + WARNING_STRICT_FATAL(row==NULL,("Loading object %s, no PlayerObjectBufferRow in the buffer\n",objectId.getValueString().c_str())); + if (!row) + return false; + + encodeExperience(objectId,data); + encodeWaypoints(objectId,data); + { + int temp; + row->force_power.getValue(temp); + Archive::put(data,temp); + } + { + int temp; + row->max_force_power.getValue(temp); + Archive::put(data,temp); + } + { + BitArray temp; + row->completed_quests.getValue(temp); + Archive::put(data,temp); + } + { + BitArray temp; + row->active_quests.getValue(temp); + Archive::put(data,temp); + } + { + uint32 temp; + row->current_quest.getValue(temp); + Archive::put(data,temp); + } + encodeQuests(data,row->quests,row->quests2,row->quests3,row->quests4); + { + std::string temp; + row->working_skill.getValue(temp); + Archive::put(data,temp); + } + return true; +} + +bool SwgSnapshot::encodeSharedData(NetworkId const & objectId, Tag typeId, std::vector &baselines) const +{ + Archive::ByteStream bs; + switch (typeId) + { + case ServerBattlefieldMarkerObjectTemplate::ServerBattlefieldMarkerObjectTemplate_tag: + if (!encodeSharedBattlefieldMarkerObject(objectId, bs)) return false; + break; + case ServerBuildingObjectTemplate::ServerBuildingObjectTemplate_tag: + if (!encodeSharedBuildingObject(objectId, bs)) return false; + break; + case ServerCellObjectTemplate::ServerCellObjectTemplate_tag: + if (!encodeSharedCellObject(objectId, bs)) return false; + break; + case ServerCityObjectTemplate::ServerCityObjectTemplate_tag: + if (!encodeSharedCityObject(objectId, bs)) return false; + break; + case ServerCreatureObjectTemplate::ServerCreatureObjectTemplate_tag: + if (!encodeSharedCreatureObject(objectId, bs)) return false; + break; + case ServerFactoryObjectTemplate::ServerFactoryObjectTemplate_tag: + if (!encodeSharedFactoryObject(objectId, bs)) return false; + break; + case ServerGuildObjectTemplate::ServerGuildObjectTemplate_tag: + if (!encodeSharedGuildObject(objectId, bs)) return false; + break; + case ServerHarvesterInstallationObjectTemplate::ServerHarvesterInstallationObjectTemplate_tag: + if (!encodeSharedHarvesterInstallationObject(objectId, bs)) return false; + break; + case ServerInstallationObjectTemplate::ServerInstallationObjectTemplate_tag: + if (!encodeSharedInstallationObject(objectId, bs)) return false; + break; + case ServerIntangibleObjectTemplate::ServerIntangibleObjectTemplate_tag: + if (!encodeSharedIntangibleObject(objectId, bs)) return false; + break; + case ServerManufactureInstallationObjectTemplate::ServerManufactureInstallationObjectTemplate_tag: + if (!encodeSharedManufactureInstallationObject(objectId, bs)) return false; + break; + case ServerManufactureSchematicObjectTemplate::ServerManufactureSchematicObjectTemplate_tag: + if (!encodeSharedManufactureSchematicObject(objectId, bs)) return false; + break; + case ServerMissionObjectTemplate::ServerMissionObjectTemplate_tag: + if (!encodeSharedMissionObject(objectId, bs)) return false; + break; + case ServerPlanetObjectTemplate::ServerPlanetObjectTemplate_tag: + if (!encodeSharedPlanetObject(objectId, bs)) return false; + break; + case ServerPlayerObjectTemplate::ServerPlayerObjectTemplate_tag: + if (!encodeSharedPlayerObject(objectId, bs)) return false; + break; + case ServerPlayerQuestObjectTemplate::ServerPlayerQuestObjectTemplate_tag: + if (!encodeSharedPlayerQuestObject(objectId, bs)) return false; + break; + case ServerResourceContainerObjectTemplate::ServerResourceContainerObjectTemplate_tag: + if (!encodeSharedResourceContainerObject(objectId, bs)) return false; + break; + case ServerObjectTemplate::ServerObjectTemplate_tag: + if (!encodeSharedServerObject(objectId, bs)) return false; + break; + case ServerShipObjectTemplate::ServerShipObjectTemplate_tag: + if (!encodeSharedShipObject(objectId, bs)) return false; + break; + case ServerStaticObjectTemplate::ServerStaticObjectTemplate_tag: + if (!encodeSharedStaticObject(objectId, bs)) return false; + break; + case ServerTangibleObjectTemplate::ServerTangibleObjectTemplate_tag: + if (!encodeSharedTangibleObject(objectId, bs)) return false; + break; + case ServerUniverseObjectTemplate::ServerUniverseObjectTemplate_tag: + if (!encodeSharedUniverseObject(objectId, bs)) return false; + break; + case ServerVehicleObjectTemplate::ServerVehicleObjectTemplate_tag: + if (!encodeSharedVehicleObject(objectId, bs)) return false; + break; + case ServerWeaponObjectTemplate::ServerWeaponObjectTemplate_tag: + if (!encodeSharedWeaponObject(objectId, bs)) return false; + break; + } + + // test for 0-length message + if (bs.getSize() == 0) + return true; + + { + PROFILER_AUTO_BLOCK_DEFINE("new BaselinesMessage"); + baselines.push_back(BatchBaselinesMessageData(objectId,typeId,BaselinesMessage::BASELINES_SHARED,bs)); + } + return true; +} + +bool SwgSnapshot::encodeServerData(NetworkId const & objectId, Tag typeId, std::vector &baselines) const +{ + Archive::ByteStream bs; + switch (typeId) + { + case ServerBattlefieldMarkerObjectTemplate::ServerBattlefieldMarkerObjectTemplate_tag: + if (!encodeServerBattlefieldMarkerObject(objectId, bs)) return false; + break; + case ServerBuildingObjectTemplate::ServerBuildingObjectTemplate_tag: + if (!encodeServerBuildingObject(objectId, bs)) return false; + break; + case ServerCellObjectTemplate::ServerCellObjectTemplate_tag: + if (!encodeServerCellObject(objectId, bs)) return false; + break; + case ServerCityObjectTemplate::ServerCityObjectTemplate_tag: + if (!encodeServerCityObject(objectId, bs)) return false; + break; + case ServerCreatureObjectTemplate::ServerCreatureObjectTemplate_tag: + if (!encodeServerCreatureObject(objectId, bs)) return false; + break; + case ServerFactoryObjectTemplate::ServerFactoryObjectTemplate_tag: + if (!encodeServerFactoryObject(objectId, bs)) return false; + break; + case ServerGuildObjectTemplate::ServerGuildObjectTemplate_tag: + if (!encodeServerGuildObject(objectId, bs)) return false; + break; + case ServerHarvesterInstallationObjectTemplate::ServerHarvesterInstallationObjectTemplate_tag: + if (!encodeServerHarvesterInstallationObject(objectId, bs)) return false; + break; + case ServerInstallationObjectTemplate::ServerInstallationObjectTemplate_tag: + if (!encodeServerInstallationObject(objectId, bs)) return false; + break; + case ServerIntangibleObjectTemplate::ServerIntangibleObjectTemplate_tag: + if (!encodeServerIntangibleObject(objectId, bs)) return false; + break; + case ServerManufactureInstallationObjectTemplate::ServerManufactureInstallationObjectTemplate_tag: + if (!encodeServerManufactureInstallationObject(objectId, bs)) return false; + break; + case ServerManufactureSchematicObjectTemplate::ServerManufactureSchematicObjectTemplate_tag: + if (!encodeServerManufactureSchematicObject(objectId, bs)) return false; + break; + case ServerMissionObjectTemplate::ServerMissionObjectTemplate_tag: + if (!encodeServerMissionObject(objectId, bs)) return false; + break; + case ServerPlanetObjectTemplate::ServerPlanetObjectTemplate_tag: + if (!encodeServerPlanetObject(objectId, bs)) return false; + break; + case ServerPlayerObjectTemplate::ServerPlayerObjectTemplate_tag: + if (!encodeServerPlayerObject(objectId, bs)) return false; + break; + case ServerPlayerQuestObjectTemplate::ServerPlayerQuestObjectTemplate_tag: + if (!encodeServerPlayerQuestObject(objectId, bs)) return false; + break; + case ServerResourceContainerObjectTemplate::ServerResourceContainerObjectTemplate_tag: + if (!encodeServerResourceContainerObject(objectId, bs)) return false; + break; + case ServerObjectTemplate::ServerObjectTemplate_tag: + if (!encodeServerServerObject(objectId, bs)) return false; + break; + case ServerShipObjectTemplate::ServerShipObjectTemplate_tag: + if (!encodeServerShipObject(objectId, bs)) return false; + break; + case ServerStaticObjectTemplate::ServerStaticObjectTemplate_tag: + if (!encodeServerStaticObject(objectId, bs)) return false; + break; + case ServerTangibleObjectTemplate::ServerTangibleObjectTemplate_tag: + if (!encodeServerTangibleObject(objectId, bs)) return false; + break; + case ServerUniverseObjectTemplate::ServerUniverseObjectTemplate_tag: + if (!encodeServerUniverseObject(objectId, bs)) return false; + break; + case ServerVehicleObjectTemplate::ServerVehicleObjectTemplate_tag: + if (!encodeServerVehicleObject(objectId, bs)) return false; + break; + case ServerWeaponObjectTemplate::ServerWeaponObjectTemplate_tag: + if (!encodeServerWeaponObject(objectId, bs)) return false; + break; + } + + // test for 0-length message + if (bs.getSize() == 0) + return true; + + { + PROFILER_AUTO_BLOCK_DEFINE("new BaselinesMessage"); + baselines.push_back(BatchBaselinesMessageData(objectId,typeId,BaselinesMessage::BASELINES_SERVER,bs)); + } + return true; +} + +bool SwgSnapshot::encodeClientData(NetworkId const & objectId, Tag typeId, std::vector &baselines) const +{ + Archive::ByteStream bs; + switch (typeId) + { + case ServerBattlefieldMarkerObjectTemplate::ServerBattlefieldMarkerObjectTemplate_tag: + if (!encodeClientBattlefieldMarkerObject(objectId, bs)) return false; + break; + case ServerBuildingObjectTemplate::ServerBuildingObjectTemplate_tag: + if (!encodeClientBuildingObject(objectId, bs)) return false; + break; + case ServerCellObjectTemplate::ServerCellObjectTemplate_tag: + if (!encodeClientCellObject(objectId, bs)) return false; + break; + case ServerCityObjectTemplate::ServerCityObjectTemplate_tag: + if (!encodeClientCityObject(objectId, bs)) return false; + break; + case ServerCreatureObjectTemplate::ServerCreatureObjectTemplate_tag: + if (!encodeClientCreatureObject(objectId, bs)) return false; + break; + case ServerFactoryObjectTemplate::ServerFactoryObjectTemplate_tag: + if (!encodeClientFactoryObject(objectId, bs)) return false; + break; + case ServerGuildObjectTemplate::ServerGuildObjectTemplate_tag: + if (!encodeClientGuildObject(objectId, bs)) return false; + break; + case ServerHarvesterInstallationObjectTemplate::ServerHarvesterInstallationObjectTemplate_tag: + if (!encodeClientHarvesterInstallationObject(objectId, bs)) return false; + break; + case ServerInstallationObjectTemplate::ServerInstallationObjectTemplate_tag: + if (!encodeClientInstallationObject(objectId, bs)) return false; + break; + case ServerIntangibleObjectTemplate::ServerIntangibleObjectTemplate_tag: + if (!encodeClientIntangibleObject(objectId, bs)) return false; + break; + case ServerManufactureInstallationObjectTemplate::ServerManufactureInstallationObjectTemplate_tag: + if (!encodeClientManufactureInstallationObject(objectId, bs)) return false; + break; + case ServerManufactureSchematicObjectTemplate::ServerManufactureSchematicObjectTemplate_tag: + if (!encodeClientManufactureSchematicObject(objectId, bs)) return false; + break; + case ServerMissionObjectTemplate::ServerMissionObjectTemplate_tag: + if (!encodeClientMissionObject(objectId, bs)) return false; + break; + case ServerPlanetObjectTemplate::ServerPlanetObjectTemplate_tag: + if (!encodeClientPlanetObject(objectId, bs)) return false; + break; + case ServerPlayerObjectTemplate::ServerPlayerObjectTemplate_tag: + if (!encodeClientPlayerObject(objectId, bs)) return false; + break; + case ServerPlayerQuestObjectTemplate::ServerPlayerQuestObjectTemplate_tag: + if (!encodeClientPlayerQuestObject(objectId, bs)) return false; + break; + case ServerResourceContainerObjectTemplate::ServerResourceContainerObjectTemplate_tag: + if (!encodeClientResourceContainerObject(objectId, bs)) return false; + break; + case ServerObjectTemplate::ServerObjectTemplate_tag: + if (!encodeClientServerObject(objectId, bs)) return false; + break; + case ServerShipObjectTemplate::ServerShipObjectTemplate_tag: + if (!encodeClientShipObject(objectId, bs)) return false; + break; + case ServerStaticObjectTemplate::ServerStaticObjectTemplate_tag: + if (!encodeClientStaticObject(objectId, bs)) return false; + break; + case ServerTangibleObjectTemplate::ServerTangibleObjectTemplate_tag: + if (!encodeClientTangibleObject(objectId, bs)) return false; + break; + case ServerUniverseObjectTemplate::ServerUniverseObjectTemplate_tag: + if (!encodeClientUniverseObject(objectId, bs)) return false; + break; + case ServerVehicleObjectTemplate::ServerVehicleObjectTemplate_tag: + if (!encodeClientVehicleObject(objectId, bs)) return false; + break; + case ServerWeaponObjectTemplate::ServerWeaponObjectTemplate_tag: + if (!encodeClientWeaponObject(objectId, bs)) return false; + break; + } + + // test for 0-length message + if (bs.getSize() == 0) + return true; + + { + PROFILER_AUTO_BLOCK_DEFINE("new BaselinesMessage"); + baselines.push_back(BatchBaselinesMessageData(objectId,typeId,BaselinesMessage::BASELINES_CLIENT_SERVER,bs)); + } + return true; +} + +bool SwgSnapshot::encodeParentClientData(NetworkId const & objectId, Tag typeId, std::vector &baselines) const +{ + Archive::ByteStream bs; + switch (typeId) + { + case ServerPlayerObjectTemplate::ServerPlayerObjectTemplate_tag: + if (!encodeParentClientPlayerObject(objectId, bs)) return false; + break; + } + + // test for 0-length message + if (bs.getSize() == 0) + return true; + + { + PROFILER_AUTO_BLOCK_DEFINE("new BaselinesMessage"); + baselines.push_back(BatchBaselinesMessageData(objectId,typeId,BaselinesMessage::BASELINES_FIRST_PARENT_CLIENT_SERVER,bs)); + } + return true; +} + //!!!END GENERATED ENCODER diff --git a/game/server/application/SwgDatabaseServer/src/shared/generated/LoadObject_cpp.template b/game/server/application/SwgDatabaseServer/src/shared/generated/LoadObject_cpp.template index 1a0e94ac..1eb77a63 100644 --- a/game/server/application/SwgDatabaseServer/src/shared/generated/LoadObject_cpp.template +++ b/game/server/application/SwgDatabaseServer/src/shared/generated/LoadObject_cpp.template @@ -28,4 +28,546 @@ //!!!BEGIN GENERATED LOADOBJECT +void SwgSnapshot::loadBattlefieldMarkerObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_battlefieldMarkerObjectBuffer.addEmptyRow(objectId); + loadTangibleObject(session,objectId); +} + +void SwgSnapshot::newBattlefieldMarkerObject(NetworkId const & objectId) +{ + m_battlefieldMarkerObjectBuffer.addEmptyRow(objectId); + newTangibleObject(objectId); +} + +void SwgSnapshot::loadBuildingObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_buildingObjectBuffer.addEmptyRow(objectId); + loadTangibleObject(session,objectId); +} + +void SwgSnapshot::newBuildingObject(NetworkId const & objectId) +{ + m_buildingObjectBuffer.addEmptyRow(objectId); + newTangibleObject(objectId); +} + +void SwgSnapshot::loadCellObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_cellObjectBuffer.addEmptyRow(objectId); +} + +void SwgSnapshot::newCellObject(NetworkId const & objectId) +{ + m_cellObjectBuffer.addEmptyRow(objectId); +} + +void SwgSnapshot::loadCityObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_cityObjectBuffer.addEmptyRow(objectId); + loadUniverseObject(session,objectId); +} + +void SwgSnapshot::newCityObject(NetworkId const & objectId) +{ + m_cityObjectBuffer.addEmptyRow(objectId); + newUniverseObject(objectId); +} + +void SwgSnapshot::loadCreatureObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_creatureObjectBuffer.addEmptyRow(objectId); + loadAttributes(session,objectId); + loadSkills(session,objectId); + loadCommands(session,objectId); + loadTangibleObject(session,objectId); +} + +void SwgSnapshot::newCreatureObject(NetworkId const & objectId) +{ + m_creatureObjectBuffer.addEmptyRow(objectId); + newTangibleObject(objectId); +} + +void SwgSnapshot::loadFactoryObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_factoryObjectBuffer.addEmptyRow(objectId); + loadTangibleObject(session,objectId); +} + +void SwgSnapshot::newFactoryObject(NetworkId const & objectId) +{ + m_factoryObjectBuffer.addEmptyRow(objectId); + newTangibleObject(objectId); +} + +void SwgSnapshot::loadGuildObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_guildObjectBuffer.addEmptyRow(objectId); + loadUniverseObject(session,objectId); +} + +void SwgSnapshot::newGuildObject(NetworkId const & objectId) +{ + m_guildObjectBuffer.addEmptyRow(objectId); + newUniverseObject(objectId); +} + +void SwgSnapshot::loadHarvesterInstallationObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_harvesterInstallationObjectBuffer.addEmptyRow(objectId); + loadInstallationObject(session,objectId); +} + +void SwgSnapshot::newHarvesterInstallationObject(NetworkId const & objectId) +{ + m_harvesterInstallationObjectBuffer.addEmptyRow(objectId); + newInstallationObject(objectId); +} + +void SwgSnapshot::loadInstallationObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_installationObjectBuffer.addEmptyRow(objectId); + loadTangibleObject(session,objectId); +} + +void SwgSnapshot::newInstallationObject(NetworkId const & objectId) +{ + m_installationObjectBuffer.addEmptyRow(objectId); + newTangibleObject(objectId); +} + +void SwgSnapshot::loadIntangibleObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_intangibleObjectBuffer.addEmptyRow(objectId); +} + +void SwgSnapshot::newIntangibleObject(NetworkId const & objectId) +{ + m_intangibleObjectBuffer.addEmptyRow(objectId); +} + +void SwgSnapshot::loadManufactureInstallationObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_manufactureInstallationObjectBuffer.addEmptyRow(objectId); + loadInstallationObject(session,objectId); +} + +void SwgSnapshot::newManufactureInstallationObject(NetworkId const & objectId) +{ + m_manufactureInstallationObjectBuffer.addEmptyRow(objectId); + newInstallationObject(objectId); +} + +void SwgSnapshot::loadManufactureSchematicObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_manufactureSchematicObjectBuffer.addEmptyRow(objectId); + loadIntangibleObject(session,objectId); +} + +void SwgSnapshot::newManufactureSchematicObject(NetworkId const & objectId) +{ + m_manufactureSchematicObjectBuffer.addEmptyRow(objectId); + newIntangibleObject(objectId); +} + +void SwgSnapshot::loadMissionObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_missionObjectBuffer.addEmptyRow(objectId); + loadIntangibleObject(session,objectId); +} + +void SwgSnapshot::newMissionObject(NetworkId const & objectId) +{ + m_missionObjectBuffer.addEmptyRow(objectId); + newIntangibleObject(objectId); +} + +void SwgSnapshot::loadPlanetObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_planetObjectBuffer.addEmptyRow(objectId); + loadUniverseObject(session,objectId); +} + +void SwgSnapshot::newPlanetObject(NetworkId const & objectId) +{ + m_planetObjectBuffer.addEmptyRow(objectId); + newUniverseObject(objectId); +} + +void SwgSnapshot::loadPlayerObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_playerObjectBuffer.addEmptyRow(objectId); + loadIntangibleObject(session,objectId); +} + +void SwgSnapshot::newPlayerObject(NetworkId const & objectId) +{ + m_playerObjectBuffer.addEmptyRow(objectId); + newIntangibleObject(objectId); +} + +void SwgSnapshot::loadPlayerQuestObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_playerQuestObjectBuffer.addEmptyRow(objectId); + loadTangibleObject(session,objectId); +} + +void SwgSnapshot::newPlayerQuestObject(NetworkId const & objectId) +{ + m_playerQuestObjectBuffer.addEmptyRow(objectId); + newTangibleObject(objectId); +} + +void SwgSnapshot::loadResourceContainerObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_resourceContainerObjectBuffer.addEmptyRow(objectId); + loadTangibleObject(session,objectId); +} + +void SwgSnapshot::newResourceContainerObject(NetworkId const & objectId) +{ + m_resourceContainerObjectBuffer.addEmptyRow(objectId); + newTangibleObject(objectId); +} + +void SwgSnapshot::loadShipObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_shipObjectBuffer.addEmptyRow(objectId); + loadTangibleObject(session,objectId); +} + +void SwgSnapshot::newShipObject(NetworkId const & objectId) +{ + m_shipObjectBuffer.addEmptyRow(objectId); + newTangibleObject(objectId); +} + +void SwgSnapshot::loadStaticObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_staticObjectBuffer.addEmptyRow(objectId); +} + +void SwgSnapshot::newStaticObject(NetworkId const & objectId) +{ + m_staticObjectBuffer.addEmptyRow(objectId); +} + +void SwgSnapshot::loadTangibleObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_tangibleObjectBuffer.addEmptyRow(objectId); +} + +void SwgSnapshot::newTangibleObject(NetworkId const & objectId) +{ + m_tangibleObjectBuffer.addEmptyRow(objectId); +} + +void SwgSnapshot::loadUniverseObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_universeObjectBuffer.addEmptyRow(objectId); +} + +void SwgSnapshot::newUniverseObject(NetworkId const & objectId) +{ + m_universeObjectBuffer.addEmptyRow(objectId); +} + +void SwgSnapshot::loadVehicleObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_vehicleObjectBuffer.addEmptyRow(objectId); + loadTangibleObject(session,objectId); +} + +void SwgSnapshot::newVehicleObject(NetworkId const & objectId) +{ + m_vehicleObjectBuffer.addEmptyRow(objectId); + newTangibleObject(objectId); +} + +void SwgSnapshot::loadWeaponObject(DB::Session *session, NetworkId const & objectId) +{ + UNREF(session); + m_weaponObjectBuffer.addEmptyRow(objectId); + loadTangibleObject(session,objectId); +} + +void SwgSnapshot::newWeaponObject(NetworkId const & objectId) +{ + m_weaponObjectBuffer.addEmptyRow(objectId); + newTangibleObject(objectId); +} + +void SwgSnapshot::loadObject(DB::Session *session,const Tag &typeId, const NetworkId &objectId) +{ + switch(typeId) + { + case ServerBattlefieldMarkerObjectTemplate::ServerBattlefieldMarkerObjectTemplate_tag: + loadBattlefieldMarkerObject(session,objectId); + break; + + case ServerBuildingObjectTemplate::ServerBuildingObjectTemplate_tag: + loadBuildingObject(session,objectId); + break; + + case ServerCellObjectTemplate::ServerCellObjectTemplate_tag: + loadCellObject(session,objectId); + break; + + case ServerCityObjectTemplate::ServerCityObjectTemplate_tag: + loadCityObject(session,objectId); + break; + + case ServerCreatureObjectTemplate::ServerCreatureObjectTemplate_tag: + loadCreatureObject(session,objectId); + break; + + case ServerFactoryObjectTemplate::ServerFactoryObjectTemplate_tag: + loadFactoryObject(session,objectId); + break; + + case ServerGuildObjectTemplate::ServerGuildObjectTemplate_tag: + loadGuildObject(session,objectId); + break; + + case ServerHarvesterInstallationObjectTemplate::ServerHarvesterInstallationObjectTemplate_tag: + loadHarvesterInstallationObject(session,objectId); + break; + + case ServerInstallationObjectTemplate::ServerInstallationObjectTemplate_tag: + loadInstallationObject(session,objectId); + break; + + case ServerIntangibleObjectTemplate::ServerIntangibleObjectTemplate_tag: + loadIntangibleObject(session,objectId); + break; + + case ServerManufactureInstallationObjectTemplate::ServerManufactureInstallationObjectTemplate_tag: + loadManufactureInstallationObject(session,objectId); + break; + + case ServerManufactureSchematicObjectTemplate::ServerManufactureSchematicObjectTemplate_tag: + loadManufactureSchematicObject(session,objectId); + break; + + case ServerMissionObjectTemplate::ServerMissionObjectTemplate_tag: + loadMissionObject(session,objectId); + break; + + case ServerPlanetObjectTemplate::ServerPlanetObjectTemplate_tag: + loadPlanetObject(session,objectId); + break; + + case ServerPlayerObjectTemplate::ServerPlayerObjectTemplate_tag: + loadPlayerObject(session,objectId); + break; + + case ServerPlayerQuestObjectTemplate::ServerPlayerQuestObjectTemplate_tag: + loadPlayerQuestObject(session,objectId); + break; + + case ServerResourceContainerObjectTemplate::ServerResourceContainerObjectTemplate_tag: + loadResourceContainerObject(session,objectId); + break; + + case ServerShipObjectTemplate::ServerShipObjectTemplate_tag: + loadShipObject(session,objectId); + break; + + case ServerStaticObjectTemplate::ServerStaticObjectTemplate_tag: + loadStaticObject(session,objectId); + break; + + case ServerTangibleObjectTemplate::ServerTangibleObjectTemplate_tag: + loadTangibleObject(session,objectId); + break; + + case ServerUniverseObjectTemplate::ServerUniverseObjectTemplate_tag: + loadUniverseObject(session,objectId); + break; + + case ServerVehicleObjectTemplate::ServerVehicleObjectTemplate_tag: + loadVehicleObject(session,objectId); + break; + + case ServerWeaponObjectTemplate::ServerWeaponObjectTemplate_tag: + loadWeaponObject(session,objectId); + break; + + default: + WARNING(true,("Attempt to load object %s from the database. It has unknown type %i.",objectId.getValueString().c_str(),typeId)); + } +} + +void SwgSnapshot::newObject(NetworkId const & objectId, int templateId, Tag typeId) +{ + m_objectTableBuffer.newObject(objectId, templateId, typeId); + switch(typeId) + { + case ServerBattlefieldMarkerObjectTemplate::ServerBattlefieldMarkerObjectTemplate_tag: + newBattlefieldMarkerObject(objectId); + break; + + case ServerBuildingObjectTemplate::ServerBuildingObjectTemplate_tag: + newBuildingObject(objectId); + break; + + case ServerCellObjectTemplate::ServerCellObjectTemplate_tag: + newCellObject(objectId); + break; + + case ServerCityObjectTemplate::ServerCityObjectTemplate_tag: + newCityObject(objectId); + break; + + case ServerCreatureObjectTemplate::ServerCreatureObjectTemplate_tag: + newCreatureObject(objectId); + break; + + case ServerFactoryObjectTemplate::ServerFactoryObjectTemplate_tag: + newFactoryObject(objectId); + break; + + case ServerGuildObjectTemplate::ServerGuildObjectTemplate_tag: + newGuildObject(objectId); + break; + + case ServerHarvesterInstallationObjectTemplate::ServerHarvesterInstallationObjectTemplate_tag: + newHarvesterInstallationObject(objectId); + break; + + case ServerInstallationObjectTemplate::ServerInstallationObjectTemplate_tag: + newInstallationObject(objectId); + break; + + case ServerIntangibleObjectTemplate::ServerIntangibleObjectTemplate_tag: + newIntangibleObject(objectId); + break; + + case ServerManufactureInstallationObjectTemplate::ServerManufactureInstallationObjectTemplate_tag: + newManufactureInstallationObject(objectId); + break; + + case ServerManufactureSchematicObjectTemplate::ServerManufactureSchematicObjectTemplate_tag: + newManufactureSchematicObject(objectId); + break; + + case ServerMissionObjectTemplate::ServerMissionObjectTemplate_tag: + newMissionObject(objectId); + break; + + case ServerPlanetObjectTemplate::ServerPlanetObjectTemplate_tag: + newPlanetObject(objectId); + break; + + case ServerPlayerObjectTemplate::ServerPlayerObjectTemplate_tag: + newPlayerObject(objectId); + break; + + case ServerPlayerQuestObjectTemplate::ServerPlayerQuestObjectTemplate_tag: + newPlayerQuestObject(objectId); + break; + + case ServerResourceContainerObjectTemplate::ServerResourceContainerObjectTemplate_tag: + newResourceContainerObject(objectId); + break; + + case ServerShipObjectTemplate::ServerShipObjectTemplate_tag: + newShipObject(objectId); + break; + + case ServerStaticObjectTemplate::ServerStaticObjectTemplate_tag: + newStaticObject(objectId); + break; + + case ServerTangibleObjectTemplate::ServerTangibleObjectTemplate_tag: + newTangibleObject(objectId); + break; + + case ServerUniverseObjectTemplate::ServerUniverseObjectTemplate_tag: + newUniverseObject(objectId); + break; + + case ServerVehicleObjectTemplate::ServerVehicleObjectTemplate_tag: + newVehicleObject(objectId); + break; + + case ServerWeaponObjectTemplate::ServerWeaponObjectTemplate_tag: + newWeaponObject(objectId); + break; + + default: + WARNING(true,("Attempt to create object %s. It has unknown type %i.",objectId.getValueString().c_str(),typeId)); + } +} + +void SwgSnapshot::registerTags() +{ + m_battlefieldMarkerObjectBuffer.addTag(ServerBattlefieldMarkerObjectTemplate::ServerBattlefieldMarkerObjectTemplate_tag); + m_tangibleObjectBuffer.addTag(ServerBattlefieldMarkerObjectTemplate::ServerBattlefieldMarkerObjectTemplate_tag); + m_buildingObjectBuffer.addTag(ServerBuildingObjectTemplate::ServerBuildingObjectTemplate_tag); + m_tangibleObjectBuffer.addTag(ServerBuildingObjectTemplate::ServerBuildingObjectTemplate_tag); + m_cellObjectBuffer.addTag(ServerCellObjectTemplate::ServerCellObjectTemplate_tag); + m_cityObjectBuffer.addTag(ServerCityObjectTemplate::ServerCityObjectTemplate_tag); + m_universeObjectBuffer.addTag(ServerCityObjectTemplate::ServerCityObjectTemplate_tag); + m_creatureObjectBuffer.addTag(ServerCreatureObjectTemplate::ServerCreatureObjectTemplate_tag); + m_tangibleObjectBuffer.addTag(ServerCreatureObjectTemplate::ServerCreatureObjectTemplate_tag); + m_factoryObjectBuffer.addTag(ServerFactoryObjectTemplate::ServerFactoryObjectTemplate_tag); + m_tangibleObjectBuffer.addTag(ServerFactoryObjectTemplate::ServerFactoryObjectTemplate_tag); + m_guildObjectBuffer.addTag(ServerGuildObjectTemplate::ServerGuildObjectTemplate_tag); + m_universeObjectBuffer.addTag(ServerGuildObjectTemplate::ServerGuildObjectTemplate_tag); + m_harvesterInstallationObjectBuffer.addTag(ServerHarvesterInstallationObjectTemplate::ServerHarvesterInstallationObjectTemplate_tag); + m_installationObjectBuffer.addTag(ServerHarvesterInstallationObjectTemplate::ServerHarvesterInstallationObjectTemplate_tag); + m_tangibleObjectBuffer.addTag(ServerHarvesterInstallationObjectTemplate::ServerHarvesterInstallationObjectTemplate_tag); + m_installationObjectBuffer.addTag(ServerInstallationObjectTemplate::ServerInstallationObjectTemplate_tag); + m_tangibleObjectBuffer.addTag(ServerInstallationObjectTemplate::ServerInstallationObjectTemplate_tag); + m_intangibleObjectBuffer.addTag(ServerIntangibleObjectTemplate::ServerIntangibleObjectTemplate_tag); + m_manufactureInstallationObjectBuffer.addTag(ServerManufactureInstallationObjectTemplate::ServerManufactureInstallationObjectTemplate_tag); + m_installationObjectBuffer.addTag(ServerManufactureInstallationObjectTemplate::ServerManufactureInstallationObjectTemplate_tag); + m_tangibleObjectBuffer.addTag(ServerManufactureInstallationObjectTemplate::ServerManufactureInstallationObjectTemplate_tag); + m_manufactureSchematicObjectBuffer.addTag(ServerManufactureSchematicObjectTemplate::ServerManufactureSchematicObjectTemplate_tag); + m_intangibleObjectBuffer.addTag(ServerManufactureSchematicObjectTemplate::ServerManufactureSchematicObjectTemplate_tag); + m_missionObjectBuffer.addTag(ServerMissionObjectTemplate::ServerMissionObjectTemplate_tag); + m_intangibleObjectBuffer.addTag(ServerMissionObjectTemplate::ServerMissionObjectTemplate_tag); + m_planetObjectBuffer.addTag(ServerPlanetObjectTemplate::ServerPlanetObjectTemplate_tag); + m_universeObjectBuffer.addTag(ServerPlanetObjectTemplate::ServerPlanetObjectTemplate_tag); + m_playerObjectBuffer.addTag(ServerPlayerObjectTemplate::ServerPlayerObjectTemplate_tag); + m_intangibleObjectBuffer.addTag(ServerPlayerObjectTemplate::ServerPlayerObjectTemplate_tag); + m_playerQuestObjectBuffer.addTag(ServerPlayerQuestObjectTemplate::ServerPlayerQuestObjectTemplate_tag); + m_tangibleObjectBuffer.addTag(ServerPlayerQuestObjectTemplate::ServerPlayerQuestObjectTemplate_tag); + m_resourceContainerObjectBuffer.addTag(ServerResourceContainerObjectTemplate::ServerResourceContainerObjectTemplate_tag); + m_tangibleObjectBuffer.addTag(ServerResourceContainerObjectTemplate::ServerResourceContainerObjectTemplate_tag); + m_shipObjectBuffer.addTag(ServerShipObjectTemplate::ServerShipObjectTemplate_tag); + m_tangibleObjectBuffer.addTag(ServerShipObjectTemplate::ServerShipObjectTemplate_tag); + m_staticObjectBuffer.addTag(ServerStaticObjectTemplate::ServerStaticObjectTemplate_tag); + m_tangibleObjectBuffer.addTag(ServerTangibleObjectTemplate::ServerTangibleObjectTemplate_tag); + m_universeObjectBuffer.addTag(ServerUniverseObjectTemplate::ServerUniverseObjectTemplate_tag); + m_vehicleObjectBuffer.addTag(ServerVehicleObjectTemplate::ServerVehicleObjectTemplate_tag); + m_tangibleObjectBuffer.addTag(ServerVehicleObjectTemplate::ServerVehicleObjectTemplate_tag); + m_weaponObjectBuffer.addTag(ServerWeaponObjectTemplate::ServerWeaponObjectTemplate_tag); + m_tangibleObjectBuffer.addTag(ServerWeaponObjectTemplate::ServerWeaponObjectTemplate_tag); +} + //!!!END GENERATED LOADOBJECT diff --git a/game/server/application/SwgDatabaseServer/src/shared/generated/ObjectQueries_cpp.template b/game/server/application/SwgDatabaseServer/src/shared/generated/ObjectQueries_cpp.template index 067f2fac..165d5c9a 100644 --- a/game/server/application/SwgDatabaseServer/src/shared/generated/ObjectQueries_cpp.template +++ b/game/server/application/SwgDatabaseServer/src/shared/generated/ObjectQueries_cpp.template @@ -17,6 +17,6089 @@ using namespace ObjectQueriesNamespace; // ====================================================================== //!!!BEGIN GENERATED QUERYDEFINITIONS +BattlefieldMarkerObjectQuery::BattlefieldMarkerObjectQuery() : + DatabaseProcessQuery(new BattlefieldMarkerObjectRow), + m_numItems(0) +{ +} + +bool BattlefieldMarkerObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_region_names.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool BattlefieldMarkerObjectQuery::addData(const DB::Row *_data) +{ + const BattlefieldMarkerObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + if (!m_region_names.push_back(myData->region_name.getValueASCII())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int BattlefieldMarkerObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void BattlefieldMarkerObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + m_region_names.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void BattlefieldMarkerObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + m_region_names.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool BattlefieldMarkerObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_region_names)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool BattlefieldMarkerObjectQuery::bindColumns() +{ + return true; +} + +void BattlefieldMarkerObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_battlefield_marker_obj (:object_id, :region_name, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_battlefield_marker_obj (:object_id, :region_name, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_battlefield_marker_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +BattlefieldMarkerObjectQuerySelect::BattlefieldMarkerObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool BattlefieldMarkerObjectQuerySelect::bindParameters () +{ + return true; +} + +bool BattlefieldMarkerObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + if (!bindCol(m_data[0].region_name)) return false; + return true; +} + +const std::vector & BattlefieldMarkerObjectQuerySelect::getData() const +{ + return m_data; +} + +void BattlefieldMarkerObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_battlefield_marker_object; end;"; +} + +DB::Query::QueryMode BattlefieldMarkerObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +BuildingObjectQuery::BuildingObjectQuery() : + DatabaseProcessQuery(new BuildingObjectRow), + m_numItems(0) +{ +} + +bool BuildingObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_maintenance_costs.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_time_last_checkeds.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_is_publics.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_city_ids.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool BuildingObjectQuery::addData(const DB::Row *_data) +{ + const BuildingObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + if (!m_maintenance_costs.push_back(myData->maintenance_cost.isNull(), myData->maintenance_cost.getValue())) return false; + if (!m_time_last_checkeds.push_back(myData->time_last_checked.isNull(), myData->time_last_checked.getValue())) return false; + if (!m_is_publics.push_back(myData->is_public.getValueASCII())) return false; + if (!m_city_ids.push_back(myData->city_id.isNull(), myData->city_id.getValue())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int BuildingObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void BuildingObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + m_maintenance_costs.clear(); + m_time_last_checkeds.clear(); + m_is_publics.clear(); + m_city_ids.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void BuildingObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + m_maintenance_costs.free(); + m_time_last_checkeds.free(); + m_is_publics.free(); + m_city_ids.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool BuildingObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_maintenance_costs)) return false; + if (!bindParameter(m_time_last_checkeds)) return false; + if (!bindParameter(m_is_publics)) return false; + if (!bindParameter(m_city_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool BuildingObjectQuery::bindColumns() +{ + return true; +} + +void BuildingObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_building_obj (:object_id, :maintenance_cost, :time_last_checked, :is_public, :city_id, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_building_obj (:object_id, :maintenance_cost, :time_last_checked, :is_public, :city_id, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_building_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +BuildingObjectQuerySelect::BuildingObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool BuildingObjectQuerySelect::bindParameters () +{ + return true; +} + +bool BuildingObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + if (!bindCol(m_data[0].maintenance_cost)) return false; + if (!bindCol(m_data[0].time_last_checked)) return false; + if (!bindCol(m_data[0].is_public)) return false; + if (!bindCol(m_data[0].city_id)) return false; + return true; +} + +const std::vector & BuildingObjectQuerySelect::getData() const +{ + return m_data; +} + +void BuildingObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_building_object; end;"; +} + +DB::Query::QueryMode BuildingObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +CellObjectQuery::CellObjectQuery() : + DatabaseProcessQuery(new CellObjectRow), + m_numItems(0) +{ +} + +bool CellObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_cell_numbers.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_is_publics.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool CellObjectQuery::addData(const DB::Row *_data) +{ + const CellObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + if (!m_cell_numbers.push_back(myData->cell_number.isNull(), myData->cell_number.getValue())) return false; + if (!m_is_publics.push_back(myData->is_public.getValueASCII())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int CellObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void CellObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + m_cell_numbers.clear(); + m_is_publics.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void CellObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + m_cell_numbers.free(); + m_is_publics.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool CellObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_cell_numbers)) return false; + if (!bindParameter(m_is_publics)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool CellObjectQuery::bindColumns() +{ + return true; +} + +void CellObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_cell_obj (:object_id, :cell_number, :is_public, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_cell_obj (:object_id, :cell_number, :is_public, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_cell_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +CellObjectQuerySelect::CellObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool CellObjectQuerySelect::bindParameters () +{ + return true; +} + +bool CellObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + if (!bindCol(m_data[0].cell_number)) return false; + if (!bindCol(m_data[0].is_public)) return false; + return true; +} + +const std::vector & CellObjectQuerySelect::getData() const +{ + return m_data; +} + +void CellObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_cell_object; end;"; +} + +DB::Query::QueryMode CellObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +CityObjectQuery::CityObjectQuery() : + DatabaseProcessQuery(new CityObjectRow), + m_numItems(0) +{ +} + +bool CityObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool CityObjectQuery::addData(const DB::Row *_data) +{ + const CityObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int CityObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void CityObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void CityObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool CityObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool CityObjectQuery::bindColumns() +{ + return true; +} + +void CityObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_city_obj (:object_id, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_city_obj (:object_id, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_city_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +CityObjectQuerySelect::CityObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool CityObjectQuerySelect::bindParameters () +{ + return true; +} + +bool CityObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + return true; +} + +const std::vector & CityObjectQuerySelect::getData() const +{ + return m_data; +} + +void CityObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_city_object; end;"; +} + +DB::Query::QueryMode CityObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +CreatureObjectQuery::CreatureObjectQuery() : + DatabaseProcessQuery(new CreatureObjectRow), + m_numItems(0) +{ +} + +bool CreatureObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_scale_factors.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_statess.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_postures.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_shock_woundss.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_master_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_ranks.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_base_walk_speeds.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_base_run_speeds.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_0s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_1s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_2s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_3s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_4s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_5s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_6s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_7s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_8s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_9s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_10s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_11s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_12s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_13s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_14s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_15s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_16s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_17s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_18s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_19s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_20s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_21s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_22s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_23s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_24s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_25s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attribute_26s.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_persisted_buffss.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_ws_xs.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_ws_ys.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_ws_zs.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool CreatureObjectQuery::addData(const DB::Row *_data) +{ + const CreatureObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + if (!m_scale_factors.push_back(myData->scale_factor.isNull(), myData->scale_factor.getValue())) return false; + if (!m_statess.push_back(myData->states.isNull(), myData->states.getValue())) return false; + if (!m_postures.push_back(myData->posture.isNull(), myData->posture.getValue())) return false; + if (!m_shock_woundss.push_back(myData->shock_wounds.isNull(), myData->shock_wounds.getValue())) return false; + if (!m_master_ids.push_back(myData->master_id.getValueASCII())) return false; + if (!m_ranks.push_back(myData->rank.isNull(), myData->rank.getValue())) return false; + if (!m_base_walk_speeds.push_back(myData->base_walk_speed.isNull(), myData->base_walk_speed.getValue())) return false; + if (!m_base_run_speeds.push_back(myData->base_run_speed.isNull(), myData->base_run_speed.getValue())) return false; + if (!m_attribute_0s.push_back(myData->attribute_0.isNull(), myData->attribute_0.getValue())) return false; + if (!m_attribute_1s.push_back(myData->attribute_1.isNull(), myData->attribute_1.getValue())) return false; + if (!m_attribute_2s.push_back(myData->attribute_2.isNull(), myData->attribute_2.getValue())) return false; + if (!m_attribute_3s.push_back(myData->attribute_3.isNull(), myData->attribute_3.getValue())) return false; + if (!m_attribute_4s.push_back(myData->attribute_4.isNull(), myData->attribute_4.getValue())) return false; + if (!m_attribute_5s.push_back(myData->attribute_5.isNull(), myData->attribute_5.getValue())) return false; + if (!m_attribute_6s.push_back(myData->attribute_6.isNull(), myData->attribute_6.getValue())) return false; + if (!m_attribute_7s.push_back(myData->attribute_7.isNull(), myData->attribute_7.getValue())) return false; + if (!m_attribute_8s.push_back(myData->attribute_8.isNull(), myData->attribute_8.getValue())) return false; + if (!m_attribute_9s.push_back(myData->attribute_9.isNull(), myData->attribute_9.getValue())) return false; + if (!m_attribute_10s.push_back(myData->attribute_10.isNull(), myData->attribute_10.getValue())) return false; + if (!m_attribute_11s.push_back(myData->attribute_11.isNull(), myData->attribute_11.getValue())) return false; + if (!m_attribute_12s.push_back(myData->attribute_12.isNull(), myData->attribute_12.getValue())) return false; + if (!m_attribute_13s.push_back(myData->attribute_13.isNull(), myData->attribute_13.getValue())) return false; + if (!m_attribute_14s.push_back(myData->attribute_14.isNull(), myData->attribute_14.getValue())) return false; + if (!m_attribute_15s.push_back(myData->attribute_15.isNull(), myData->attribute_15.getValue())) return false; + if (!m_attribute_16s.push_back(myData->attribute_16.isNull(), myData->attribute_16.getValue())) return false; + if (!m_attribute_17s.push_back(myData->attribute_17.isNull(), myData->attribute_17.getValue())) return false; + if (!m_attribute_18s.push_back(myData->attribute_18.isNull(), myData->attribute_18.getValue())) return false; + if (!m_attribute_19s.push_back(myData->attribute_19.isNull(), myData->attribute_19.getValue())) return false; + if (!m_attribute_20s.push_back(myData->attribute_20.isNull(), myData->attribute_20.getValue())) return false; + if (!m_attribute_21s.push_back(myData->attribute_21.isNull(), myData->attribute_21.getValue())) return false; + if (!m_attribute_22s.push_back(myData->attribute_22.isNull(), myData->attribute_22.getValue())) return false; + if (!m_attribute_23s.push_back(myData->attribute_23.isNull(), myData->attribute_23.getValue())) return false; + if (!m_attribute_24s.push_back(myData->attribute_24.isNull(), myData->attribute_24.getValue())) return false; + if (!m_attribute_25s.push_back(myData->attribute_25.isNull(), myData->attribute_25.getValue())) return false; + if (!m_attribute_26s.push_back(myData->attribute_26.isNull(), myData->attribute_26.getValue())) return false; + if (!m_persisted_buffss.push_back(myData->persisted_buffs.getValueASCII())) return false; + if (!m_ws_xs.push_back(myData->ws_x.isNull(), myData->ws_x.getValue())) return false; + if (!m_ws_ys.push_back(myData->ws_y.isNull(), myData->ws_y.getValue())) return false; + if (!m_ws_zs.push_back(myData->ws_z.isNull(), myData->ws_z.getValue())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int CreatureObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void CreatureObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + m_scale_factors.clear(); + m_statess.clear(); + m_postures.clear(); + m_shock_woundss.clear(); + m_master_ids.clear(); + m_ranks.clear(); + m_base_walk_speeds.clear(); + m_base_run_speeds.clear(); + m_attribute_0s.clear(); + m_attribute_1s.clear(); + m_attribute_2s.clear(); + m_attribute_3s.clear(); + m_attribute_4s.clear(); + m_attribute_5s.clear(); + m_attribute_6s.clear(); + m_attribute_7s.clear(); + m_attribute_8s.clear(); + m_attribute_9s.clear(); + m_attribute_10s.clear(); + m_attribute_11s.clear(); + m_attribute_12s.clear(); + m_attribute_13s.clear(); + m_attribute_14s.clear(); + m_attribute_15s.clear(); + m_attribute_16s.clear(); + m_attribute_17s.clear(); + m_attribute_18s.clear(); + m_attribute_19s.clear(); + m_attribute_20s.clear(); + m_attribute_21s.clear(); + m_attribute_22s.clear(); + m_attribute_23s.clear(); + m_attribute_24s.clear(); + m_attribute_25s.clear(); + m_attribute_26s.clear(); + m_persisted_buffss.clear(); + m_ws_xs.clear(); + m_ws_ys.clear(); + m_ws_zs.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void CreatureObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + m_scale_factors.free(); + m_statess.free(); + m_postures.free(); + m_shock_woundss.free(); + m_master_ids.free(); + m_ranks.free(); + m_base_walk_speeds.free(); + m_base_run_speeds.free(); + m_attribute_0s.free(); + m_attribute_1s.free(); + m_attribute_2s.free(); + m_attribute_3s.free(); + m_attribute_4s.free(); + m_attribute_5s.free(); + m_attribute_6s.free(); + m_attribute_7s.free(); + m_attribute_8s.free(); + m_attribute_9s.free(); + m_attribute_10s.free(); + m_attribute_11s.free(); + m_attribute_12s.free(); + m_attribute_13s.free(); + m_attribute_14s.free(); + m_attribute_15s.free(); + m_attribute_16s.free(); + m_attribute_17s.free(); + m_attribute_18s.free(); + m_attribute_19s.free(); + m_attribute_20s.free(); + m_attribute_21s.free(); + m_attribute_22s.free(); + m_attribute_23s.free(); + m_attribute_24s.free(); + m_attribute_25s.free(); + m_attribute_26s.free(); + m_persisted_buffss.free(); + m_ws_xs.free(); + m_ws_ys.free(); + m_ws_zs.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool CreatureObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_scale_factors)) return false; + if (!bindParameter(m_statess)) return false; + if (!bindParameter(m_postures)) return false; + if (!bindParameter(m_shock_woundss)) return false; + if (!bindParameter(m_master_ids)) return false; + if (!bindParameter(m_ranks)) return false; + if (!bindParameter(m_base_walk_speeds)) return false; + if (!bindParameter(m_base_run_speeds)) return false; + if (!bindParameter(m_attribute_0s)) return false; + if (!bindParameter(m_attribute_1s)) return false; + if (!bindParameter(m_attribute_2s)) return false; + if (!bindParameter(m_attribute_3s)) return false; + if (!bindParameter(m_attribute_4s)) return false; + if (!bindParameter(m_attribute_5s)) return false; + if (!bindParameter(m_attribute_6s)) return false; + if (!bindParameter(m_attribute_7s)) return false; + if (!bindParameter(m_attribute_8s)) return false; + if (!bindParameter(m_attribute_9s)) return false; + if (!bindParameter(m_attribute_10s)) return false; + if (!bindParameter(m_attribute_11s)) return false; + if (!bindParameter(m_attribute_12s)) return false; + if (!bindParameter(m_attribute_13s)) return false; + if (!bindParameter(m_attribute_14s)) return false; + if (!bindParameter(m_attribute_15s)) return false; + if (!bindParameter(m_attribute_16s)) return false; + if (!bindParameter(m_attribute_17s)) return false; + if (!bindParameter(m_attribute_18s)) return false; + if (!bindParameter(m_attribute_19s)) return false; + if (!bindParameter(m_attribute_20s)) return false; + if (!bindParameter(m_attribute_21s)) return false; + if (!bindParameter(m_attribute_22s)) return false; + if (!bindParameter(m_attribute_23s)) return false; + if (!bindParameter(m_attribute_24s)) return false; + if (!bindParameter(m_attribute_25s)) return false; + if (!bindParameter(m_attribute_26s)) return false; + if (!bindParameter(m_persisted_buffss)) return false; + if (!bindParameter(m_ws_xs)) return false; + if (!bindParameter(m_ws_ys)) return false; + if (!bindParameter(m_ws_zs)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool CreatureObjectQuery::bindColumns() +{ + return true; +} + +void CreatureObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_creature_obj (:object_id, :scale_factor, :states, :posture, :shock_wounds, :master_id, :rank, :base_walk_speed, :base_run_speed, :attribute_0, :attribute_1, :attribute_2, :attribute_3, :attribute_4, :attribute_5, :attribute_6, :attribute_7, :attribute_8, :attribute_9, :attribute_10, :attribute_11, :attribute_12, :attribute_13, :attribute_14, :attribute_15, :attribute_16, :attribute_17, :attribute_18, :attribute_19, :attribute_20, :attribute_21, :attribute_22, :attribute_23, :attribute_24, :attribute_25, :attribute_26, :persisted_buffs, :ws_x, :ws_y, :ws_z, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_creature_obj (:object_id, :scale_factor, :states, :posture, :shock_wounds, :master_id, :rank, :base_walk_speed, :base_run_speed, :attribute_0, :attribute_1, :attribute_2, :attribute_3, :attribute_4, :attribute_5, :attribute_6, :attribute_7, :attribute_8, :attribute_9, :attribute_10, :attribute_11, :attribute_12, :attribute_13, :attribute_14, :attribute_15, :attribute_16, :attribute_17, :attribute_18, :attribute_19, :attribute_20, :attribute_21, :attribute_22, :attribute_23, :attribute_24, :attribute_25, :attribute_26, :persisted_buffs, :ws_x, :ws_y, :ws_z, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_creature_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +CreatureObjectQuerySelect::CreatureObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool CreatureObjectQuerySelect::bindParameters () +{ + return true; +} + +bool CreatureObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + if (!bindCol(m_data[0].scale_factor)) return false; + if (!bindCol(m_data[0].states)) return false; + if (!bindCol(m_data[0].posture)) return false; + if (!bindCol(m_data[0].shock_wounds)) return false; + if (!bindCol(m_data[0].master_id)) return false; + if (!bindCol(m_data[0].rank)) return false; + if (!bindCol(m_data[0].base_walk_speed)) return false; + if (!bindCol(m_data[0].base_run_speed)) return false; + if (!bindCol(m_data[0].attribute_0)) return false; + if (!bindCol(m_data[0].attribute_1)) return false; + if (!bindCol(m_data[0].attribute_2)) return false; + if (!bindCol(m_data[0].attribute_3)) return false; + if (!bindCol(m_data[0].attribute_4)) return false; + if (!bindCol(m_data[0].attribute_5)) return false; + if (!bindCol(m_data[0].attribute_6)) return false; + if (!bindCol(m_data[0].attribute_7)) return false; + if (!bindCol(m_data[0].attribute_8)) return false; + if (!bindCol(m_data[0].attribute_9)) return false; + if (!bindCol(m_data[0].attribute_10)) return false; + if (!bindCol(m_data[0].attribute_11)) return false; + if (!bindCol(m_data[0].attribute_12)) return false; + if (!bindCol(m_data[0].attribute_13)) return false; + if (!bindCol(m_data[0].attribute_14)) return false; + if (!bindCol(m_data[0].attribute_15)) return false; + if (!bindCol(m_data[0].attribute_16)) return false; + if (!bindCol(m_data[0].attribute_17)) return false; + if (!bindCol(m_data[0].attribute_18)) return false; + if (!bindCol(m_data[0].attribute_19)) return false; + if (!bindCol(m_data[0].attribute_20)) return false; + if (!bindCol(m_data[0].attribute_21)) return false; + if (!bindCol(m_data[0].attribute_22)) return false; + if (!bindCol(m_data[0].attribute_23)) return false; + if (!bindCol(m_data[0].attribute_24)) return false; + if (!bindCol(m_data[0].attribute_25)) return false; + if (!bindCol(m_data[0].attribute_26)) return false; + if (!bindCol(m_data[0].persisted_buffs)) return false; + if (!bindCol(m_data[0].ws_x)) return false; + if (!bindCol(m_data[0].ws_y)) return false; + if (!bindCol(m_data[0].ws_z)) return false; + return true; +} + +const std::vector & CreatureObjectQuerySelect::getData() const +{ + return m_data; +} + +void CreatureObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_creature_object; end;"; +} + +DB::Query::QueryMode CreatureObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +FactoryObjectQuery::FactoryObjectQuery() : + DatabaseProcessQuery(new FactoryObjectRow), + m_numItems(0) +{ +} + +bool FactoryObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool FactoryObjectQuery::addData(const DB::Row *_data) +{ + const FactoryObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int FactoryObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void FactoryObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void FactoryObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool FactoryObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool FactoryObjectQuery::bindColumns() +{ + return true; +} + +void FactoryObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_factory_obj (:object_id, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_factory_obj (:object_id, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_factory_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +FactoryObjectQuerySelect::FactoryObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool FactoryObjectQuerySelect::bindParameters () +{ + return true; +} + +bool FactoryObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + return true; +} + +const std::vector & FactoryObjectQuerySelect::getData() const +{ + return m_data; +} + +void FactoryObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_factory_object; end;"; +} + +DB::Query::QueryMode FactoryObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +GuildObjectQuery::GuildObjectQuery() : + DatabaseProcessQuery(new GuildObjectRow), + m_numItems(0) +{ +} + +bool GuildObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool GuildObjectQuery::addData(const DB::Row *_data) +{ + const GuildObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int GuildObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void GuildObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void GuildObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool GuildObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool GuildObjectQuery::bindColumns() +{ + return true; +} + +void GuildObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_guild_obj (:object_id, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_guild_obj (:object_id, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_guild_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +GuildObjectQuerySelect::GuildObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool GuildObjectQuerySelect::bindParameters () +{ + return true; +} + +bool GuildObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + return true; +} + +const std::vector & GuildObjectQuerySelect::getData() const +{ + return m_data; +} + +void GuildObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_guild_object; end;"; +} + +DB::Query::QueryMode GuildObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +HarvesterInstallationObjectQuery::HarvesterInstallationObjectQuery() : + DatabaseProcessQuery(new HarvesterInstallationObjectRow), + m_numItems(0) +{ +} + +bool HarvesterInstallationObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_installed_efficiencys.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_max_extraction_rates.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_current_extraction_rates.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_max_hopper_amounts.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_hopper_resources.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_hopper_amounts.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_resource_types.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool HarvesterInstallationObjectQuery::addData(const DB::Row *_data) +{ + const HarvesterInstallationObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + if (!m_installed_efficiencys.push_back(myData->installed_efficiency.isNull(), myData->installed_efficiency.getValue())) return false; + if (!m_max_extraction_rates.push_back(myData->max_extraction_rate.isNull(), myData->max_extraction_rate.getValue())) return false; + if (!m_current_extraction_rates.push_back(myData->current_extraction_rate.isNull(), myData->current_extraction_rate.getValue())) return false; + if (!m_max_hopper_amounts.push_back(myData->max_hopper_amount.isNull(), myData->max_hopper_amount.getValue())) return false; + if (!m_hopper_resources.push_back(myData->hopper_resource.getValueASCII())) return false; + if (!m_hopper_amounts.push_back(myData->hopper_amount.isNull(), myData->hopper_amount.getValue())) return false; + if (!m_resource_types.push_back(myData->resource_type.getValueASCII())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int HarvesterInstallationObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void HarvesterInstallationObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + m_installed_efficiencys.clear(); + m_max_extraction_rates.clear(); + m_current_extraction_rates.clear(); + m_max_hopper_amounts.clear(); + m_hopper_resources.clear(); + m_hopper_amounts.clear(); + m_resource_types.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void HarvesterInstallationObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + m_installed_efficiencys.free(); + m_max_extraction_rates.free(); + m_current_extraction_rates.free(); + m_max_hopper_amounts.free(); + m_hopper_resources.free(); + m_hopper_amounts.free(); + m_resource_types.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool HarvesterInstallationObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_installed_efficiencys)) return false; + if (!bindParameter(m_max_extraction_rates)) return false; + if (!bindParameter(m_current_extraction_rates)) return false; + if (!bindParameter(m_max_hopper_amounts)) return false; + if (!bindParameter(m_hopper_resources)) return false; + if (!bindParameter(m_hopper_amounts)) return false; + if (!bindParameter(m_resource_types)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool HarvesterInstallationObjectQuery::bindColumns() +{ + return true; +} + +void HarvesterInstallationObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_harvester_inst_obj (:object_id, :installed_efficiency, :max_extraction_rate, :current_extraction_rate, :max_hopper_amount, :hopper_resource, :hopper_amount, :resource_type, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_harvester_inst_obj (:object_id, :installed_efficiency, :max_extraction_rate, :current_extraction_rate, :max_hopper_amount, :hopper_resource, :hopper_amount, :resource_type, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_harvester_inst_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +HarvesterInstallationObjectQuerySelect::HarvesterInstallationObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool HarvesterInstallationObjectQuerySelect::bindParameters () +{ + return true; +} + +bool HarvesterInstallationObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + if (!bindCol(m_data[0].installed_efficiency)) return false; + if (!bindCol(m_data[0].max_extraction_rate)) return false; + if (!bindCol(m_data[0].current_extraction_rate)) return false; + if (!bindCol(m_data[0].max_hopper_amount)) return false; + if (!bindCol(m_data[0].hopper_resource)) return false; + if (!bindCol(m_data[0].hopper_amount)) return false; + if (!bindCol(m_data[0].resource_type)) return false; + return true; +} + +const std::vector & HarvesterInstallationObjectQuerySelect::getData() const +{ + return m_data; +} + +void HarvesterInstallationObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_harvester_inst_object; end;"; +} + +DB::Query::QueryMode HarvesterInstallationObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +InstallationObjectQuery::InstallationObjectQuery() : + DatabaseProcessQuery(new InstallationObjectRow), + m_numItems(0) +{ +} + +bool InstallationObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_installation_types.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_activateds.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_tick_counts.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_activate_start_times.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_powers.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_power_rates.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool InstallationObjectQuery::addData(const DB::Row *_data) +{ + const InstallationObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + if (!m_installation_types.push_back(myData->installation_type.isNull(), myData->installation_type.getValue())) return false; + if (!m_activateds.push_back(myData->activated.getValueASCII())) return false; + if (!m_tick_counts.push_back(myData->tick_count.isNull(), myData->tick_count.getValue())) return false; + if (!m_activate_start_times.push_back(myData->activate_start_time.isNull(), myData->activate_start_time.getValue())) return false; + if (!m_powers.push_back(myData->power.isNull(), myData->power.getValue())) return false; + if (!m_power_rates.push_back(myData->power_rate.isNull(), myData->power_rate.getValue())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int InstallationObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void InstallationObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + m_installation_types.clear(); + m_activateds.clear(); + m_tick_counts.clear(); + m_activate_start_times.clear(); + m_powers.clear(); + m_power_rates.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void InstallationObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + m_installation_types.free(); + m_activateds.free(); + m_tick_counts.free(); + m_activate_start_times.free(); + m_powers.free(); + m_power_rates.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool InstallationObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_installation_types)) return false; + if (!bindParameter(m_activateds)) return false; + if (!bindParameter(m_tick_counts)) return false; + if (!bindParameter(m_activate_start_times)) return false; + if (!bindParameter(m_powers)) return false; + if (!bindParameter(m_power_rates)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool InstallationObjectQuery::bindColumns() +{ + return true; +} + +void InstallationObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_installation_obj (:object_id, :installation_type, :activated, :tick_count, :activate_start_time, :power, :power_rate, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_installation_obj (:object_id, :installation_type, :activated, :tick_count, :activate_start_time, :power, :power_rate, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_installation_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +InstallationObjectQuerySelect::InstallationObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool InstallationObjectQuerySelect::bindParameters () +{ + return true; +} + +bool InstallationObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + if (!bindCol(m_data[0].installation_type)) return false; + if (!bindCol(m_data[0].activated)) return false; + if (!bindCol(m_data[0].tick_count)) return false; + if (!bindCol(m_data[0].activate_start_time)) return false; + if (!bindCol(m_data[0].power)) return false; + if (!bindCol(m_data[0].power_rate)) return false; + return true; +} + +const std::vector & InstallationObjectQuerySelect::getData() const +{ + return m_data; +} + +void InstallationObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_installation_object; end;"; +} + +DB::Query::QueryMode InstallationObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +IntangibleObjectQuery::IntangibleObjectQuery() : + DatabaseProcessQuery(new IntangibleObjectRow), + m_numItems(0) +{ +} + +bool IntangibleObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_counts.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool IntangibleObjectQuery::addData(const DB::Row *_data) +{ + const IntangibleObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + if (!m_counts.push_back(myData->count.isNull(), myData->count.getValue())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int IntangibleObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void IntangibleObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + m_counts.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void IntangibleObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + m_counts.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool IntangibleObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_counts)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool IntangibleObjectQuery::bindColumns() +{ + return true; +} + +void IntangibleObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_intangible_obj (:object_id, :count, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_intangible_obj (:object_id, :count, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_intangible_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +IntangibleObjectQuerySelect::IntangibleObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool IntangibleObjectQuerySelect::bindParameters () +{ + return true; +} + +bool IntangibleObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + if (!bindCol(m_data[0].count)) return false; + return true; +} + +const std::vector & IntangibleObjectQuerySelect::getData() const +{ + return m_data; +} + +void IntangibleObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_intangible_object; end;"; +} + +DB::Query::QueryMode IntangibleObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +ManufactureSchematicObjectQuery::ManufactureSchematicObjectQuery() : + DatabaseProcessQuery(new ManufactureSchematicObjectRow), + m_numItems(0) +{ +} + +bool ManufactureSchematicObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_creator_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_creator_names.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_items_per_containers.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_manufacture_times.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_draft_schematics.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool ManufactureSchematicObjectQuery::addData(const DB::Row *_data) +{ + const ManufactureSchematicObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + if (!m_creator_ids.push_back(myData->creator_id.getValueASCII())) return false; + if (!m_creator_names.push_back(myData->creator_name.getValueASCII())) return false; + if (!m_items_per_containers.push_back(myData->items_per_container.isNull(), myData->items_per_container.getValue())) return false; + if (!m_manufacture_times.push_back(myData->manufacture_time.isNull(), myData->manufacture_time.getValue())) return false; + if (!m_draft_schematics.push_back(myData->draft_schematic.isNull(), myData->draft_schematic.getValue())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int ManufactureSchematicObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void ManufactureSchematicObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + m_creator_ids.clear(); + m_creator_names.clear(); + m_items_per_containers.clear(); + m_manufacture_times.clear(); + m_draft_schematics.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void ManufactureSchematicObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + m_creator_ids.free(); + m_creator_names.free(); + m_items_per_containers.free(); + m_manufacture_times.free(); + m_draft_schematics.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool ManufactureSchematicObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_creator_ids)) return false; + if (!bindParameter(m_creator_names)) return false; + if (!bindParameter(m_items_per_containers)) return false; + if (!bindParameter(m_manufacture_times)) return false; + if (!bindParameter(m_draft_schematics)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool ManufactureSchematicObjectQuery::bindColumns() +{ + return true; +} + +void ManufactureSchematicObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_manf_schematic_obj (:object_id, :creator_id, :creator_name, :items_per_container, :manufacture_time, :draft_schematic, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_manf_schematic_obj (:object_id, :creator_id, :creator_name, :items_per_container, :manufacture_time, :draft_schematic, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_manf_schematic_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +ManufactureSchematicObjectQuerySelect::ManufactureSchematicObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool ManufactureSchematicObjectQuerySelect::bindParameters () +{ + return true; +} + +bool ManufactureSchematicObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + if (!bindCol(m_data[0].creator_id)) return false; + if (!bindCol(m_data[0].creator_name)) return false; + if (!bindCol(m_data[0].items_per_container)) return false; + if (!bindCol(m_data[0].manufacture_time)) return false; + if (!bindCol(m_data[0].draft_schematic)) return false; + return true; +} + +const std::vector & ManufactureSchematicObjectQuerySelect::getData() const +{ + return m_data; +} + +void ManufactureSchematicObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_manf_schematic_object; end;"; +} + +DB::Query::QueryMode ManufactureSchematicObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +ManufactureInstallationObjectQuery::ManufactureInstallationObjectQuery() : + DatabaseProcessQuery(new ManufactureInstallationObjectRow), + m_numItems(0) +{ +} + +bool ManufactureInstallationObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool ManufactureInstallationObjectQuery::addData(const DB::Row *_data) +{ + const ManufactureInstallationObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int ManufactureInstallationObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void ManufactureInstallationObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void ManufactureInstallationObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool ManufactureInstallationObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool ManufactureInstallationObjectQuery::bindColumns() +{ + return true; +} + +void ManufactureInstallationObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_manufacture_inst_obj (:object_id, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_manufacture_inst_obj (:object_id, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_manufacture_inst_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +ManufactureInstallationObjectQuerySelect::ManufactureInstallationObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool ManufactureInstallationObjectQuerySelect::bindParameters () +{ + return true; +} + +bool ManufactureInstallationObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + return true; +} + +const std::vector & ManufactureInstallationObjectQuerySelect::getData() const +{ + return m_data; +} + +void ManufactureInstallationObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_manufacture_inst_object; end;"; +} + +DB::Query::QueryMode ManufactureInstallationObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +MissionObjectQuery::MissionObjectQuery() : + DatabaseProcessQuery(new MissionObjectRow), + m_numItems(0) +{ +} + +bool MissionObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_difficultys.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_end_xs.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_end_ys.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_end_zs.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_end_cells.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_end_scenes.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_mission_creators.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_rewards.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_root_script_names.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_start_xs.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_start_ys.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_start_zs.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_start_cells.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_start_scenes.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_description_tables.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_description_texts.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_title_tables.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_title_texts.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_mission_holder_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_statuss.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_mission_types.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_target_appearances.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_target_names.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool MissionObjectQuery::addData(const DB::Row *_data) +{ + const MissionObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + if (!m_difficultys.push_back(myData->difficulty.isNull(), myData->difficulty.getValue())) return false; + if (!m_end_xs.push_back(myData->end_x.isNull(), myData->end_x.getValue())) return false; + if (!m_end_ys.push_back(myData->end_y.isNull(), myData->end_y.getValue())) return false; + if (!m_end_zs.push_back(myData->end_z.isNull(), myData->end_z.getValue())) return false; + if (!m_end_cells.push_back(myData->end_cell.getValueASCII())) return false; + if (!m_end_scenes.push_back(myData->end_scene.isNull(), myData->end_scene.getValue())) return false; + if (!m_mission_creators.push_back(myData->mission_creator.getValueASCII())) return false; + if (!m_rewards.push_back(myData->reward.isNull(), myData->reward.getValue())) return false; + if (!m_root_script_names.push_back(myData->root_script_name.getValueASCII())) return false; + if (!m_start_xs.push_back(myData->start_x.isNull(), myData->start_x.getValue())) return false; + if (!m_start_ys.push_back(myData->start_y.isNull(), myData->start_y.getValue())) return false; + if (!m_start_zs.push_back(myData->start_z.isNull(), myData->start_z.getValue())) return false; + if (!m_start_cells.push_back(myData->start_cell.getValueASCII())) return false; + if (!m_start_scenes.push_back(myData->start_scene.isNull(), myData->start_scene.getValue())) return false; + if (!m_description_tables.push_back(myData->description_table.getValueASCII())) return false; + if (!m_description_texts.push_back(myData->description_text.getValueASCII())) return false; + if (!m_title_tables.push_back(myData->title_table.getValueASCII())) return false; + if (!m_title_texts.push_back(myData->title_text.getValueASCII())) return false; + if (!m_mission_holder_ids.push_back(myData->mission_holder_id.getValueASCII())) return false; + if (!m_statuss.push_back(myData->status.isNull(), myData->status.getValue())) return false; + if (!m_mission_types.push_back(myData->mission_type.isNull(), myData->mission_type.getValue())) return false; + if (!m_target_appearances.push_back(myData->target_appearance.isNull(), myData->target_appearance.getValue())) return false; + if (!m_target_names.push_back(myData->target_name.getValueASCII())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int MissionObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void MissionObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + m_difficultys.clear(); + m_end_xs.clear(); + m_end_ys.clear(); + m_end_zs.clear(); + m_end_cells.clear(); + m_end_scenes.clear(); + m_mission_creators.clear(); + m_rewards.clear(); + m_root_script_names.clear(); + m_start_xs.clear(); + m_start_ys.clear(); + m_start_zs.clear(); + m_start_cells.clear(); + m_start_scenes.clear(); + m_description_tables.clear(); + m_description_texts.clear(); + m_title_tables.clear(); + m_title_texts.clear(); + m_mission_holder_ids.clear(); + m_statuss.clear(); + m_mission_types.clear(); + m_target_appearances.clear(); + m_target_names.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void MissionObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + m_difficultys.free(); + m_end_xs.free(); + m_end_ys.free(); + m_end_zs.free(); + m_end_cells.free(); + m_end_scenes.free(); + m_mission_creators.free(); + m_rewards.free(); + m_root_script_names.free(); + m_start_xs.free(); + m_start_ys.free(); + m_start_zs.free(); + m_start_cells.free(); + m_start_scenes.free(); + m_description_tables.free(); + m_description_texts.free(); + m_title_tables.free(); + m_title_texts.free(); + m_mission_holder_ids.free(); + m_statuss.free(); + m_mission_types.free(); + m_target_appearances.free(); + m_target_names.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool MissionObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_difficultys)) return false; + if (!bindParameter(m_end_xs)) return false; + if (!bindParameter(m_end_ys)) return false; + if (!bindParameter(m_end_zs)) return false; + if (!bindParameter(m_end_cells)) return false; + if (!bindParameter(m_end_scenes)) return false; + if (!bindParameter(m_mission_creators)) return false; + if (!bindParameter(m_rewards)) return false; + if (!bindParameter(m_root_script_names)) return false; + if (!bindParameter(m_start_xs)) return false; + if (!bindParameter(m_start_ys)) return false; + if (!bindParameter(m_start_zs)) return false; + if (!bindParameter(m_start_cells)) return false; + if (!bindParameter(m_start_scenes)) return false; + if (!bindParameter(m_description_tables)) return false; + if (!bindParameter(m_description_texts)) return false; + if (!bindParameter(m_title_tables)) return false; + if (!bindParameter(m_title_texts)) return false; + if (!bindParameter(m_mission_holder_ids)) return false; + if (!bindParameter(m_statuss)) return false; + if (!bindParameter(m_mission_types)) return false; + if (!bindParameter(m_target_appearances)) return false; + if (!bindParameter(m_target_names)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool MissionObjectQuery::bindColumns() +{ + return true; +} + +void MissionObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_mission_obj (:object_id, :difficulty, :end_x, :end_y, :end_z, :end_cell, :end_scene, :mission_creator, :reward, :root_script_name, :start_x, :start_y, :start_z, :start_cell, :start_scene, :description_table, :description_text, :title_table, :title_text, :mission_holder_id, :status, :mission_type, :target_appearance, :target_name, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_mission_obj (:object_id, :difficulty, :end_x, :end_y, :end_z, :end_cell, :end_scene, :mission_creator, :reward, :root_script_name, :start_x, :start_y, :start_z, :start_cell, :start_scene, :description_table, :description_text, :title_table, :title_text, :mission_holder_id, :status, :mission_type, :target_appearance, :target_name, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_mission_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +MissionObjectQuerySelect::MissionObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool MissionObjectQuerySelect::bindParameters () +{ + return true; +} + +bool MissionObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + if (!bindCol(m_data[0].difficulty)) return false; + if (!bindCol(m_data[0].end_x)) return false; + if (!bindCol(m_data[0].end_y)) return false; + if (!bindCol(m_data[0].end_z)) return false; + if (!bindCol(m_data[0].end_cell)) return false; + if (!bindCol(m_data[0].end_scene)) return false; + if (!bindCol(m_data[0].mission_creator)) return false; + if (!bindCol(m_data[0].reward)) return false; + if (!bindCol(m_data[0].root_script_name)) return false; + if (!bindCol(m_data[0].start_x)) return false; + if (!bindCol(m_data[0].start_y)) return false; + if (!bindCol(m_data[0].start_z)) return false; + if (!bindCol(m_data[0].start_cell)) return false; + if (!bindCol(m_data[0].start_scene)) return false; + if (!bindCol(m_data[0].description_table)) return false; + if (!bindCol(m_data[0].description_text)) return false; + if (!bindCol(m_data[0].title_table)) return false; + if (!bindCol(m_data[0].title_text)) return false; + if (!bindCol(m_data[0].mission_holder_id)) return false; + if (!bindCol(m_data[0].status)) return false; + if (!bindCol(m_data[0].mission_type)) return false; + if (!bindCol(m_data[0].target_appearance)) return false; + if (!bindCol(m_data[0].target_name)) return false; + return true; +} + +const std::vector & MissionObjectQuerySelect::getData() const +{ + return m_data; +} + +void MissionObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_mission_object; end;"; +} + +DB::Query::QueryMode MissionObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +PlanetObjectQuery::PlanetObjectQuery() : + DatabaseProcessQuery(new PlanetObjectRow), + m_numItems(0) +{ +} + +bool PlanetObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_planet_names.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool PlanetObjectQuery::addData(const DB::Row *_data) +{ + const PlanetObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + if (!m_planet_names.push_back(myData->planet_name.getValueASCII())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int PlanetObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void PlanetObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + m_planet_names.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void PlanetObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + m_planet_names.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool PlanetObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_planet_names)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool PlanetObjectQuery::bindColumns() +{ + return true; +} + +void PlanetObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_planet_obj (:object_id, :planet_name, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_planet_obj (:object_id, :planet_name, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_planet_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +PlanetObjectQuerySelect::PlanetObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool PlanetObjectQuerySelect::bindParameters () +{ + return true; +} + +bool PlanetObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + if (!bindCol(m_data[0].planet_name)) return false; + return true; +} + +const std::vector & PlanetObjectQuerySelect::getData() const +{ + return m_data; +} + +void PlanetObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_planet_object; end;"; +} + +DB::Query::QueryMode PlanetObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +PlayerObjectQuery::PlayerObjectQuery() : + DatabaseProcessQuery(new PlayerObjectRow), + m_numItems(0) +{ +} + +bool PlayerObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_station_ids.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_house_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_account_num_lotss.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_account_is_outcasts.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_account_cheater_levels.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_account_max_lots_adjustments.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_personal_profile_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_character_profile_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_skill_titles.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_born_dates.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_played_times.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_force_regen_rates.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_force_powers.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_max_force_powers.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_active_questss.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_completed_questss.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_current_quests.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_questss.create(session, "VAOFLONGSTRING", DatabaseProcess::getInstance().getSchema(), 4000)) return false; + if (!m_role_icon_choices.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_quests2s.create(session, "VAOFLONGSTRING", DatabaseProcess::getInstance().getSchema(), 4000)) return false; + if (!m_quests3s.create(session, "VAOFLONGSTRING", DatabaseProcess::getInstance().getSchema(), 4000)) return false; + if (!m_quests4s.create(session, "VAOFLONGSTRING", DatabaseProcess::getInstance().getSchema(), 4000)) return false; + if (!m_skill_templates.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_working_skills.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_current_gcw_pointss.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_current_gcw_ratings.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_current_pvp_killss.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_lifetime_gcw_pointss.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_max_gcw_imperial_ratings.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_max_gcw_rebel_ratings.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_lifetime_pvp_killss.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_next_gcw_rating_calc_times.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_collectionss.create(session, "VAOFLONGSTRING", DatabaseProcess::getInstance().getSchema(), 4000)) return false; + if (!m_show_backpacks.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_show_helmets.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_collections2s.create(session, "VAOFLONGSTRING", DatabaseProcess::getInstance().getSchema(), 4000)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool PlayerObjectQuery::addData(const DB::Row *_data) +{ + const PlayerObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + if (!m_station_ids.push_back(myData->station_id.isNull(), myData->station_id.getValue())) return false; + if (!m_house_ids.push_back(myData->house_id.getValueASCII())) return false; + if (!m_account_num_lotss.push_back(myData->account_num_lots.isNull(), myData->account_num_lots.getValue())) return false; + if (!m_account_is_outcasts.push_back(myData->account_is_outcast.getValueASCII())) return false; + if (!m_account_cheater_levels.push_back(myData->account_cheater_level.isNull(), myData->account_cheater_level.getValue())) return false; + if (!m_account_max_lots_adjustments.push_back(myData->account_max_lots_adjustment.isNull(), myData->account_max_lots_adjustment.getValue())) return false; + if (!m_personal_profile_ids.push_back(myData->personal_profile_id.getValueASCII())) return false; + if (!m_character_profile_ids.push_back(myData->character_profile_id.getValueASCII())) return false; + if (!m_skill_titles.push_back(myData->skill_title.getValueASCII())) return false; + if (!m_born_dates.push_back(myData->born_date.isNull(), myData->born_date.getValue())) return false; + if (!m_played_times.push_back(myData->played_time.isNull(), myData->played_time.getValue())) return false; + if (!m_force_regen_rates.push_back(myData->force_regen_rate.isNull(), myData->force_regen_rate.getValue())) return false; + if (!m_force_powers.push_back(myData->force_power.isNull(), myData->force_power.getValue())) return false; + if (!m_max_force_powers.push_back(myData->max_force_power.isNull(), myData->max_force_power.getValue())) return false; + if (!m_active_questss.push_back(myData->active_quests.getValueASCII())) return false; + if (!m_completed_questss.push_back(myData->completed_quests.getValueASCII())) return false; + if (!m_current_quests.push_back(myData->current_quest.isNull(), myData->current_quest.getValue())) return false; + if (!m_questss.push_back(myData->quests.getValueASCII())) return false; + if (!m_role_icon_choices.push_back(myData->role_icon_choice.isNull(), myData->role_icon_choice.getValue())) return false; + if (!m_quests2s.push_back(myData->quests2.getValueASCII())) return false; + if (!m_quests3s.push_back(myData->quests3.getValueASCII())) return false; + if (!m_quests4s.push_back(myData->quests4.getValueASCII())) return false; + if (!m_skill_templates.push_back(myData->skill_template.getValueASCII())) return false; + if (!m_working_skills.push_back(myData->working_skill.getValueASCII())) return false; + if (!m_current_gcw_pointss.push_back(myData->current_gcw_points.isNull(), myData->current_gcw_points.getValue())) return false; + if (!m_current_gcw_ratings.push_back(myData->current_gcw_rating.isNull(), myData->current_gcw_rating.getValue())) return false; + if (!m_current_pvp_killss.push_back(myData->current_pvp_kills.isNull(), myData->current_pvp_kills.getValue())) return false; + if (!m_lifetime_gcw_pointss.push_back(myData->lifetime_gcw_points.isNull(), myData->lifetime_gcw_points.getValue())) return false; + if (!m_max_gcw_imperial_ratings.push_back(myData->max_gcw_imperial_rating.isNull(), myData->max_gcw_imperial_rating.getValue())) return false; + if (!m_max_gcw_rebel_ratings.push_back(myData->max_gcw_rebel_rating.isNull(), myData->max_gcw_rebel_rating.getValue())) return false; + if (!m_lifetime_pvp_killss.push_back(myData->lifetime_pvp_kills.isNull(), myData->lifetime_pvp_kills.getValue())) return false; + if (!m_next_gcw_rating_calc_times.push_back(myData->next_gcw_rating_calc_time.isNull(), myData->next_gcw_rating_calc_time.getValue())) return false; + if (!m_collectionss.push_back(myData->collections.getValueASCII())) return false; + if (!m_show_backpacks.push_back(myData->show_backpack.getValueASCII())) return false; + if (!m_show_helmets.push_back(myData->show_helmet.getValueASCII())) return false; + if (!m_collections2s.push_back(myData->collections2.getValueASCII())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int PlayerObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void PlayerObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + m_station_ids.clear(); + m_house_ids.clear(); + m_account_num_lotss.clear(); + m_account_is_outcasts.clear(); + m_account_cheater_levels.clear(); + m_account_max_lots_adjustments.clear(); + m_personal_profile_ids.clear(); + m_character_profile_ids.clear(); + m_skill_titles.clear(); + m_born_dates.clear(); + m_played_times.clear(); + m_force_regen_rates.clear(); + m_force_powers.clear(); + m_max_force_powers.clear(); + m_active_questss.clear(); + m_completed_questss.clear(); + m_current_quests.clear(); + m_questss.clear(); + m_role_icon_choices.clear(); + m_quests2s.clear(); + m_quests3s.clear(); + m_quests4s.clear(); + m_skill_templates.clear(); + m_working_skills.clear(); + m_current_gcw_pointss.clear(); + m_current_gcw_ratings.clear(); + m_current_pvp_killss.clear(); + m_lifetime_gcw_pointss.clear(); + m_max_gcw_imperial_ratings.clear(); + m_max_gcw_rebel_ratings.clear(); + m_lifetime_pvp_killss.clear(); + m_next_gcw_rating_calc_times.clear(); + m_collectionss.clear(); + m_show_backpacks.clear(); + m_show_helmets.clear(); + m_collections2s.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void PlayerObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + m_station_ids.free(); + m_house_ids.free(); + m_account_num_lotss.free(); + m_account_is_outcasts.free(); + m_account_cheater_levels.free(); + m_account_max_lots_adjustments.free(); + m_personal_profile_ids.free(); + m_character_profile_ids.free(); + m_skill_titles.free(); + m_born_dates.free(); + m_played_times.free(); + m_force_regen_rates.free(); + m_force_powers.free(); + m_max_force_powers.free(); + m_active_questss.free(); + m_completed_questss.free(); + m_current_quests.free(); + m_questss.free(); + m_role_icon_choices.free(); + m_quests2s.free(); + m_quests3s.free(); + m_quests4s.free(); + m_skill_templates.free(); + m_working_skills.free(); + m_current_gcw_pointss.free(); + m_current_gcw_ratings.free(); + m_current_pvp_killss.free(); + m_lifetime_gcw_pointss.free(); + m_max_gcw_imperial_ratings.free(); + m_max_gcw_rebel_ratings.free(); + m_lifetime_pvp_killss.free(); + m_next_gcw_rating_calc_times.free(); + m_collectionss.free(); + m_show_backpacks.free(); + m_show_helmets.free(); + m_collections2s.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool PlayerObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_station_ids)) return false; + if (!bindParameter(m_house_ids)) return false; + if (!bindParameter(m_account_num_lotss)) return false; + if (!bindParameter(m_account_is_outcasts)) return false; + if (!bindParameter(m_account_cheater_levels)) return false; + if (!bindParameter(m_account_max_lots_adjustments)) return false; + if (!bindParameter(m_personal_profile_ids)) return false; + if (!bindParameter(m_character_profile_ids)) return false; + if (!bindParameter(m_skill_titles)) return false; + if (!bindParameter(m_born_dates)) return false; + if (!bindParameter(m_played_times)) return false; + if (!bindParameter(m_force_regen_rates)) return false; + if (!bindParameter(m_force_powers)) return false; + if (!bindParameter(m_max_force_powers)) return false; + if (!bindParameter(m_active_questss)) return false; + if (!bindParameter(m_completed_questss)) return false; + if (!bindParameter(m_current_quests)) return false; + if (!bindParameter(m_questss)) return false; + if (!bindParameter(m_role_icon_choices)) return false; + if (!bindParameter(m_quests2s)) return false; + if (!bindParameter(m_quests3s)) return false; + if (!bindParameter(m_quests4s)) return false; + if (!bindParameter(m_skill_templates)) return false; + if (!bindParameter(m_working_skills)) return false; + if (!bindParameter(m_current_gcw_pointss)) return false; + if (!bindParameter(m_current_gcw_ratings)) return false; + if (!bindParameter(m_current_pvp_killss)) return false; + if (!bindParameter(m_lifetime_gcw_pointss)) return false; + if (!bindParameter(m_max_gcw_imperial_ratings)) return false; + if (!bindParameter(m_max_gcw_rebel_ratings)) return false; + if (!bindParameter(m_lifetime_pvp_killss)) return false; + if (!bindParameter(m_next_gcw_rating_calc_times)) return false; + if (!bindParameter(m_collectionss)) return false; + if (!bindParameter(m_show_backpacks)) return false; + if (!bindParameter(m_show_helmets)) return false; + if (!bindParameter(m_collections2s)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool PlayerObjectQuery::bindColumns() +{ + return true; +} + +void PlayerObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_player_obj (:object_id, :station_id, :house_id, :account_num_lots, :account_is_outcast, :account_cheater_level, :account_max_lots_adjustment, :personal_profile_id, :character_profile_id, :skill_title, :born_date, :played_time, :force_regen_rate, :force_power, :max_force_power, :active_quests, :completed_quests, :current_quest, :quests, :role_icon_choice, :quests2, :quests3, :quests4, :skill_template, :working_skill, :current_gcw_points, :current_gcw_rating, :current_pvp_kills, :lifetime_gcw_points, :max_gcw_imperial_rating, :max_gcw_rebel_rating, :lifetime_pvp_kills, :next_gcw_rating_calc_time, :collections, :show_backpack, :show_helmet, :collections2, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_player_obj (:object_id, :station_id, :house_id, :account_num_lots, :account_is_outcast, :account_cheater_level, :account_max_lots_adjustment, :personal_profile_id, :character_profile_id, :skill_title, :born_date, :played_time, :force_regen_rate, :force_power, :max_force_power, :active_quests, :completed_quests, :current_quest, :quests, :role_icon_choice, :quests2, :quests3, :quests4, :skill_template, :working_skill, :current_gcw_points, :current_gcw_rating, :current_pvp_kills, :lifetime_gcw_points, :max_gcw_imperial_rating, :max_gcw_rebel_rating, :lifetime_pvp_kills, :next_gcw_rating_calc_time, :collections, :show_backpack, :show_helmet, :collections2, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_player_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +PlayerObjectQuerySelect::PlayerObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool PlayerObjectQuerySelect::bindParameters () +{ + return true; +} + +bool PlayerObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + if (!bindCol(m_data[0].station_id)) return false; + if (!bindCol(m_data[0].house_id)) return false; + if (!bindCol(m_data[0].account_num_lots)) return false; + if (!bindCol(m_data[0].account_is_outcast)) return false; + if (!bindCol(m_data[0].account_cheater_level)) return false; + if (!bindCol(m_data[0].account_max_lots_adjustment)) return false; + if (!bindCol(m_data[0].personal_profile_id)) return false; + if (!bindCol(m_data[0].character_profile_id)) return false; + if (!bindCol(m_data[0].skill_title)) return false; + if (!bindCol(m_data[0].born_date)) return false; + if (!bindCol(m_data[0].played_time)) return false; + if (!bindCol(m_data[0].force_regen_rate)) return false; + if (!bindCol(m_data[0].force_power)) return false; + if (!bindCol(m_data[0].max_force_power)) return false; + if (!bindCol(m_data[0].active_quests)) return false; + if (!bindCol(m_data[0].completed_quests)) return false; + if (!bindCol(m_data[0].current_quest)) return false; + if (!bindCol(m_data[0].quests)) return false; + if (!bindCol(m_data[0].role_icon_choice)) return false; + if (!bindCol(m_data[0].quests2)) return false; + if (!bindCol(m_data[0].quests3)) return false; + if (!bindCol(m_data[0].quests4)) return false; + if (!bindCol(m_data[0].skill_template)) return false; + if (!bindCol(m_data[0].working_skill)) return false; + if (!bindCol(m_data[0].current_gcw_points)) return false; + if (!bindCol(m_data[0].current_gcw_rating)) return false; + if (!bindCol(m_data[0].current_pvp_kills)) return false; + if (!bindCol(m_data[0].lifetime_gcw_points)) return false; + if (!bindCol(m_data[0].max_gcw_imperial_rating)) return false; + if (!bindCol(m_data[0].max_gcw_rebel_rating)) return false; + if (!bindCol(m_data[0].lifetime_pvp_kills)) return false; + if (!bindCol(m_data[0].next_gcw_rating_calc_time)) return false; + if (!bindCol(m_data[0].collections)) return false; + if (!bindCol(m_data[0].show_backpack)) return false; + if (!bindCol(m_data[0].show_helmet)) return false; + if (!bindCol(m_data[0].collections2)) return false; + return true; +} + +const std::vector & PlayerObjectQuerySelect::getData() const +{ + return m_data; +} + +void PlayerObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_player_object; end;"; +} + +DB::Query::QueryMode PlayerObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +PlayerQuestObjectQuery::PlayerQuestObjectQuery() : + DatabaseProcessQuery(new PlayerQuestObjectRow), + m_numItems(0) +{ +} + +bool PlayerQuestObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_titles.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_descriptions.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_creators.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_total_taskss.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_difficultys.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_task_title1s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_description1s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_title2s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_description2s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_title3s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_description3s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_title4s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_description4s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_title5s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_description5s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_title6s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_description6s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_title7s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_description7s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_title8s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_description8s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_title9s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_description9s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_title10s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_description10s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_title11s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_description11s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_title12s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_task_description12s.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool PlayerQuestObjectQuery::addData(const DB::Row *_data) +{ + const PlayerQuestObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + if (!m_titles.push_back(myData->title.getValueASCII())) return false; + if (!m_descriptions.push_back(myData->description.getValueASCII())) return false; + if (!m_creators.push_back(myData->creator.getValueASCII())) return false; + if (!m_total_taskss.push_back(myData->total_tasks.isNull(), myData->total_tasks.getValue())) return false; + if (!m_difficultys.push_back(myData->difficulty.isNull(), myData->difficulty.getValue())) return false; + if (!m_task_title1s.push_back(myData->task_title1.getValueASCII())) return false; + if (!m_task_description1s.push_back(myData->task_description1.getValueASCII())) return false; + if (!m_task_title2s.push_back(myData->task_title2.getValueASCII())) return false; + if (!m_task_description2s.push_back(myData->task_description2.getValueASCII())) return false; + if (!m_task_title3s.push_back(myData->task_title3.getValueASCII())) return false; + if (!m_task_description3s.push_back(myData->task_description3.getValueASCII())) return false; + if (!m_task_title4s.push_back(myData->task_title4.getValueASCII())) return false; + if (!m_task_description4s.push_back(myData->task_description4.getValueASCII())) return false; + if (!m_task_title5s.push_back(myData->task_title5.getValueASCII())) return false; + if (!m_task_description5s.push_back(myData->task_description5.getValueASCII())) return false; + if (!m_task_title6s.push_back(myData->task_title6.getValueASCII())) return false; + if (!m_task_description6s.push_back(myData->task_description6.getValueASCII())) return false; + if (!m_task_title7s.push_back(myData->task_title7.getValueASCII())) return false; + if (!m_task_description7s.push_back(myData->task_description7.getValueASCII())) return false; + if (!m_task_title8s.push_back(myData->task_title8.getValueASCII())) return false; + if (!m_task_description8s.push_back(myData->task_description8.getValueASCII())) return false; + if (!m_task_title9s.push_back(myData->task_title9.getValueASCII())) return false; + if (!m_task_description9s.push_back(myData->task_description9.getValueASCII())) return false; + if (!m_task_title10s.push_back(myData->task_title10.getValueASCII())) return false; + if (!m_task_description10s.push_back(myData->task_description10.getValueASCII())) return false; + if (!m_task_title11s.push_back(myData->task_title11.getValueASCII())) return false; + if (!m_task_description11s.push_back(myData->task_description11.getValueASCII())) return false; + if (!m_task_title12s.push_back(myData->task_title12.getValueASCII())) return false; + if (!m_task_description12s.push_back(myData->task_description12.getValueASCII())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int PlayerQuestObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void PlayerQuestObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + m_titles.clear(); + m_descriptions.clear(); + m_creators.clear(); + m_total_taskss.clear(); + m_difficultys.clear(); + m_task_title1s.clear(); + m_task_description1s.clear(); + m_task_title2s.clear(); + m_task_description2s.clear(); + m_task_title3s.clear(); + m_task_description3s.clear(); + m_task_title4s.clear(); + m_task_description4s.clear(); + m_task_title5s.clear(); + m_task_description5s.clear(); + m_task_title6s.clear(); + m_task_description6s.clear(); + m_task_title7s.clear(); + m_task_description7s.clear(); + m_task_title8s.clear(); + m_task_description8s.clear(); + m_task_title9s.clear(); + m_task_description9s.clear(); + m_task_title10s.clear(); + m_task_description10s.clear(); + m_task_title11s.clear(); + m_task_description11s.clear(); + m_task_title12s.clear(); + m_task_description12s.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void PlayerQuestObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + m_titles.free(); + m_descriptions.free(); + m_creators.free(); + m_total_taskss.free(); + m_difficultys.free(); + m_task_title1s.free(); + m_task_description1s.free(); + m_task_title2s.free(); + m_task_description2s.free(); + m_task_title3s.free(); + m_task_description3s.free(); + m_task_title4s.free(); + m_task_description4s.free(); + m_task_title5s.free(); + m_task_description5s.free(); + m_task_title6s.free(); + m_task_description6s.free(); + m_task_title7s.free(); + m_task_description7s.free(); + m_task_title8s.free(); + m_task_description8s.free(); + m_task_title9s.free(); + m_task_description9s.free(); + m_task_title10s.free(); + m_task_description10s.free(); + m_task_title11s.free(); + m_task_description11s.free(); + m_task_title12s.free(); + m_task_description12s.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool PlayerQuestObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_titles)) return false; + if (!bindParameter(m_descriptions)) return false; + if (!bindParameter(m_creators)) return false; + if (!bindParameter(m_total_taskss)) return false; + if (!bindParameter(m_difficultys)) return false; + if (!bindParameter(m_task_title1s)) return false; + if (!bindParameter(m_task_description1s)) return false; + if (!bindParameter(m_task_title2s)) return false; + if (!bindParameter(m_task_description2s)) return false; + if (!bindParameter(m_task_title3s)) return false; + if (!bindParameter(m_task_description3s)) return false; + if (!bindParameter(m_task_title4s)) return false; + if (!bindParameter(m_task_description4s)) return false; + if (!bindParameter(m_task_title5s)) return false; + if (!bindParameter(m_task_description5s)) return false; + if (!bindParameter(m_task_title6s)) return false; + if (!bindParameter(m_task_description6s)) return false; + if (!bindParameter(m_task_title7s)) return false; + if (!bindParameter(m_task_description7s)) return false; + if (!bindParameter(m_task_title8s)) return false; + if (!bindParameter(m_task_description8s)) return false; + if (!bindParameter(m_task_title9s)) return false; + if (!bindParameter(m_task_description9s)) return false; + if (!bindParameter(m_task_title10s)) return false; + if (!bindParameter(m_task_description10s)) return false; + if (!bindParameter(m_task_title11s)) return false; + if (!bindParameter(m_task_description11s)) return false; + if (!bindParameter(m_task_title12s)) return false; + if (!bindParameter(m_task_description12s)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool PlayerQuestObjectQuery::bindColumns() +{ + return true; +} + +void PlayerQuestObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_player_quest_obj (:object_id, :title, :description, :creator, :total_tasks, :difficulty, :task_title1, :task_description1, :task_title2, :task_description2, :task_title3, :task_description3, :task_title4, :task_description4, :task_title5, :task_description5, :task_title6, :task_description6, :task_title7, :task_description7, :task_title8, :task_description8, :task_title9, :task_description9, :task_title10, :task_description10, :task_title11, :task_description11, :task_title12, :task_description12, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_player_quest_obj (:object_id, :title, :description, :creator, :total_tasks, :difficulty, :task_title1, :task_description1, :task_title2, :task_description2, :task_title3, :task_description3, :task_title4, :task_description4, :task_title5, :task_description5, :task_title6, :task_description6, :task_title7, :task_description7, :task_title8, :task_description8, :task_title9, :task_description9, :task_title10, :task_description10, :task_title11, :task_description11, :task_title12, :task_description12, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_player_quest_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +PlayerQuestObjectQuerySelect::PlayerQuestObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool PlayerQuestObjectQuerySelect::bindParameters () +{ + return true; +} + +bool PlayerQuestObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + if (!bindCol(m_data[0].title)) return false; + if (!bindCol(m_data[0].description)) return false; + if (!bindCol(m_data[0].creator)) return false; + if (!bindCol(m_data[0].total_tasks)) return false; + if (!bindCol(m_data[0].difficulty)) return false; + if (!bindCol(m_data[0].task_title1)) return false; + if (!bindCol(m_data[0].task_description1)) return false; + if (!bindCol(m_data[0].task_title2)) return false; + if (!bindCol(m_data[0].task_description2)) return false; + if (!bindCol(m_data[0].task_title3)) return false; + if (!bindCol(m_data[0].task_description3)) return false; + if (!bindCol(m_data[0].task_title4)) return false; + if (!bindCol(m_data[0].task_description4)) return false; + if (!bindCol(m_data[0].task_title5)) return false; + if (!bindCol(m_data[0].task_description5)) return false; + if (!bindCol(m_data[0].task_title6)) return false; + if (!bindCol(m_data[0].task_description6)) return false; + if (!bindCol(m_data[0].task_title7)) return false; + if (!bindCol(m_data[0].task_description7)) return false; + if (!bindCol(m_data[0].task_title8)) return false; + if (!bindCol(m_data[0].task_description8)) return false; + if (!bindCol(m_data[0].task_title9)) return false; + if (!bindCol(m_data[0].task_description9)) return false; + if (!bindCol(m_data[0].task_title10)) return false; + if (!bindCol(m_data[0].task_description10)) return false; + if (!bindCol(m_data[0].task_title11)) return false; + if (!bindCol(m_data[0].task_description11)) return false; + if (!bindCol(m_data[0].task_title12)) return false; + if (!bindCol(m_data[0].task_description12)) return false; + return true; +} + +const std::vector & PlayerQuestObjectQuerySelect::getData() const +{ + return m_data; +} + +void PlayerQuestObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_player_quest_object; end;"; +} + +DB::Query::QueryMode PlayerQuestObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +ResourceContainerObjectQuery::ResourceContainerObjectQuery() : + DatabaseProcessQuery(new ResourceContainerObjectRow), + m_numItems(0) +{ +} + +bool ResourceContainerObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_resource_types.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_quantitys.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_sources.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool ResourceContainerObjectQuery::addData(const DB::Row *_data) +{ + const ResourceContainerObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + if (!m_resource_types.push_back(myData->resource_type.getValueASCII())) return false; + if (!m_quantitys.push_back(myData->quantity.isNull(), myData->quantity.getValue())) return false; + if (!m_sources.push_back(myData->source.getValueASCII())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int ResourceContainerObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void ResourceContainerObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + m_resource_types.clear(); + m_quantitys.clear(); + m_sources.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void ResourceContainerObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + m_resource_types.free(); + m_quantitys.free(); + m_sources.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool ResourceContainerObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_resource_types)) return false; + if (!bindParameter(m_quantitys)) return false; + if (!bindParameter(m_sources)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool ResourceContainerObjectQuery::bindColumns() +{ + return true; +} + +void ResourceContainerObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_resource_container_obj (:object_id, :resource_type, :quantity, :source, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_resource_container_obj (:object_id, :resource_type, :quantity, :source, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_resource_container_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +ResourceContainerObjectQuerySelect::ResourceContainerObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool ResourceContainerObjectQuerySelect::bindParameters () +{ + return true; +} + +bool ResourceContainerObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + if (!bindCol(m_data[0].resource_type)) return false; + if (!bindCol(m_data[0].quantity)) return false; + if (!bindCol(m_data[0].source)) return false; + return true; +} + +const std::vector & ResourceContainerObjectQuerySelect::getData() const +{ + return m_data; +} + +void ResourceContainerObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_resource_container_object; end;"; +} + +DB::Query::QueryMode ResourceContainerObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +ShipObjectQuery::ShipObjectQuery() : + DatabaseProcessQuery(new ShipObjectRow), + m_numItems(0) +{ +} + +bool ShipObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_slide_dampeners.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_current_chassis_hit_pointss.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_maximum_chassis_hit_pointss.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_chassis_types.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_cmp_armor_hp_maximums.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_cmp_armor_hp_currents.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_cmp_efficiency_generals.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_cmp_efficiency_engs.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_cmp_eng_maintenances.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_cmp_masss.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_cmp_crcs.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_cmp_hp_currents.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_cmp_hp_maximums.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_cmp_flagss.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_cmp_namess.create(session, "VAOFLONGSTRING", DatabaseProcess::getInstance().getSchema(), 4000)) return false; + if (!m_weapon_damage_maximums.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_weapon_damage_minimums.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_weapon_effectiveness_shieldss.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_weapon_effectiveness_armors.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_weapon_eng_per_shots.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_weapon_refire_rates.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_weapon_ammo_currents.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_weapon_ammo_maximums.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_weapon_ammo_types.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_shield_hp_front_maximums.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_shield_hp_back_maximums.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_shield_recharge_rates.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_capacitor_eng_maximums.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_capacitor_eng_recharge_rates.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_engine_acc_rates.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_engine_deceleration_rates.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_engine_pitch_acc_rates.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_engine_yaw_acc_rates.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_engine_roll_acc_rates.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_engine_pitch_rate_maximums.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_engine_yaw_rate_maximums.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_engine_roll_rate_maximums.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_engine_speed_maximums.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_reactor_eng_generation_rates.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_booster_eng_maximums.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_booster_eng_recharge_rates.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_booster_eng_consumption_rates.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_booster_accs.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_booster_speed_maximums.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_droid_if_cmd_speeds.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_installed_dcds.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_chassis_cmp_mass_maximums.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_cmp_creatorss.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_cargo_hold_contents_maximums.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_cargo_hold_contents_currents.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_cargo_hold_contentss.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool ShipObjectQuery::addData(const DB::Row *_data) +{ + const ShipObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + if (!m_slide_dampeners.push_back(myData->slide_dampener.isNull(), myData->slide_dampener.getValue())) return false; + if (!m_current_chassis_hit_pointss.push_back(myData->current_chassis_hit_points.isNull(), myData->current_chassis_hit_points.getValue())) return false; + if (!m_maximum_chassis_hit_pointss.push_back(myData->maximum_chassis_hit_points.isNull(), myData->maximum_chassis_hit_points.getValue())) return false; + if (!m_chassis_types.push_back(myData->chassis_type.isNull(), myData->chassis_type.getValue())) return false; + if (!m_cmp_armor_hp_maximums.push_back(myData->cmp_armor_hp_maximum.getValueASCII())) return false; + if (!m_cmp_armor_hp_currents.push_back(myData->cmp_armor_hp_current.getValueASCII())) return false; + if (!m_cmp_efficiency_generals.push_back(myData->cmp_efficiency_general.getValueASCII())) return false; + if (!m_cmp_efficiency_engs.push_back(myData->cmp_efficiency_eng.getValueASCII())) return false; + if (!m_cmp_eng_maintenances.push_back(myData->cmp_eng_maintenance.getValueASCII())) return false; + if (!m_cmp_masss.push_back(myData->cmp_mass.getValueASCII())) return false; + if (!m_cmp_crcs.push_back(myData->cmp_crc.getValueASCII())) return false; + if (!m_cmp_hp_currents.push_back(myData->cmp_hp_current.getValueASCII())) return false; + if (!m_cmp_hp_maximums.push_back(myData->cmp_hp_maximum.getValueASCII())) return false; + if (!m_cmp_flagss.push_back(myData->cmp_flags.getValueASCII())) return false; + if (!m_cmp_namess.push_back(myData->cmp_names.getValueASCII())) return false; + if (!m_weapon_damage_maximums.push_back(myData->weapon_damage_maximum.getValueASCII())) return false; + if (!m_weapon_damage_minimums.push_back(myData->weapon_damage_minimum.getValueASCII())) return false; + if (!m_weapon_effectiveness_shieldss.push_back(myData->weapon_effectiveness_shields.getValueASCII())) return false; + if (!m_weapon_effectiveness_armors.push_back(myData->weapon_effectiveness_armor.getValueASCII())) return false; + if (!m_weapon_eng_per_shots.push_back(myData->weapon_eng_per_shot.getValueASCII())) return false; + if (!m_weapon_refire_rates.push_back(myData->weapon_refire_rate.getValueASCII())) return false; + if (!m_weapon_ammo_currents.push_back(myData->weapon_ammo_current.getValueASCII())) return false; + if (!m_weapon_ammo_maximums.push_back(myData->weapon_ammo_maximum.getValueASCII())) return false; + if (!m_weapon_ammo_types.push_back(myData->weapon_ammo_type.getValueASCII())) return false; + if (!m_shield_hp_front_maximums.push_back(myData->shield_hp_front_maximum.isNull(), myData->shield_hp_front_maximum.getValue())) return false; + if (!m_shield_hp_back_maximums.push_back(myData->shield_hp_back_maximum.isNull(), myData->shield_hp_back_maximum.getValue())) return false; + if (!m_shield_recharge_rates.push_back(myData->shield_recharge_rate.isNull(), myData->shield_recharge_rate.getValue())) return false; + if (!m_capacitor_eng_maximums.push_back(myData->capacitor_eng_maximum.isNull(), myData->capacitor_eng_maximum.getValue())) return false; + if (!m_capacitor_eng_recharge_rates.push_back(myData->capacitor_eng_recharge_rate.isNull(), myData->capacitor_eng_recharge_rate.getValue())) return false; + if (!m_engine_acc_rates.push_back(myData->engine_acc_rate.isNull(), myData->engine_acc_rate.getValue())) return false; + if (!m_engine_deceleration_rates.push_back(myData->engine_deceleration_rate.isNull(), myData->engine_deceleration_rate.getValue())) return false; + if (!m_engine_pitch_acc_rates.push_back(myData->engine_pitch_acc_rate.isNull(), myData->engine_pitch_acc_rate.getValue())) return false; + if (!m_engine_yaw_acc_rates.push_back(myData->engine_yaw_acc_rate.isNull(), myData->engine_yaw_acc_rate.getValue())) return false; + if (!m_engine_roll_acc_rates.push_back(myData->engine_roll_acc_rate.isNull(), myData->engine_roll_acc_rate.getValue())) return false; + if (!m_engine_pitch_rate_maximums.push_back(myData->engine_pitch_rate_maximum.isNull(), myData->engine_pitch_rate_maximum.getValue())) return false; + if (!m_engine_yaw_rate_maximums.push_back(myData->engine_yaw_rate_maximum.isNull(), myData->engine_yaw_rate_maximum.getValue())) return false; + if (!m_engine_roll_rate_maximums.push_back(myData->engine_roll_rate_maximum.isNull(), myData->engine_roll_rate_maximum.getValue())) return false; + if (!m_engine_speed_maximums.push_back(myData->engine_speed_maximum.isNull(), myData->engine_speed_maximum.getValue())) return false; + if (!m_reactor_eng_generation_rates.push_back(myData->reactor_eng_generation_rate.isNull(), myData->reactor_eng_generation_rate.getValue())) return false; + if (!m_booster_eng_maximums.push_back(myData->booster_eng_maximum.isNull(), myData->booster_eng_maximum.getValue())) return false; + if (!m_booster_eng_recharge_rates.push_back(myData->booster_eng_recharge_rate.isNull(), myData->booster_eng_recharge_rate.getValue())) return false; + if (!m_booster_eng_consumption_rates.push_back(myData->booster_eng_consumption_rate.isNull(), myData->booster_eng_consumption_rate.getValue())) return false; + if (!m_booster_accs.push_back(myData->booster_acc.isNull(), myData->booster_acc.getValue())) return false; + if (!m_booster_speed_maximums.push_back(myData->booster_speed_maximum.isNull(), myData->booster_speed_maximum.getValue())) return false; + if (!m_droid_if_cmd_speeds.push_back(myData->droid_if_cmd_speed.isNull(), myData->droid_if_cmd_speed.getValue())) return false; + if (!m_installed_dcds.push_back(myData->installed_dcd.getValueASCII())) return false; + if (!m_chassis_cmp_mass_maximums.push_back(myData->chassis_cmp_mass_maximum.isNull(), myData->chassis_cmp_mass_maximum.getValue())) return false; + if (!m_cmp_creatorss.push_back(myData->cmp_creators.getValueASCII())) return false; + if (!m_cargo_hold_contents_maximums.push_back(myData->cargo_hold_contents_maximum.isNull(), myData->cargo_hold_contents_maximum.getValue())) return false; + if (!m_cargo_hold_contents_currents.push_back(myData->cargo_hold_contents_current.isNull(), myData->cargo_hold_contents_current.getValue())) return false; + if (!m_cargo_hold_contentss.push_back(myData->cargo_hold_contents.getValueASCII())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int ShipObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void ShipObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + m_slide_dampeners.clear(); + m_current_chassis_hit_pointss.clear(); + m_maximum_chassis_hit_pointss.clear(); + m_chassis_types.clear(); + m_cmp_armor_hp_maximums.clear(); + m_cmp_armor_hp_currents.clear(); + m_cmp_efficiency_generals.clear(); + m_cmp_efficiency_engs.clear(); + m_cmp_eng_maintenances.clear(); + m_cmp_masss.clear(); + m_cmp_crcs.clear(); + m_cmp_hp_currents.clear(); + m_cmp_hp_maximums.clear(); + m_cmp_flagss.clear(); + m_cmp_namess.clear(); + m_weapon_damage_maximums.clear(); + m_weapon_damage_minimums.clear(); + m_weapon_effectiveness_shieldss.clear(); + m_weapon_effectiveness_armors.clear(); + m_weapon_eng_per_shots.clear(); + m_weapon_refire_rates.clear(); + m_weapon_ammo_currents.clear(); + m_weapon_ammo_maximums.clear(); + m_weapon_ammo_types.clear(); + m_shield_hp_front_maximums.clear(); + m_shield_hp_back_maximums.clear(); + m_shield_recharge_rates.clear(); + m_capacitor_eng_maximums.clear(); + m_capacitor_eng_recharge_rates.clear(); + m_engine_acc_rates.clear(); + m_engine_deceleration_rates.clear(); + m_engine_pitch_acc_rates.clear(); + m_engine_yaw_acc_rates.clear(); + m_engine_roll_acc_rates.clear(); + m_engine_pitch_rate_maximums.clear(); + m_engine_yaw_rate_maximums.clear(); + m_engine_roll_rate_maximums.clear(); + m_engine_speed_maximums.clear(); + m_reactor_eng_generation_rates.clear(); + m_booster_eng_maximums.clear(); + m_booster_eng_recharge_rates.clear(); + m_booster_eng_consumption_rates.clear(); + m_booster_accs.clear(); + m_booster_speed_maximums.clear(); + m_droid_if_cmd_speeds.clear(); + m_installed_dcds.clear(); + m_chassis_cmp_mass_maximums.clear(); + m_cmp_creatorss.clear(); + m_cargo_hold_contents_maximums.clear(); + m_cargo_hold_contents_currents.clear(); + m_cargo_hold_contentss.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void ShipObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + m_slide_dampeners.free(); + m_current_chassis_hit_pointss.free(); + m_maximum_chassis_hit_pointss.free(); + m_chassis_types.free(); + m_cmp_armor_hp_maximums.free(); + m_cmp_armor_hp_currents.free(); + m_cmp_efficiency_generals.free(); + m_cmp_efficiency_engs.free(); + m_cmp_eng_maintenances.free(); + m_cmp_masss.free(); + m_cmp_crcs.free(); + m_cmp_hp_currents.free(); + m_cmp_hp_maximums.free(); + m_cmp_flagss.free(); + m_cmp_namess.free(); + m_weapon_damage_maximums.free(); + m_weapon_damage_minimums.free(); + m_weapon_effectiveness_shieldss.free(); + m_weapon_effectiveness_armors.free(); + m_weapon_eng_per_shots.free(); + m_weapon_refire_rates.free(); + m_weapon_ammo_currents.free(); + m_weapon_ammo_maximums.free(); + m_weapon_ammo_types.free(); + m_shield_hp_front_maximums.free(); + m_shield_hp_back_maximums.free(); + m_shield_recharge_rates.free(); + m_capacitor_eng_maximums.free(); + m_capacitor_eng_recharge_rates.free(); + m_engine_acc_rates.free(); + m_engine_deceleration_rates.free(); + m_engine_pitch_acc_rates.free(); + m_engine_yaw_acc_rates.free(); + m_engine_roll_acc_rates.free(); + m_engine_pitch_rate_maximums.free(); + m_engine_yaw_rate_maximums.free(); + m_engine_roll_rate_maximums.free(); + m_engine_speed_maximums.free(); + m_reactor_eng_generation_rates.free(); + m_booster_eng_maximums.free(); + m_booster_eng_recharge_rates.free(); + m_booster_eng_consumption_rates.free(); + m_booster_accs.free(); + m_booster_speed_maximums.free(); + m_droid_if_cmd_speeds.free(); + m_installed_dcds.free(); + m_chassis_cmp_mass_maximums.free(); + m_cmp_creatorss.free(); + m_cargo_hold_contents_maximums.free(); + m_cargo_hold_contents_currents.free(); + m_cargo_hold_contentss.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool ShipObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_slide_dampeners)) return false; + if (!bindParameter(m_current_chassis_hit_pointss)) return false; + if (!bindParameter(m_maximum_chassis_hit_pointss)) return false; + if (!bindParameter(m_chassis_types)) return false; + if (!bindParameter(m_cmp_armor_hp_maximums)) return false; + if (!bindParameter(m_cmp_armor_hp_currents)) return false; + if (!bindParameter(m_cmp_efficiency_generals)) return false; + if (!bindParameter(m_cmp_efficiency_engs)) return false; + if (!bindParameter(m_cmp_eng_maintenances)) return false; + if (!bindParameter(m_cmp_masss)) return false; + if (!bindParameter(m_cmp_crcs)) return false; + if (!bindParameter(m_cmp_hp_currents)) return false; + if (!bindParameter(m_cmp_hp_maximums)) return false; + if (!bindParameter(m_cmp_flagss)) return false; + if (!bindParameter(m_cmp_namess)) return false; + if (!bindParameter(m_weapon_damage_maximums)) return false; + if (!bindParameter(m_weapon_damage_minimums)) return false; + if (!bindParameter(m_weapon_effectiveness_shieldss)) return false; + if (!bindParameter(m_weapon_effectiveness_armors)) return false; + if (!bindParameter(m_weapon_eng_per_shots)) return false; + if (!bindParameter(m_weapon_refire_rates)) return false; + if (!bindParameter(m_weapon_ammo_currents)) return false; + if (!bindParameter(m_weapon_ammo_maximums)) return false; + if (!bindParameter(m_weapon_ammo_types)) return false; + if (!bindParameter(m_shield_hp_front_maximums)) return false; + if (!bindParameter(m_shield_hp_back_maximums)) return false; + if (!bindParameter(m_shield_recharge_rates)) return false; + if (!bindParameter(m_capacitor_eng_maximums)) return false; + if (!bindParameter(m_capacitor_eng_recharge_rates)) return false; + if (!bindParameter(m_engine_acc_rates)) return false; + if (!bindParameter(m_engine_deceleration_rates)) return false; + if (!bindParameter(m_engine_pitch_acc_rates)) return false; + if (!bindParameter(m_engine_yaw_acc_rates)) return false; + if (!bindParameter(m_engine_roll_acc_rates)) return false; + if (!bindParameter(m_engine_pitch_rate_maximums)) return false; + if (!bindParameter(m_engine_yaw_rate_maximums)) return false; + if (!bindParameter(m_engine_roll_rate_maximums)) return false; + if (!bindParameter(m_engine_speed_maximums)) return false; + if (!bindParameter(m_reactor_eng_generation_rates)) return false; + if (!bindParameter(m_booster_eng_maximums)) return false; + if (!bindParameter(m_booster_eng_recharge_rates)) return false; + if (!bindParameter(m_booster_eng_consumption_rates)) return false; + if (!bindParameter(m_booster_accs)) return false; + if (!bindParameter(m_booster_speed_maximums)) return false; + if (!bindParameter(m_droid_if_cmd_speeds)) return false; + if (!bindParameter(m_installed_dcds)) return false; + if (!bindParameter(m_chassis_cmp_mass_maximums)) return false; + if (!bindParameter(m_cmp_creatorss)) return false; + if (!bindParameter(m_cargo_hold_contents_maximums)) return false; + if (!bindParameter(m_cargo_hold_contents_currents)) return false; + if (!bindParameter(m_cargo_hold_contentss)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool ShipObjectQuery::bindColumns() +{ + return true; +} + +void ShipObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_ship_obj (:object_id, :slide_dampener, :current_chassis_hit_points, :maximum_chassis_hit_points, :chassis_type, :cmp_armor_hp_maximum, :cmp_armor_hp_current, :cmp_efficiency_general, :cmp_efficiency_eng, :cmp_eng_maintenance, :cmp_mass, :cmp_crc, :cmp_hp_current, :cmp_hp_maximum, :cmp_flags, :cmp_names, :weapon_damage_maximum, :weapon_damage_minimum, :weapon_effectiveness_shields, :weapon_effectiveness_armor, :weapon_eng_per_shot, :weapon_refire_rate, :weapon_ammo_current, :weapon_ammo_maximum, :weapon_ammo_type, :shield_hp_front_maximum, :shield_hp_back_maximum, :shield_recharge_rate, :capacitor_eng_maximum, :capacitor_eng_recharge_rate, :engine_acc_rate, :engine_deceleration_rate, :engine_pitch_acc_rate, :engine_yaw_acc_rate, :engine_roll_acc_rate, :engine_pitch_rate_maximum, :engine_yaw_rate_maximum, :engine_roll_rate_maximum, :engine_speed_maximum, :reactor_eng_generation_rate, :booster_eng_maximum, :booster_eng_recharge_rate, :booster_eng_consumption_rate, :booster_acc, :booster_speed_maximum, :droid_if_cmd_speed, :installed_dcd, :chassis_cmp_mass_maximum, :cmp_creators, :cargo_hold_contents_maximum, :cargo_hold_contents_current, :cargo_hold_contents, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_ship_obj (:object_id, :slide_dampener, :current_chassis_hit_points, :maximum_chassis_hit_points, :chassis_type, :cmp_armor_hp_maximum, :cmp_armor_hp_current, :cmp_efficiency_general, :cmp_efficiency_eng, :cmp_eng_maintenance, :cmp_mass, :cmp_crc, :cmp_hp_current, :cmp_hp_maximum, :cmp_flags, :cmp_names, :weapon_damage_maximum, :weapon_damage_minimum, :weapon_effectiveness_shields, :weapon_effectiveness_armor, :weapon_eng_per_shot, :weapon_refire_rate, :weapon_ammo_current, :weapon_ammo_maximum, :weapon_ammo_type, :shield_hp_front_maximum, :shield_hp_back_maximum, :shield_recharge_rate, :capacitor_eng_maximum, :capacitor_eng_recharge_rate, :engine_acc_rate, :engine_deceleration_rate, :engine_pitch_acc_rate, :engine_yaw_acc_rate, :engine_roll_acc_rate, :engine_pitch_rate_maximum, :engine_yaw_rate_maximum, :engine_roll_rate_maximum, :engine_speed_maximum, :reactor_eng_generation_rate, :booster_eng_maximum, :booster_eng_recharge_rate, :booster_eng_consumption_rate, :booster_acc, :booster_speed_maximum, :droid_if_cmd_speed, :installed_dcd, :chassis_cmp_mass_maximum, :cmp_creators, :cargo_hold_contents_maximum, :cargo_hold_contents_current, :cargo_hold_contents, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_ship_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +ShipObjectQuerySelect::ShipObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool ShipObjectQuerySelect::bindParameters () +{ + return true; +} + +bool ShipObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + if (!bindCol(m_data[0].slide_dampener)) return false; + if (!bindCol(m_data[0].current_chassis_hit_points)) return false; + if (!bindCol(m_data[0].maximum_chassis_hit_points)) return false; + if (!bindCol(m_data[0].chassis_type)) return false; + if (!bindCol(m_data[0].cmp_armor_hp_maximum)) return false; + if (!bindCol(m_data[0].cmp_armor_hp_current)) return false; + if (!bindCol(m_data[0].cmp_efficiency_general)) return false; + if (!bindCol(m_data[0].cmp_efficiency_eng)) return false; + if (!bindCol(m_data[0].cmp_eng_maintenance)) return false; + if (!bindCol(m_data[0].cmp_mass)) return false; + if (!bindCol(m_data[0].cmp_crc)) return false; + if (!bindCol(m_data[0].cmp_hp_current)) return false; + if (!bindCol(m_data[0].cmp_hp_maximum)) return false; + if (!bindCol(m_data[0].cmp_flags)) return false; + if (!bindCol(m_data[0].cmp_names)) return false; + if (!bindCol(m_data[0].weapon_damage_maximum)) return false; + if (!bindCol(m_data[0].weapon_damage_minimum)) return false; + if (!bindCol(m_data[0].weapon_effectiveness_shields)) return false; + if (!bindCol(m_data[0].weapon_effectiveness_armor)) return false; + if (!bindCol(m_data[0].weapon_eng_per_shot)) return false; + if (!bindCol(m_data[0].weapon_refire_rate)) return false; + if (!bindCol(m_data[0].weapon_ammo_current)) return false; + if (!bindCol(m_data[0].weapon_ammo_maximum)) return false; + if (!bindCol(m_data[0].weapon_ammo_type)) return false; + if (!bindCol(m_data[0].shield_hp_front_maximum)) return false; + if (!bindCol(m_data[0].shield_hp_back_maximum)) return false; + if (!bindCol(m_data[0].shield_recharge_rate)) return false; + if (!bindCol(m_data[0].capacitor_eng_maximum)) return false; + if (!bindCol(m_data[0].capacitor_eng_recharge_rate)) return false; + if (!bindCol(m_data[0].engine_acc_rate)) return false; + if (!bindCol(m_data[0].engine_deceleration_rate)) return false; + if (!bindCol(m_data[0].engine_pitch_acc_rate)) return false; + if (!bindCol(m_data[0].engine_yaw_acc_rate)) return false; + if (!bindCol(m_data[0].engine_roll_acc_rate)) return false; + if (!bindCol(m_data[0].engine_pitch_rate_maximum)) return false; + if (!bindCol(m_data[0].engine_yaw_rate_maximum)) return false; + if (!bindCol(m_data[0].engine_roll_rate_maximum)) return false; + if (!bindCol(m_data[0].engine_speed_maximum)) return false; + if (!bindCol(m_data[0].reactor_eng_generation_rate)) return false; + if (!bindCol(m_data[0].booster_eng_maximum)) return false; + if (!bindCol(m_data[0].booster_eng_recharge_rate)) return false; + if (!bindCol(m_data[0].booster_eng_consumption_rate)) return false; + if (!bindCol(m_data[0].booster_acc)) return false; + if (!bindCol(m_data[0].booster_speed_maximum)) return false; + if (!bindCol(m_data[0].droid_if_cmd_speed)) return false; + if (!bindCol(m_data[0].installed_dcd)) return false; + if (!bindCol(m_data[0].chassis_cmp_mass_maximum)) return false; + if (!bindCol(m_data[0].cmp_creators)) return false; + if (!bindCol(m_data[0].cargo_hold_contents_maximum)) return false; + if (!bindCol(m_data[0].cargo_hold_contents_current)) return false; + if (!bindCol(m_data[0].cargo_hold_contents)) return false; + return true; +} + +const std::vector & ShipObjectQuerySelect::getData() const +{ + return m_data; +} + +void ShipObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_ship_object; end;"; +} + +DB::Query::QueryMode ShipObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +StaticObjectQuery::StaticObjectQuery() : + DatabaseProcessQuery(new StaticObjectRow), + m_numItems(0) +{ +} + +bool StaticObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool StaticObjectQuery::addData(const DB::Row *_data) +{ + const StaticObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int StaticObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void StaticObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void StaticObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool StaticObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool StaticObjectQuery::bindColumns() +{ + return true; +} + +void StaticObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_static_obj (:object_id, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_static_obj (:object_id, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_static_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +StaticObjectQuerySelect::StaticObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool StaticObjectQuerySelect::bindParameters () +{ + return true; +} + +bool StaticObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + return true; +} + +const std::vector & StaticObjectQuerySelect::getData() const +{ + return m_data; +} + +void StaticObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_static_object; end;"; +} + +DB::Query::QueryMode StaticObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +TangibleObjectQuery::TangibleObjectQuery() : + DatabaseProcessQuery(new TangibleObjectRow), + m_numItems(0) +{ +} + +bool TangibleObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_max_hit_pointss.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_owner_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_visibles.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_appearance_datas.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_interest_radiuss.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_pvp_types.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_pvp_factions.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_damage_takens.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_custom_appearances.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_counts.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_conditions.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_creator_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_source_draft_schematics.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool TangibleObjectQuery::addData(const DB::Row *_data) +{ + const TangibleObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + if (!m_max_hit_pointss.push_back(myData->max_hit_points.isNull(), myData->max_hit_points.getValue())) return false; + if (!m_owner_ids.push_back(myData->owner_id.getValueASCII())) return false; + if (!m_visibles.push_back(myData->visible.getValueASCII())) return false; + if (!m_appearance_datas.push_back(myData->appearance_data.getValueASCII())) return false; + if (!m_interest_radiuss.push_back(myData->interest_radius.isNull(), myData->interest_radius.getValue())) return false; + if (!m_pvp_types.push_back(myData->pvp_type.isNull(), myData->pvp_type.getValue())) return false; + if (!m_pvp_factions.push_back(myData->pvp_faction.isNull(), myData->pvp_faction.getValue())) return false; + if (!m_damage_takens.push_back(myData->damage_taken.isNull(), myData->damage_taken.getValue())) return false; + if (!m_custom_appearances.push_back(myData->custom_appearance.getValueASCII())) return false; + if (!m_counts.push_back(myData->count.isNull(), myData->count.getValue())) return false; + if (!m_conditions.push_back(myData->condition.isNull(), myData->condition.getValue())) return false; + if (!m_creator_ids.push_back(myData->creator_id.getValueASCII())) return false; + if (!m_source_draft_schematics.push_back(myData->source_draft_schematic.isNull(), myData->source_draft_schematic.getValue())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int TangibleObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void TangibleObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + m_max_hit_pointss.clear(); + m_owner_ids.clear(); + m_visibles.clear(); + m_appearance_datas.clear(); + m_interest_radiuss.clear(); + m_pvp_types.clear(); + m_pvp_factions.clear(); + m_damage_takens.clear(); + m_custom_appearances.clear(); + m_counts.clear(); + m_conditions.clear(); + m_creator_ids.clear(); + m_source_draft_schematics.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void TangibleObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + m_max_hit_pointss.free(); + m_owner_ids.free(); + m_visibles.free(); + m_appearance_datas.free(); + m_interest_radiuss.free(); + m_pvp_types.free(); + m_pvp_factions.free(); + m_damage_takens.free(); + m_custom_appearances.free(); + m_counts.free(); + m_conditions.free(); + m_creator_ids.free(); + m_source_draft_schematics.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool TangibleObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_max_hit_pointss)) return false; + if (!bindParameter(m_owner_ids)) return false; + if (!bindParameter(m_visibles)) return false; + if (!bindParameter(m_appearance_datas)) return false; + if (!bindParameter(m_interest_radiuss)) return false; + if (!bindParameter(m_pvp_types)) return false; + if (!bindParameter(m_pvp_factions)) return false; + if (!bindParameter(m_damage_takens)) return false; + if (!bindParameter(m_custom_appearances)) return false; + if (!bindParameter(m_counts)) return false; + if (!bindParameter(m_conditions)) return false; + if (!bindParameter(m_creator_ids)) return false; + if (!bindParameter(m_source_draft_schematics)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool TangibleObjectQuery::bindColumns() +{ + return true; +} + +void TangibleObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_tangible_obj (:object_id, :max_hit_points, :owner_id, :visible, :appearance_data, :interest_radius, :pvp_type, :pvp_faction, :damage_taken, :custom_appearance, :count, :condition, :creator_id, :source_draft_schematic, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_tangible_obj (:object_id, :max_hit_points, :owner_id, :visible, :appearance_data, :interest_radius, :pvp_type, :pvp_faction, :damage_taken, :custom_appearance, :count, :condition, :creator_id, :source_draft_schematic, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_tangible_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +TangibleObjectQuerySelect::TangibleObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool TangibleObjectQuerySelect::bindParameters () +{ + return true; +} + +bool TangibleObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + if (!bindCol(m_data[0].max_hit_points)) return false; + if (!bindCol(m_data[0].owner_id)) return false; + if (!bindCol(m_data[0].visible)) return false; + if (!bindCol(m_data[0].appearance_data)) return false; + if (!bindCol(m_data[0].interest_radius)) return false; + if (!bindCol(m_data[0].pvp_type)) return false; + if (!bindCol(m_data[0].pvp_faction)) return false; + if (!bindCol(m_data[0].damage_taken)) return false; + if (!bindCol(m_data[0].custom_appearance)) return false; + if (!bindCol(m_data[0].count)) return false; + if (!bindCol(m_data[0].condition)) return false; + if (!bindCol(m_data[0].creator_id)) return false; + if (!bindCol(m_data[0].source_draft_schematic)) return false; + return true; +} + +const std::vector & TangibleObjectQuerySelect::getData() const +{ + return m_data; +} + +void TangibleObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_tangible_object; end;"; +} + +DB::Query::QueryMode TangibleObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +TokenObjectQuery::TokenObjectQuery() : + DatabaseProcessQuery(new TokenObjectRow), + m_numItems(0) +{ +} + +bool TokenObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_references.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_target_server_template_names.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_target_shared_template_names.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_waypoints.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool TokenObjectQuery::addData(const DB::Row *_data) +{ + const TokenObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + if (!m_references.push_back(myData->reference.getValueASCII())) return false; + if (!m_target_server_template_names.push_back(myData->target_server_template_name.getValueASCII())) return false; + if (!m_target_shared_template_names.push_back(myData->target_shared_template_name.getValueASCII())) return false; + if (!m_waypoints.push_back(myData->waypoint.getValueASCII())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int TokenObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void TokenObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + m_references.clear(); + m_target_server_template_names.clear(); + m_target_shared_template_names.clear(); + m_waypoints.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void TokenObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + m_references.free(); + m_target_server_template_names.free(); + m_target_shared_template_names.free(); + m_waypoints.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool TokenObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_references)) return false; + if (!bindParameter(m_target_server_template_names)) return false; + if (!bindParameter(m_target_shared_template_names)) return false; + if (!bindParameter(m_waypoints)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool TokenObjectQuery::bindColumns() +{ + return true; +} + +void TokenObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_token_obj (:object_id, :reference, :target_server_template_name, :target_shared_template_name, :waypoint, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_token_obj (:object_id, :reference, :target_server_template_name, :target_shared_template_name, :waypoint, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_token_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +TokenObjectQuerySelect::TokenObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool TokenObjectQuerySelect::bindParameters () +{ + return true; +} + +bool TokenObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + if (!bindCol(m_data[0].reference)) return false; + if (!bindCol(m_data[0].target_server_template_name)) return false; + if (!bindCol(m_data[0].target_shared_template_name)) return false; + if (!bindCol(m_data[0].waypoint)) return false; + return true; +} + +const std::vector & TokenObjectQuerySelect::getData() const +{ + return m_data; +} + +void TokenObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_token_object; end;"; +} + +DB::Query::QueryMode TokenObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +UniverseObjectQuery::UniverseObjectQuery() : + DatabaseProcessQuery(new UniverseObjectRow), + m_numItems(0) +{ +} + +bool UniverseObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool UniverseObjectQuery::addData(const DB::Row *_data) +{ + const UniverseObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int UniverseObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void UniverseObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void UniverseObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool UniverseObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool UniverseObjectQuery::bindColumns() +{ + return true; +} + +void UniverseObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_universe_obj (:object_id, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_universe_obj (:object_id, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_universe_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +UniverseObjectQuerySelect::UniverseObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool UniverseObjectQuerySelect::bindParameters () +{ + return true; +} + +bool UniverseObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + return true; +} + +const std::vector & UniverseObjectQuerySelect::getData() const +{ + return m_data; +} + +void UniverseObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_universe_object; end;"; +} + +DB::Query::QueryMode UniverseObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +VehicleObjectQuery::VehicleObjectQuery() : + DatabaseProcessQuery(new VehicleObjectRow), + m_numItems(0) +{ +} + +bool VehicleObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_boguss.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool VehicleObjectQuery::addData(const DB::Row *_data) +{ + const VehicleObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + if (!m_boguss.push_back(myData->bogus.isNull(), myData->bogus.getValue())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int VehicleObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void VehicleObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + m_boguss.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void VehicleObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + m_boguss.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool VehicleObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_boguss)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool VehicleObjectQuery::bindColumns() +{ + return true; +} + +void VehicleObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_vehicle_obj (:object_id, :bogus, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_vehicle_obj (:object_id, :bogus, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_vehicle_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +VehicleObjectQuerySelect::VehicleObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool VehicleObjectQuerySelect::bindParameters () +{ + return true; +} + +bool VehicleObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + if (!bindCol(m_data[0].bogus)) return false; + return true; +} + +const std::vector & VehicleObjectQuerySelect::getData() const +{ + return m_data; +} + +void VehicleObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_vehicle_object; end;"; +} + +DB::Query::QueryMode VehicleObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} + +WeaponObjectQuery::WeaponObjectQuery() : + DatabaseProcessQuery(new WeaponObjectRow), + m_numItems(0) +{ +} + +bool WeaponObjectQuery::setupData(DB::Session *session) +{ + + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(), 1000)) return false; + if (!m_min_damages.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_max_damages.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_damage_types.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_elemental_types.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_elemental_values.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attack_speeds.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_wound_chances.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_accuracys.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_attack_costs.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_damage_radiuss.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_min_ranges.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + if (!m_max_ranges.create(session, "VAOFNUMBER", DatabaseProcess::getInstance().getSchema())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.create(session, "VAOFSTRING", DatabaseProcess::getInstance().getSchema(),1000)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; +} + +bool WeaponObjectQuery::addData(const DB::Row *_data) +{ + const WeaponObjectBufferRow *myData=safe_cast(_data); + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + if (!m_min_damages.push_back(myData->min_damage.isNull(), myData->min_damage.getValue())) return false; + if (!m_max_damages.push_back(myData->max_damage.isNull(), myData->max_damage.getValue())) return false; + if (!m_damage_types.push_back(myData->damage_type.isNull(), myData->damage_type.getValue())) return false; + if (!m_elemental_types.push_back(myData->elemental_type.isNull(), myData->elemental_type.getValue())) return false; + if (!m_elemental_values.push_back(myData->elemental_value.isNull(), myData->elemental_value.getValue())) return false; + if (!m_attack_speeds.push_back(myData->attack_speed.isNull(), myData->attack_speed.getValue())) return false; + if (!m_wound_chances.push_back(myData->wound_chance.isNull(), myData->wound_chance.getValue())) return false; + if (!m_accuracys.push_back(myData->accuracy.isNull(), myData->accuracy.getValue())) return false; + if (!m_attack_costs.push_back(myData->attack_cost.isNull(), myData->attack_cost.getValue())) return false; + if (!m_damage_radiuss.push_back(myData->damage_radius.isNull(), myData->damage_radius.getValue())) return false; + if (!m_min_ranges.push_back(myData->min_range.isNull(), myData->min_range.getValue())) return false; + if (!m_max_ranges.push_back(myData->max_range.isNull(), myData->max_range.getValue())) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!m_object_ids.push_back(myData->object_id.getValueASCII())) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=m_numItems.getValue() + 1; + return true; +} + +int WeaponObjectQuery::getNumItems() const +{ + return m_numItems.getValue(); +} + +void WeaponObjectQuery::clearData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.clear(); + m_min_damages.clear(); + m_max_damages.clear(); + m_damage_types.clear(); + m_elemental_types.clear(); + m_elemental_values.clear(); + m_attack_speeds.clear(); + m_wound_chances.clear(); + m_accuracys.clear(); + m_attack_costs.clear(); + m_damage_radiuss.clear(); + m_min_ranges.clear(); + m_max_ranges.clear(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.clear(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + + m_numItems=0; +} + +void WeaponObjectQuery::freeData() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + m_object_ids.free(); + m_min_damages.free(); + m_max_damages.free(); + m_damage_types.free(); + m_elemental_types.free(); + m_elemental_values.free(); + m_attack_speeds.free(); + m_wound_chances.free(); + m_accuracys.free(); + m_attack_costs.free(); + m_damage_radiuss.free(); + m_min_ranges.free(); + m_max_ranges.free(); + break; + + case mode_SELECT: + break; + + case mode_DELETE: + m_object_ids.free(); + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +bool WeaponObjectQuery::bindParameters() +{ + switch(mode) + { + case mode_UPDATE: + case mode_INSERT: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_min_damages)) return false; + if (!bindParameter(m_max_damages)) return false; + if (!bindParameter(m_damage_types)) return false; + if (!bindParameter(m_elemental_types)) return false; + if (!bindParameter(m_elemental_values)) return false; + if (!bindParameter(m_attack_speeds)) return false; + if (!bindParameter(m_wound_chances)) return false; + if (!bindParameter(m_accuracys)) return false; + if (!bindParameter(m_attack_costs)) return false; + if (!bindParameter(m_damage_radiuss)) return false; + if (!bindParameter(m_min_ranges)) return false; + if (!bindParameter(m_max_ranges)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + if (!bindParameter(m_object_ids)) return false; + if (!bindParameter(m_numItems)) return false; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + return true; + +} + +bool WeaponObjectQuery::bindColumns() +{ + return true; +} + +void WeaponObjectQuery::getSQL(std::string &sql) +{ + switch(mode) + { + case mode_UPDATE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.save_weapon_obj (:object_id, :min_damage, :max_damage, :damage_type, :elemental_type, :elemental_value, :attack_speed, :wound_chance, :accuracy, :attack_cost, :damage_radius, :min_range, :max_range, :chunk_size); end;"; + break; + + case mode_INSERT: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.add_weapon_obj (:object_id, :min_damage, :max_damage, :damage_type, :elemental_type, :elemental_value, :attack_speed, :wound_chance, :accuracy, :attack_cost, :damage_radius, :min_range, :max_range, :chunk_size); end;"; + break; + + case mode_SELECT: + break; + + case mode_DELETE: + sql=std::string("begin ")+DatabaseProcess::getInstance().getSchemaQualifier()+"persister.remove_weapon_obj (:object_id, :chunk_size ); end;"; + break; + + default: + DEBUG_FATAL(true,("Bad query mode.")); + } + +} + +WeaponObjectQuerySelect::WeaponObjectQuerySelect(const std::string &schema) : + m_data(ms_fetchBatchSize), + m_schema(schema) +{ +} + +bool WeaponObjectQuerySelect::bindParameters () +{ + return true; +} + +bool WeaponObjectQuerySelect::bindColumns() +{ + size_t skipSize = reinterpret_cast(&(m_data[1])) - reinterpret_cast(&(m_data[0])); + setColArrayMode(skipSize, ms_fetchBatchSize); + + if (!bindCol(m_data[0].object_id)) return false; + if (!bindCol(m_data[0].min_damage)) return false; + if (!bindCol(m_data[0].max_damage)) return false; + if (!bindCol(m_data[0].damage_type)) return false; + if (!bindCol(m_data[0].elemental_type)) return false; + if (!bindCol(m_data[0].elemental_value)) return false; + if (!bindCol(m_data[0].attack_speed)) return false; + if (!bindCol(m_data[0].wound_chance)) return false; + if (!bindCol(m_data[0].accuracy)) return false; + if (!bindCol(m_data[0].attack_cost)) return false; + if (!bindCol(m_data[0].damage_radius)) return false; + if (!bindCol(m_data[0].min_range)) return false; + if (!bindCol(m_data[0].max_range)) return false; + return true; +} + +const std::vector & WeaponObjectQuerySelect::getData() const +{ + return m_data; +} + +void WeaponObjectQuerySelect::getSQL(std::string &sql) +{ + sql=std::string("begin :result := ")+m_schema+"loader.load_weapon_object; end;"; +} + +DB::Query::QueryMode WeaponObjectQuerySelect::getExecutionMode() const +{ + return MODE_PLSQL_REFCURSOR; +} //!!!END GENERATED QUERYDEFINITIONS diff --git a/game/server/application/SwgDatabaseServer/src/shared/generated/ObjectQueries_h.template b/game/server/application/SwgDatabaseServer/src/shared/generated/ObjectQueries_h.template index 60021931..327283d0 100644 --- a/game/server/application/SwgDatabaseServer/src/shared/generated/ObjectQueries_h.template +++ b/game/server/application/SwgDatabaseServer/src/shared/generated/ObjectQueries_h.template @@ -24,6 +24,1347 @@ namespace DBQuery { //!!!BEGIN GENERATED QUERYDECLARATIONS +class BattlefieldMarkerObjectQuery : public DatabaseProcessQuery +{ + BattlefieldMarkerObjectQuery(const BattlefieldMarkerObjectQuery&); + BattlefieldMarkerObjectQuery& operator= (const BattlefieldMarkerObjectQuery&); +public: + BattlefieldMarkerObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableVarrayString m_region_names; + DB::BindableLong m_numItems; +}; + +class BattlefieldMarkerObjectQuerySelect : public DB::Query +{ +public: + BattlefieldMarkerObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + BattlefieldMarkerObjectQuerySelect (const BattlefieldMarkerObjectQuerySelect&); + BattlefieldMarkerObjectQuerySelect& operator= (const BattlefieldMarkerObjectQuerySelect&); +}; + +class BuildingObjectQuery : public DatabaseProcessQuery +{ + BuildingObjectQuery(const BuildingObjectQuery&); + BuildingObjectQuery& operator= (const BuildingObjectQuery&); +public: + BuildingObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableVarrayNumber m_maintenance_costs; + DB::BindableVarrayNumber m_time_last_checkeds; + DB::BindableVarrayString m_is_publics; + DB::BindableVarrayNumber m_city_ids; + DB::BindableLong m_numItems; +}; + +class BuildingObjectQuerySelect : public DB::Query +{ +public: + BuildingObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + BuildingObjectQuerySelect (const BuildingObjectQuerySelect&); + BuildingObjectQuerySelect& operator= (const BuildingObjectQuerySelect&); +}; + +class CellObjectQuery : public DatabaseProcessQuery +{ + CellObjectQuery(const CellObjectQuery&); + CellObjectQuery& operator= (const CellObjectQuery&); +public: + CellObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableVarrayNumber m_cell_numbers; + DB::BindableVarrayString m_is_publics; + DB::BindableLong m_numItems; +}; + +class CellObjectQuerySelect : public DB::Query +{ +public: + CellObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + CellObjectQuerySelect (const CellObjectQuerySelect&); + CellObjectQuerySelect& operator= (const CellObjectQuerySelect&); +}; + +class CityObjectQuery : public DatabaseProcessQuery +{ + CityObjectQuery(const CityObjectQuery&); + CityObjectQuery& operator= (const CityObjectQuery&); +public: + CityObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableLong m_numItems; +}; + +class CityObjectQuerySelect : public DB::Query +{ +public: + CityObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + CityObjectQuerySelect (const CityObjectQuerySelect&); + CityObjectQuerySelect& operator= (const CityObjectQuerySelect&); +}; + +class CreatureObjectQuery : public DatabaseProcessQuery +{ + CreatureObjectQuery(const CreatureObjectQuery&); + CreatureObjectQuery& operator= (const CreatureObjectQuery&); +public: + CreatureObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableVarrayNumber m_scale_factors; + DB::BindableVarrayNumber m_statess; + DB::BindableVarrayNumber m_postures; + DB::BindableVarrayNumber m_shock_woundss; + DB::BindableVarrayString m_master_ids; + DB::BindableVarrayNumber m_ranks; + DB::BindableVarrayNumber m_base_walk_speeds; + DB::BindableVarrayNumber m_base_run_speeds; + DB::BindableVarrayNumber m_attribute_0s; + DB::BindableVarrayNumber m_attribute_1s; + DB::BindableVarrayNumber m_attribute_2s; + DB::BindableVarrayNumber m_attribute_3s; + DB::BindableVarrayNumber m_attribute_4s; + DB::BindableVarrayNumber m_attribute_5s; + DB::BindableVarrayNumber m_attribute_6s; + DB::BindableVarrayNumber m_attribute_7s; + DB::BindableVarrayNumber m_attribute_8s; + DB::BindableVarrayNumber m_attribute_9s; + DB::BindableVarrayNumber m_attribute_10s; + DB::BindableVarrayNumber m_attribute_11s; + DB::BindableVarrayNumber m_attribute_12s; + DB::BindableVarrayNumber m_attribute_13s; + DB::BindableVarrayNumber m_attribute_14s; + DB::BindableVarrayNumber m_attribute_15s; + DB::BindableVarrayNumber m_attribute_16s; + DB::BindableVarrayNumber m_attribute_17s; + DB::BindableVarrayNumber m_attribute_18s; + DB::BindableVarrayNumber m_attribute_19s; + DB::BindableVarrayNumber m_attribute_20s; + DB::BindableVarrayNumber m_attribute_21s; + DB::BindableVarrayNumber m_attribute_22s; + DB::BindableVarrayNumber m_attribute_23s; + DB::BindableVarrayNumber m_attribute_24s; + DB::BindableVarrayNumber m_attribute_25s; + DB::BindableVarrayNumber m_attribute_26s; + DB::BindableVarrayString m_persisted_buffss; + DB::BindableVarrayNumber m_ws_xs; + DB::BindableVarrayNumber m_ws_ys; + DB::BindableVarrayNumber m_ws_zs; + DB::BindableLong m_numItems; +}; + +class CreatureObjectQuerySelect : public DB::Query +{ +public: + CreatureObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + CreatureObjectQuerySelect (const CreatureObjectQuerySelect&); + CreatureObjectQuerySelect& operator= (const CreatureObjectQuerySelect&); +}; + +class FactoryObjectQuery : public DatabaseProcessQuery +{ + FactoryObjectQuery(const FactoryObjectQuery&); + FactoryObjectQuery& operator= (const FactoryObjectQuery&); +public: + FactoryObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableLong m_numItems; +}; + +class FactoryObjectQuerySelect : public DB::Query +{ +public: + FactoryObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + FactoryObjectQuerySelect (const FactoryObjectQuerySelect&); + FactoryObjectQuerySelect& operator= (const FactoryObjectQuerySelect&); +}; + +class GuildObjectQuery : public DatabaseProcessQuery +{ + GuildObjectQuery(const GuildObjectQuery&); + GuildObjectQuery& operator= (const GuildObjectQuery&); +public: + GuildObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableLong m_numItems; +}; + +class GuildObjectQuerySelect : public DB::Query +{ +public: + GuildObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + GuildObjectQuerySelect (const GuildObjectQuerySelect&); + GuildObjectQuerySelect& operator= (const GuildObjectQuerySelect&); +}; + +class HarvesterInstallationObjectQuery : public DatabaseProcessQuery +{ + HarvesterInstallationObjectQuery(const HarvesterInstallationObjectQuery&); + HarvesterInstallationObjectQuery& operator= (const HarvesterInstallationObjectQuery&); +public: + HarvesterInstallationObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableVarrayNumber m_installed_efficiencys; + DB::BindableVarrayNumber m_max_extraction_rates; + DB::BindableVarrayNumber m_current_extraction_rates; + DB::BindableVarrayNumber m_max_hopper_amounts; + DB::BindableVarrayString m_hopper_resources; + DB::BindableVarrayNumber m_hopper_amounts; + DB::BindableVarrayString m_resource_types; + DB::BindableLong m_numItems; +}; + +class HarvesterInstallationObjectQuerySelect : public DB::Query +{ +public: + HarvesterInstallationObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + HarvesterInstallationObjectQuerySelect (const HarvesterInstallationObjectQuerySelect&); + HarvesterInstallationObjectQuerySelect& operator= (const HarvesterInstallationObjectQuerySelect&); +}; + +class InstallationObjectQuery : public DatabaseProcessQuery +{ + InstallationObjectQuery(const InstallationObjectQuery&); + InstallationObjectQuery& operator= (const InstallationObjectQuery&); +public: + InstallationObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableVarrayNumber m_installation_types; + DB::BindableVarrayString m_activateds; + DB::BindableVarrayNumber m_tick_counts; + DB::BindableVarrayNumber m_activate_start_times; + DB::BindableVarrayNumber m_powers; + DB::BindableVarrayNumber m_power_rates; + DB::BindableLong m_numItems; +}; + +class InstallationObjectQuerySelect : public DB::Query +{ +public: + InstallationObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + InstallationObjectQuerySelect (const InstallationObjectQuerySelect&); + InstallationObjectQuerySelect& operator= (const InstallationObjectQuerySelect&); +}; + +class IntangibleObjectQuery : public DatabaseProcessQuery +{ + IntangibleObjectQuery(const IntangibleObjectQuery&); + IntangibleObjectQuery& operator= (const IntangibleObjectQuery&); +public: + IntangibleObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableVarrayNumber m_counts; + DB::BindableLong m_numItems; +}; + +class IntangibleObjectQuerySelect : public DB::Query +{ +public: + IntangibleObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + IntangibleObjectQuerySelect (const IntangibleObjectQuerySelect&); + IntangibleObjectQuerySelect& operator= (const IntangibleObjectQuerySelect&); +}; + +class ManufactureSchematicObjectQuery : public DatabaseProcessQuery +{ + ManufactureSchematicObjectQuery(const ManufactureSchematicObjectQuery&); + ManufactureSchematicObjectQuery& operator= (const ManufactureSchematicObjectQuery&); +public: + ManufactureSchematicObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableVarrayString m_creator_ids; + DB::BindableVarrayString m_creator_names; + DB::BindableVarrayNumber m_items_per_containers; + DB::BindableVarrayNumber m_manufacture_times; + DB::BindableVarrayNumber m_draft_schematics; + DB::BindableLong m_numItems; +}; + +class ManufactureSchematicObjectQuerySelect : public DB::Query +{ +public: + ManufactureSchematicObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + ManufactureSchematicObjectQuerySelect (const ManufactureSchematicObjectQuerySelect&); + ManufactureSchematicObjectQuerySelect& operator= (const ManufactureSchematicObjectQuerySelect&); +}; + +class ManufactureInstallationObjectQuery : public DatabaseProcessQuery +{ + ManufactureInstallationObjectQuery(const ManufactureInstallationObjectQuery&); + ManufactureInstallationObjectQuery& operator= (const ManufactureInstallationObjectQuery&); +public: + ManufactureInstallationObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableLong m_numItems; +}; + +class ManufactureInstallationObjectQuerySelect : public DB::Query +{ +public: + ManufactureInstallationObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + ManufactureInstallationObjectQuerySelect (const ManufactureInstallationObjectQuerySelect&); + ManufactureInstallationObjectQuerySelect& operator= (const ManufactureInstallationObjectQuerySelect&); +}; + +class MissionObjectQuery : public DatabaseProcessQuery +{ + MissionObjectQuery(const MissionObjectQuery&); + MissionObjectQuery& operator= (const MissionObjectQuery&); +public: + MissionObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableVarrayNumber m_difficultys; + DB::BindableVarrayNumber m_end_xs; + DB::BindableVarrayNumber m_end_ys; + DB::BindableVarrayNumber m_end_zs; + DB::BindableVarrayString m_end_cells; + DB::BindableVarrayNumber m_end_scenes; + DB::BindableVarrayString m_mission_creators; + DB::BindableVarrayNumber m_rewards; + DB::BindableVarrayString m_root_script_names; + DB::BindableVarrayNumber m_start_xs; + DB::BindableVarrayNumber m_start_ys; + DB::BindableVarrayNumber m_start_zs; + DB::BindableVarrayString m_start_cells; + DB::BindableVarrayNumber m_start_scenes; + DB::BindableVarrayString m_description_tables; + DB::BindableVarrayString m_description_texts; + DB::BindableVarrayString m_title_tables; + DB::BindableVarrayString m_title_texts; + DB::BindableVarrayString m_mission_holder_ids; + DB::BindableVarrayNumber m_statuss; + DB::BindableVarrayNumber m_mission_types; + DB::BindableVarrayNumber m_target_appearances; + DB::BindableVarrayString m_target_names; + DB::BindableLong m_numItems; +}; + +class MissionObjectQuerySelect : public DB::Query +{ +public: + MissionObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + MissionObjectQuerySelect (const MissionObjectQuerySelect&); + MissionObjectQuerySelect& operator= (const MissionObjectQuerySelect&); +}; + +class PlanetObjectQuery : public DatabaseProcessQuery +{ + PlanetObjectQuery(const PlanetObjectQuery&); + PlanetObjectQuery& operator= (const PlanetObjectQuery&); +public: + PlanetObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableVarrayString m_planet_names; + DB::BindableLong m_numItems; +}; + +class PlanetObjectQuerySelect : public DB::Query +{ +public: + PlanetObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + PlanetObjectQuerySelect (const PlanetObjectQuerySelect&); + PlanetObjectQuerySelect& operator= (const PlanetObjectQuerySelect&); +}; + +class PlayerObjectQuery : public DatabaseProcessQuery +{ + PlayerObjectQuery(const PlayerObjectQuery&); + PlayerObjectQuery& operator= (const PlayerObjectQuery&); +public: + PlayerObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableVarrayNumber m_station_ids; + DB::BindableVarrayString m_house_ids; + DB::BindableVarrayNumber m_account_num_lotss; + DB::BindableVarrayString m_account_is_outcasts; + DB::BindableVarrayNumber m_account_cheater_levels; + DB::BindableVarrayNumber m_account_max_lots_adjustments; + DB::BindableVarrayString m_personal_profile_ids; + DB::BindableVarrayString m_character_profile_ids; + DB::BindableVarrayString m_skill_titles; + DB::BindableVarrayNumber m_born_dates; + DB::BindableVarrayNumber m_played_times; + DB::BindableVarrayNumber m_force_regen_rates; + DB::BindableVarrayNumber m_force_powers; + DB::BindableVarrayNumber m_max_force_powers; + DB::BindableVarrayString m_active_questss; + DB::BindableVarrayString m_completed_questss; + DB::BindableVarrayNumber m_current_quests; + DB::BindableVarrayString m_questss; + DB::BindableVarrayNumber m_role_icon_choices; + DB::BindableVarrayString m_quests2s; + DB::BindableVarrayString m_quests3s; + DB::BindableVarrayString m_quests4s; + DB::BindableVarrayString m_skill_templates; + DB::BindableVarrayString m_working_skills; + DB::BindableVarrayNumber m_current_gcw_pointss; + DB::BindableVarrayNumber m_current_gcw_ratings; + DB::BindableVarrayNumber m_current_pvp_killss; + DB::BindableVarrayNumber m_lifetime_gcw_pointss; + DB::BindableVarrayNumber m_max_gcw_imperial_ratings; + DB::BindableVarrayNumber m_max_gcw_rebel_ratings; + DB::BindableVarrayNumber m_lifetime_pvp_killss; + DB::BindableVarrayNumber m_next_gcw_rating_calc_times; + DB::BindableVarrayString m_collectionss; + DB::BindableVarrayString m_show_backpacks; + DB::BindableVarrayString m_show_helmets; + DB::BindableVarrayString m_collections2s; + DB::BindableLong m_numItems; +}; + +class PlayerObjectQuerySelect : public DB::Query +{ +public: + PlayerObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + PlayerObjectQuerySelect (const PlayerObjectQuerySelect&); + PlayerObjectQuerySelect& operator= (const PlayerObjectQuerySelect&); +}; + +class PlayerQuestObjectQuery : public DatabaseProcessQuery +{ + PlayerQuestObjectQuery(const PlayerQuestObjectQuery&); + PlayerQuestObjectQuery& operator= (const PlayerQuestObjectQuery&); +public: + PlayerQuestObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableVarrayString m_titles; + DB::BindableVarrayString m_descriptions; + DB::BindableVarrayString m_creators; + DB::BindableVarrayNumber m_total_taskss; + DB::BindableVarrayNumber m_difficultys; + DB::BindableVarrayString m_task_title1s; + DB::BindableVarrayString m_task_description1s; + DB::BindableVarrayString m_task_title2s; + DB::BindableVarrayString m_task_description2s; + DB::BindableVarrayString m_task_title3s; + DB::BindableVarrayString m_task_description3s; + DB::BindableVarrayString m_task_title4s; + DB::BindableVarrayString m_task_description4s; + DB::BindableVarrayString m_task_title5s; + DB::BindableVarrayString m_task_description5s; + DB::BindableVarrayString m_task_title6s; + DB::BindableVarrayString m_task_description6s; + DB::BindableVarrayString m_task_title7s; + DB::BindableVarrayString m_task_description7s; + DB::BindableVarrayString m_task_title8s; + DB::BindableVarrayString m_task_description8s; + DB::BindableVarrayString m_task_title9s; + DB::BindableVarrayString m_task_description9s; + DB::BindableVarrayString m_task_title10s; + DB::BindableVarrayString m_task_description10s; + DB::BindableVarrayString m_task_title11s; + DB::BindableVarrayString m_task_description11s; + DB::BindableVarrayString m_task_title12s; + DB::BindableVarrayString m_task_description12s; + DB::BindableLong m_numItems; +}; + +class PlayerQuestObjectQuerySelect : public DB::Query +{ +public: + PlayerQuestObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + PlayerQuestObjectQuerySelect (const PlayerQuestObjectQuerySelect&); + PlayerQuestObjectQuerySelect& operator= (const PlayerQuestObjectQuerySelect&); +}; + +class ResourceContainerObjectQuery : public DatabaseProcessQuery +{ + ResourceContainerObjectQuery(const ResourceContainerObjectQuery&); + ResourceContainerObjectQuery& operator= (const ResourceContainerObjectQuery&); +public: + ResourceContainerObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableVarrayString m_resource_types; + DB::BindableVarrayNumber m_quantitys; + DB::BindableVarrayString m_sources; + DB::BindableLong m_numItems; +}; + +class ResourceContainerObjectQuerySelect : public DB::Query +{ +public: + ResourceContainerObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + ResourceContainerObjectQuerySelect (const ResourceContainerObjectQuerySelect&); + ResourceContainerObjectQuerySelect& operator= (const ResourceContainerObjectQuerySelect&); +}; + +class ShipObjectQuery : public DatabaseProcessQuery +{ + ShipObjectQuery(const ShipObjectQuery&); + ShipObjectQuery& operator= (const ShipObjectQuery&); +public: + ShipObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableVarrayNumber m_slide_dampeners; + DB::BindableVarrayNumber m_current_chassis_hit_pointss; + DB::BindableVarrayNumber m_maximum_chassis_hit_pointss; + DB::BindableVarrayNumber m_chassis_types; + DB::BindableVarrayString m_cmp_armor_hp_maximums; + DB::BindableVarrayString m_cmp_armor_hp_currents; + DB::BindableVarrayString m_cmp_efficiency_generals; + DB::BindableVarrayString m_cmp_efficiency_engs; + DB::BindableVarrayString m_cmp_eng_maintenances; + DB::BindableVarrayString m_cmp_masss; + DB::BindableVarrayString m_cmp_crcs; + DB::BindableVarrayString m_cmp_hp_currents; + DB::BindableVarrayString m_cmp_hp_maximums; + DB::BindableVarrayString m_cmp_flagss; + DB::BindableVarrayString m_cmp_namess; + DB::BindableVarrayString m_weapon_damage_maximums; + DB::BindableVarrayString m_weapon_damage_minimums; + DB::BindableVarrayString m_weapon_effectiveness_shieldss; + DB::BindableVarrayString m_weapon_effectiveness_armors; + DB::BindableVarrayString m_weapon_eng_per_shots; + DB::BindableVarrayString m_weapon_refire_rates; + DB::BindableVarrayString m_weapon_ammo_currents; + DB::BindableVarrayString m_weapon_ammo_maximums; + DB::BindableVarrayString m_weapon_ammo_types; + DB::BindableVarrayNumber m_shield_hp_front_maximums; + DB::BindableVarrayNumber m_shield_hp_back_maximums; + DB::BindableVarrayNumber m_shield_recharge_rates; + DB::BindableVarrayNumber m_capacitor_eng_maximums; + DB::BindableVarrayNumber m_capacitor_eng_recharge_rates; + DB::BindableVarrayNumber m_engine_acc_rates; + DB::BindableVarrayNumber m_engine_deceleration_rates; + DB::BindableVarrayNumber m_engine_pitch_acc_rates; + DB::BindableVarrayNumber m_engine_yaw_acc_rates; + DB::BindableVarrayNumber m_engine_roll_acc_rates; + DB::BindableVarrayNumber m_engine_pitch_rate_maximums; + DB::BindableVarrayNumber m_engine_yaw_rate_maximums; + DB::BindableVarrayNumber m_engine_roll_rate_maximums; + DB::BindableVarrayNumber m_engine_speed_maximums; + DB::BindableVarrayNumber m_reactor_eng_generation_rates; + DB::BindableVarrayNumber m_booster_eng_maximums; + DB::BindableVarrayNumber m_booster_eng_recharge_rates; + DB::BindableVarrayNumber m_booster_eng_consumption_rates; + DB::BindableVarrayNumber m_booster_accs; + DB::BindableVarrayNumber m_booster_speed_maximums; + DB::BindableVarrayNumber m_droid_if_cmd_speeds; + DB::BindableVarrayString m_installed_dcds; + DB::BindableVarrayNumber m_chassis_cmp_mass_maximums; + DB::BindableVarrayString m_cmp_creatorss; + DB::BindableVarrayNumber m_cargo_hold_contents_maximums; + DB::BindableVarrayNumber m_cargo_hold_contents_currents; + DB::BindableVarrayString m_cargo_hold_contentss; + DB::BindableLong m_numItems; +}; + +class ShipObjectQuerySelect : public DB::Query +{ +public: + ShipObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + ShipObjectQuerySelect (const ShipObjectQuerySelect&); + ShipObjectQuerySelect& operator= (const ShipObjectQuerySelect&); +}; + +class StaticObjectQuery : public DatabaseProcessQuery +{ + StaticObjectQuery(const StaticObjectQuery&); + StaticObjectQuery& operator= (const StaticObjectQuery&); +public: + StaticObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableLong m_numItems; +}; + +class StaticObjectQuerySelect : public DB::Query +{ +public: + StaticObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + StaticObjectQuerySelect (const StaticObjectQuerySelect&); + StaticObjectQuerySelect& operator= (const StaticObjectQuerySelect&); +}; + +class TangibleObjectQuery : public DatabaseProcessQuery +{ + TangibleObjectQuery(const TangibleObjectQuery&); + TangibleObjectQuery& operator= (const TangibleObjectQuery&); +public: + TangibleObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableVarrayNumber m_max_hit_pointss; + DB::BindableVarrayString m_owner_ids; + DB::BindableVarrayString m_visibles; + DB::BindableVarrayString m_appearance_datas; + DB::BindableVarrayNumber m_interest_radiuss; + DB::BindableVarrayNumber m_pvp_types; + DB::BindableVarrayNumber m_pvp_factions; + DB::BindableVarrayNumber m_damage_takens; + DB::BindableVarrayString m_custom_appearances; + DB::BindableVarrayNumber m_counts; + DB::BindableVarrayNumber m_conditions; + DB::BindableVarrayString m_creator_ids; + DB::BindableVarrayNumber m_source_draft_schematics; + DB::BindableLong m_numItems; +}; + +class TangibleObjectQuerySelect : public DB::Query +{ +public: + TangibleObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + TangibleObjectQuerySelect (const TangibleObjectQuerySelect&); + TangibleObjectQuerySelect& operator= (const TangibleObjectQuerySelect&); +}; + +class TokenObjectQuery : public DatabaseProcessQuery +{ + TokenObjectQuery(const TokenObjectQuery&); + TokenObjectQuery& operator= (const TokenObjectQuery&); +public: + TokenObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableVarrayString m_references; + DB::BindableVarrayString m_target_server_template_names; + DB::BindableVarrayString m_target_shared_template_names; + DB::BindableVarrayString m_waypoints; + DB::BindableLong m_numItems; +}; + +class TokenObjectQuerySelect : public DB::Query +{ +public: + TokenObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + TokenObjectQuerySelect (const TokenObjectQuerySelect&); + TokenObjectQuerySelect& operator= (const TokenObjectQuerySelect&); +}; + +class UniverseObjectQuery : public DatabaseProcessQuery +{ + UniverseObjectQuery(const UniverseObjectQuery&); + UniverseObjectQuery& operator= (const UniverseObjectQuery&); +public: + UniverseObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableLong m_numItems; +}; + +class UniverseObjectQuerySelect : public DB::Query +{ +public: + UniverseObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + UniverseObjectQuerySelect (const UniverseObjectQuerySelect&); + UniverseObjectQuerySelect& operator= (const UniverseObjectQuerySelect&); +}; + +class VehicleObjectQuery : public DatabaseProcessQuery +{ + VehicleObjectQuery(const VehicleObjectQuery&); + VehicleObjectQuery& operator= (const VehicleObjectQuery&); +public: + VehicleObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableVarrayNumber m_boguss; + DB::BindableLong m_numItems; +}; + +class VehicleObjectQuerySelect : public DB::Query +{ +public: + VehicleObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + VehicleObjectQuerySelect (const VehicleObjectQuerySelect&); + VehicleObjectQuerySelect& operator= (const VehicleObjectQuerySelect&); +}; + +class WeaponObjectQuery : public DatabaseProcessQuery +{ + WeaponObjectQuery(const WeaponObjectQuery&); + WeaponObjectQuery& operator= (const WeaponObjectQuery&); +public: + WeaponObjectQuery(); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL(std::string &sql); + + bool setupData(DB::Session *session); + bool addData(const DB::Row *_data); + void clearData(); + void freeData(); + + int getNumItems() const; + +private: + DB::BindableVarrayString m_object_ids; + DB::BindableVarrayNumber m_min_damages; + DB::BindableVarrayNumber m_max_damages; + DB::BindableVarrayNumber m_damage_types; + DB::BindableVarrayNumber m_elemental_types; + DB::BindableVarrayNumber m_elemental_values; + DB::BindableVarrayNumber m_attack_speeds; + DB::BindableVarrayNumber m_wound_chances; + DB::BindableVarrayNumber m_accuracys; + DB::BindableVarrayNumber m_attack_costs; + DB::BindableVarrayNumber m_damage_radiuss; + DB::BindableVarrayNumber m_min_ranges; + DB::BindableVarrayNumber m_max_ranges; + DB::BindableLong m_numItems; +}; + +class WeaponObjectQuerySelect : public DB::Query +{ +public: + WeaponObjectQuerySelect(const std::string &schema); + + virtual bool bindParameters (); + virtual bool bindColumns (); + virtual void getSQL (std::string &sql); + + const std::vector & getData() const; + +protected: + virtual QueryMode getExecutionMode() const; + +private: + + std::vector m_data; + const std::string m_schema; + + WeaponObjectQuerySelect (const WeaponObjectQuerySelect&); + WeaponObjectQuerySelect& operator= (const WeaponObjectQuerySelect&); +}; //!!!END GENERATED QUERYDECLARATIONS diff --git a/game/server/application/SwgDatabaseServer/src/shared/generated/Schema_h.template b/game/server/application/SwgDatabaseServer/src/shared/generated/Schema_h.template index 0be172b0..7297cfd7 100644 --- a/game/server/application/SwgDatabaseServer/src/shared/generated/Schema_h.template +++ b/game/server/application/SwgDatabaseServer/src/shared/generated/Schema_h.template @@ -252,6 +252,2876 @@ struct WaypointRow : public DB::Row }; //!!!BEGIN GENERATED DECLARATIONS +struct ArmorRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong layer; + DB::BindableLong effectiveness; + DB::BindableLong integrity; + DB::BindableString<1000> special_protections; + DB::BindableLong encumberance_0; + DB::BindableLong encumberance_1; + DB::BindableLong encumberance_2; + DB::BindableLong encumberance_3; + DB::BindableLong encumberance_4; + DB::BindableLong encumberance_5; + DB::BindableLong encumberance_6; + DB::BindableLong encumberance_7; + DB::BindableLong encumberance_8; + DB::BindableString<255> object_template; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct ArmorBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong layer; + DB::BindableLong effectiveness; + DB::BindableLong integrity; + DB::BufferString special_protections; + DB::BindableLong encumberance_0; + DB::BindableLong encumberance_1; + DB::BindableLong encumberance_2; + DB::BindableLong encumberance_3; + DB::BindableLong encumberance_4; + DB::BindableLong encumberance_5; + DB::BindableLong encumberance_6; + DB::BindableLong encumberance_7; + DB::BindableLong encumberance_8; + DB::BufferString object_template; + + ArmorBufferRow() : + object_id(), + layer(), + effectiveness(), + integrity(), + special_protections(1000), + encumberance_0(), + encumberance_1(), + encumberance_2(), + encumberance_3(), + encumberance_4(), + encumberance_5(), + encumberance_6(), + encumberance_7(), + encumberance_8(), + object_template(255) + { + } + + ArmorBufferRow(const ArmorRow & rhs) : + object_id(rhs.object_id), + layer(rhs.layer), + effectiveness(rhs.effectiveness), + integrity(rhs.integrity), + special_protections(rhs.special_protections), + encumberance_0(rhs.encumberance_0), + encumberance_1(rhs.encumberance_1), + encumberance_2(rhs.encumberance_2), + encumberance_3(rhs.encumberance_3), + encumberance_4(rhs.encumberance_4), + encumberance_5(rhs.encumberance_5), + encumberance_6(rhs.encumberance_6), + encumberance_7(rhs.encumberance_7), + encumberance_8(rhs.encumberance_8), + object_template(rhs.object_template) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct BattlefieldMarkerObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableString<500> region_name; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct BattlefieldMarkerObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BufferString region_name; + + BattlefieldMarkerObjectBufferRow() : + object_id(), + region_name(500) + { + } + + BattlefieldMarkerObjectBufferRow(const BattlefieldMarkerObjectRow & rhs) : + object_id(rhs.object_id), + region_name(rhs.region_name) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct BattlefieldParticipantRow : public DB::Row +{ + DB::BindableNetworkId region_object_id; + DB::BindableNetworkId character_object_id; + DB::BindableLong faction_id; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct BattlefieldParticipantBufferRow : public DB::Row +{ + DB::BindableNetworkId region_object_id; + DB::BindableNetworkId character_object_id; + DB::BindableLong faction_id; + + BattlefieldParticipantBufferRow() : + region_object_id(), + character_object_id(), + faction_id() + { + } + + BattlefieldParticipantBufferRow(const BattlefieldParticipantRow & rhs) : + region_object_id(rhs.region_object_id), + character_object_id(rhs.character_object_id), + faction_id(rhs.faction_id) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct BountyHunterTargetRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableNetworkId target_id; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct BountyHunterTargetBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableNetworkId target_id; + + BountyHunterTargetBufferRow() : + object_id(), + target_id() + { + } + + BountyHunterTargetBufferRow(const BountyHunterTargetRow & rhs) : + object_id(rhs.object_id), + target_id(rhs.target_id) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct BuildingObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong maintenance_cost; + DB::BindableDouble time_last_checked; + DB::BindableBool is_public; + DB::BindableLong city_id; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct BuildingObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong maintenance_cost; + DB::BindableDouble time_last_checked; + DB::BindableBool is_public; + DB::BindableLong city_id; + + BuildingObjectBufferRow() : + object_id(), + maintenance_cost(), + time_last_checked(), + is_public(), + city_id() + { + } + + BuildingObjectBufferRow(const BuildingObjectRow & rhs) : + object_id(rhs.object_id), + maintenance_cost(rhs.maintenance_cost), + time_last_checked(rhs.time_last_checked), + is_public(rhs.is_public), + city_id(rhs.city_id) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct CellObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong cell_number; + DB::BindableBool is_public; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct CellObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong cell_number; + DB::BindableBool is_public; + + CellObjectBufferRow() : + object_id(), + cell_number(), + is_public() + { + } + + CellObjectBufferRow(const CellObjectRow & rhs) : + object_id(rhs.object_id), + cell_number(rhs.cell_number), + is_public(rhs.is_public) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct CityObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct CityObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + + CityObjectBufferRow() : + object_id() + { + } + + CityObjectBufferRow(const CityObjectRow & rhs) : + object_id(rhs.object_id) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct ClockRow : public DB::Row +{ + DB::BindableLong last_save_time; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct ClockBufferRow : public DB::Row +{ + DB::BindableLong last_save_time; + + ClockBufferRow() : + last_save_time() + { + } + + ClockBufferRow(const ClockRow & rhs) : + last_save_time(rhs.last_save_time) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct CreatureObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableDouble scale_factor; + DB::BindableInt64 states; + DB::BindableLong posture; + DB::BindableLong shock_wounds; + DB::BindableNetworkId master_id; + DB::BindableLong rank; + DB::BindableDouble base_walk_speed; + DB::BindableDouble base_run_speed; + DB::BindableLong attribute_0; + DB::BindableLong attribute_1; + DB::BindableLong attribute_2; + DB::BindableLong attribute_3; + DB::BindableLong attribute_4; + DB::BindableLong attribute_5; + DB::BindableLong attribute_6; + DB::BindableLong attribute_7; + DB::BindableLong attribute_8; + DB::BindableLong attribute_9; + DB::BindableLong attribute_10; + DB::BindableLong attribute_11; + DB::BindableLong attribute_12; + DB::BindableLong attribute_13; + DB::BindableLong attribute_14; + DB::BindableLong attribute_15; + DB::BindableLong attribute_16; + DB::BindableLong attribute_17; + DB::BindableLong attribute_18; + DB::BindableLong attribute_19; + DB::BindableLong attribute_20; + DB::BindableLong attribute_21; + DB::BindableLong attribute_22; + DB::BindableLong attribute_23; + DB::BindableLong attribute_24; + DB::BindableLong attribute_25; + DB::BindableLong attribute_26; + DB::BindableString<1000> persisted_buffs; + DB::BindableDouble ws_x; + DB::BindableDouble ws_y; + DB::BindableDouble ws_z; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct CreatureObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableDouble scale_factor; + DB::BindableInt64 states; + DB::BindableLong posture; + DB::BindableLong shock_wounds; + DB::BindableNetworkId master_id; + DB::BindableLong rank; + DB::BindableDouble base_walk_speed; + DB::BindableDouble base_run_speed; + DB::BindableLong attribute_0; + DB::BindableLong attribute_1; + DB::BindableLong attribute_2; + DB::BindableLong attribute_3; + DB::BindableLong attribute_4; + DB::BindableLong attribute_5; + DB::BindableLong attribute_6; + DB::BindableLong attribute_7; + DB::BindableLong attribute_8; + DB::BindableLong attribute_9; + DB::BindableLong attribute_10; + DB::BindableLong attribute_11; + DB::BindableLong attribute_12; + DB::BindableLong attribute_13; + DB::BindableLong attribute_14; + DB::BindableLong attribute_15; + DB::BindableLong attribute_16; + DB::BindableLong attribute_17; + DB::BindableLong attribute_18; + DB::BindableLong attribute_19; + DB::BindableLong attribute_20; + DB::BindableLong attribute_21; + DB::BindableLong attribute_22; + DB::BindableLong attribute_23; + DB::BindableLong attribute_24; + DB::BindableLong attribute_25; + DB::BindableLong attribute_26; + DB::BufferString persisted_buffs; + DB::BindableDouble ws_x; + DB::BindableDouble ws_y; + DB::BindableDouble ws_z; + + CreatureObjectBufferRow() : + object_id(), + scale_factor(), + states(), + posture(), + shock_wounds(), + master_id(), + rank(), + base_walk_speed(), + base_run_speed(), + attribute_0(), + attribute_1(), + attribute_2(), + attribute_3(), + attribute_4(), + attribute_5(), + attribute_6(), + attribute_7(), + attribute_8(), + attribute_9(), + attribute_10(), + attribute_11(), + attribute_12(), + attribute_13(), + attribute_14(), + attribute_15(), + attribute_16(), + attribute_17(), + attribute_18(), + attribute_19(), + attribute_20(), + attribute_21(), + attribute_22(), + attribute_23(), + attribute_24(), + attribute_25(), + attribute_26(), + persisted_buffs(1000), + ws_x(), + ws_y(), + ws_z() + { + } + + CreatureObjectBufferRow(const CreatureObjectRow & rhs) : + object_id(rhs.object_id), + scale_factor(rhs.scale_factor), + states(rhs.states), + posture(rhs.posture), + shock_wounds(rhs.shock_wounds), + master_id(rhs.master_id), + rank(rhs.rank), + base_walk_speed(rhs.base_walk_speed), + base_run_speed(rhs.base_run_speed), + attribute_0(rhs.attribute_0), + attribute_1(rhs.attribute_1), + attribute_2(rhs.attribute_2), + attribute_3(rhs.attribute_3), + attribute_4(rhs.attribute_4), + attribute_5(rhs.attribute_5), + attribute_6(rhs.attribute_6), + attribute_7(rhs.attribute_7), + attribute_8(rhs.attribute_8), + attribute_9(rhs.attribute_9), + attribute_10(rhs.attribute_10), + attribute_11(rhs.attribute_11), + attribute_12(rhs.attribute_12), + attribute_13(rhs.attribute_13), + attribute_14(rhs.attribute_14), + attribute_15(rhs.attribute_15), + attribute_16(rhs.attribute_16), + attribute_17(rhs.attribute_17), + attribute_18(rhs.attribute_18), + attribute_19(rhs.attribute_19), + attribute_20(rhs.attribute_20), + attribute_21(rhs.attribute_21), + attribute_22(rhs.attribute_22), + attribute_23(rhs.attribute_23), + attribute_24(rhs.attribute_24), + attribute_25(rhs.attribute_25), + attribute_26(rhs.attribute_26), + persisted_buffs(rhs.persisted_buffs), + ws_x(rhs.ws_x), + ws_y(rhs.ws_y), + ws_z(rhs.ws_z) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct ExperiencePointRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableString<500> experience_type; + DB::BindableLong points; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct ExperiencePointBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BufferString experience_type; + DB::BindableLong points; + + ExperiencePointBufferRow() : + object_id(), + experience_type(500), + points() + { + } + + ExperiencePointBufferRow(const ExperiencePointRow & rhs) : + object_id(rhs.object_id), + experience_type(rhs.experience_type), + points(rhs.points) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct FactoryObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct FactoryObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + + FactoryObjectBufferRow() : + object_id() + { + } + + FactoryObjectBufferRow(const FactoryObjectRow & rhs) : + object_id(rhs.object_id) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct FreeObjectIdRow : public DB::Row +{ + DB::BindableLong start_id; + DB::BindableLong end_id; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct FreeObjectIdBufferRow : public DB::Row +{ + DB::BindableLong start_id; + DB::BindableLong end_id; + + FreeObjectIdBufferRow() : + start_id(), + end_id() + { + } + + FreeObjectIdBufferRow(const FreeObjectIdRow & rhs) : + start_id(rhs.start_id), + end_id(rhs.end_id) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct GuildObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct GuildObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + + GuildObjectBufferRow() : + object_id() + { + } + + GuildObjectBufferRow(const GuildObjectRow & rhs) : + object_id(rhs.object_id) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct HarvesterInstallationObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableDouble installed_efficiency; + DB::BindableLong max_extraction_rate; + DB::BindableDouble current_extraction_rate; + DB::BindableLong max_hopper_amount; + DB::BindableNetworkId hopper_resource; + DB::BindableDouble hopper_amount; + DB::BindableNetworkId resource_type; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct HarvesterInstallationObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableDouble installed_efficiency; + DB::BindableLong max_extraction_rate; + DB::BindableDouble current_extraction_rate; + DB::BindableLong max_hopper_amount; + DB::BindableNetworkId hopper_resource; + DB::BindableDouble hopper_amount; + DB::BindableNetworkId resource_type; + + HarvesterInstallationObjectBufferRow() : + object_id(), + installed_efficiency(), + max_extraction_rate(), + current_extraction_rate(), + max_hopper_amount(), + hopper_resource(), + hopper_amount(), + resource_type() + { + } + + HarvesterInstallationObjectBufferRow(const HarvesterInstallationObjectRow & rhs) : + object_id(rhs.object_id), + installed_efficiency(rhs.installed_efficiency), + max_extraction_rate(rhs.max_extraction_rate), + current_extraction_rate(rhs.current_extraction_rate), + max_hopper_amount(rhs.max_hopper_amount), + hopper_resource(rhs.hopper_resource), + hopper_amount(rhs.hopper_amount), + resource_type(rhs.resource_type) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct InstallationObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong installation_type; + DB::BindableBool activated; + DB::BindableDouble tick_count; + DB::BindableDouble activate_start_time; + DB::BindableDouble power; + DB::BindableDouble power_rate; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct InstallationObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong installation_type; + DB::BindableBool activated; + DB::BindableDouble tick_count; + DB::BindableDouble activate_start_time; + DB::BindableDouble power; + DB::BindableDouble power_rate; + + InstallationObjectBufferRow() : + object_id(), + installation_type(), + activated(), + tick_count(), + activate_start_time(), + power(), + power_rate() + { + } + + InstallationObjectBufferRow(const InstallationObjectRow & rhs) : + object_id(rhs.object_id), + installation_type(rhs.installation_type), + activated(rhs.activated), + tick_count(rhs.tick_count), + activate_start_time(rhs.activate_start_time), + power(rhs.power), + power_rate(rhs.power_rate) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct IntangibleObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong count; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct IntangibleObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong count; + + IntangibleObjectBufferRow() : + object_id(), + count() + { + } + + IntangibleObjectBufferRow(const IntangibleObjectRow & rhs) : + object_id(rhs.object_id), + count(rhs.count) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct LoadbeaconServerMapRow : public DB::Row +{ + DB::BindableString<255> object_template; + DB::BindableLong server_id; + DB::BindableLong secondary_server_id; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct LoadbeaconServerMapBufferRow : public DB::Row +{ + DB::BufferString object_template; + DB::BindableLong server_id; + DB::BindableLong secondary_server_id; + + LoadbeaconServerMapBufferRow() : + object_template(255), + server_id(), + secondary_server_id() + { + } + + LoadbeaconServerMapBufferRow(const LoadbeaconServerMapRow & rhs) : + object_template(rhs.object_template), + server_id(rhs.server_id), + secondary_server_id(rhs.secondary_server_id) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct ManufactureInstallationObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct ManufactureInstallationObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + + ManufactureInstallationObjectBufferRow() : + object_id() + { + } + + ManufactureInstallationObjectBufferRow(const ManufactureInstallationObjectRow & rhs) : + object_id(rhs.object_id) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct ManufactureSchematicObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableNetworkId creator_id; + DB::BindableString<127> creator_name; + DB::BindableLong items_per_container; + DB::BindableDouble manufacture_time; + DB::BindableLong draft_schematic; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct ManufactureSchematicObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableNetworkId creator_id; + DB::BufferString creator_name; + DB::BindableLong items_per_container; + DB::BindableDouble manufacture_time; + DB::BindableLong draft_schematic; + + ManufactureSchematicObjectBufferRow() : + object_id(), + creator_id(), + creator_name(127), + items_per_container(), + manufacture_time(), + draft_schematic() + { + } + + ManufactureSchematicObjectBufferRow(const ManufactureSchematicObjectRow & rhs) : + object_id(rhs.object_id), + creator_id(rhs.creator_id), + creator_name(rhs.creator_name), + items_per_container(rhs.items_per_container), + manufacture_time(rhs.manufacture_time), + draft_schematic(rhs.draft_schematic) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct MessageRow : public DB::Row +{ + DB::BindableNetworkId message_id; + DB::BindableNetworkId target; + DB::BindableString<50> method; + DB::BindableString<4000> data; + DB::BindableLong call_time; + DB::BindableBool guaranteed; + DB::BindableLong delivery_type; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + message_id.setValue(keyValue); + } +}; + +struct MessageBufferRow : public DB::Row +{ + DB::BindableNetworkId message_id; + DB::BindableNetworkId target; + DB::BufferString method; + DB::BufferString data; + DB::BindableLong call_time; + DB::BindableBool guaranteed; + DB::BindableLong delivery_type; + + MessageBufferRow() : + message_id(), + target(), + method(50), + data(4000), + call_time(), + guaranteed(), + delivery_type() + { + } + + MessageBufferRow(const MessageRow & rhs) : + message_id(rhs.message_id), + target(rhs.target), + method(rhs.method), + data(rhs.data), + call_time(rhs.call_time), + guaranteed(rhs.guaranteed), + delivery_type(rhs.delivery_type) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + message_id.setValue(keyValue); + } +}; + +struct MissionObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong difficulty; + DB::BindableDouble end_x; + DB::BindableDouble end_y; + DB::BindableDouble end_z; + DB::BindableNetworkId end_cell; + DB::BindableLong end_scene; + DB::BindableString<127> mission_creator; + DB::BindableLong reward; + DB::BindableString<100> root_script_name; + DB::BindableDouble start_x; + DB::BindableDouble start_y; + DB::BindableDouble start_z; + DB::BindableNetworkId start_cell; + DB::BindableLong start_scene; + DB::BindableString<100> description_table; + DB::BindableString<100> description_text; + DB::BindableString<100> title_table; + DB::BindableString<100> title_text; + DB::BindableNetworkId mission_holder_id; + DB::BindableLong status; + DB::BindableLong mission_type; + DB::BindableLong target_appearance; + DB::BindableString<127> target_name; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct MissionObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong difficulty; + DB::BindableDouble end_x; + DB::BindableDouble end_y; + DB::BindableDouble end_z; + DB::BindableNetworkId end_cell; + DB::BindableLong end_scene; + DB::BufferString mission_creator; + DB::BindableLong reward; + DB::BufferString root_script_name; + DB::BindableDouble start_x; + DB::BindableDouble start_y; + DB::BindableDouble start_z; + DB::BindableNetworkId start_cell; + DB::BindableLong start_scene; + DB::BufferString description_table; + DB::BufferString description_text; + DB::BufferString title_table; + DB::BufferString title_text; + DB::BindableNetworkId mission_holder_id; + DB::BindableLong status; + DB::BindableLong mission_type; + DB::BindableLong target_appearance; + DB::BufferString target_name; + + MissionObjectBufferRow() : + object_id(), + difficulty(), + end_x(), + end_y(), + end_z(), + end_cell(), + end_scene(), + mission_creator(127), + reward(), + root_script_name(100), + start_x(), + start_y(), + start_z(), + start_cell(), + start_scene(), + description_table(100), + description_text(100), + title_table(100), + title_text(100), + mission_holder_id(), + status(), + mission_type(), + target_appearance(), + target_name(127) + { + } + + MissionObjectBufferRow(const MissionObjectRow & rhs) : + object_id(rhs.object_id), + difficulty(rhs.difficulty), + end_x(rhs.end_x), + end_y(rhs.end_y), + end_z(rhs.end_z), + end_cell(rhs.end_cell), + end_scene(rhs.end_scene), + mission_creator(rhs.mission_creator), + reward(rhs.reward), + root_script_name(rhs.root_script_name), + start_x(rhs.start_x), + start_y(rhs.start_y), + start_z(rhs.start_z), + start_cell(rhs.start_cell), + start_scene(rhs.start_scene), + description_table(rhs.description_table), + description_text(rhs.description_text), + title_table(rhs.title_table), + title_text(rhs.title_text), + mission_holder_id(rhs.mission_holder_id), + status(rhs.status), + mission_type(rhs.mission_type), + target_appearance(rhs.target_appearance), + target_name(rhs.target_name) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct ObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableDouble x; + DB::BindableDouble y; + DB::BindableDouble z; + DB::BindableDouble quaternion_w; + DB::BindableDouble quaternion_x; + DB::BindableDouble quaternion_y; + DB::BindableDouble quaternion_z; + DB::BindableLong node_x; + DB::BindableLong node_y; + DB::BindableLong node_z; + DB::BindableLong type_id; + DB::BindableString<50> scene_id; + DB::BindableLong controller_type; + DB::BindableLong deleted; + DB::BindableString<127> object_name; + DB::BindableLong volume; + DB::BindableNetworkId contained_by; + DB::BindableLong slot_arrangement; + DB::BindableBool player_controlled; + DB::BindableLong cache_version; + DB::BindableBool load_contents; + DB::BindableLong cash_balance; + DB::BindableLong bank_balance; + DB::BindableDouble complexity; + DB::BindableString<500> name_string_table; + DB::BindableString<500> name_string_text; + DB::BindableLong object_template_id; + DB::BindableString<128> static_item_name; + DB::BindableLong static_item_version; + DB::BindableLong conversion_id; + DB::BindableNetworkId load_with; + DB::BindableString<50> objvar_0_name; + DB::BindableLong objvar_0_type; + DB::BindableString<50> objvar_0_value; + DB::BindableString<50> objvar_1_name; + DB::BindableLong objvar_1_type; + DB::BindableString<50> objvar_1_value; + DB::BindableString<50> objvar_2_name; + DB::BindableLong objvar_2_type; + DB::BindableString<50> objvar_2_value; + DB::BindableString<50> objvar_3_name; + DB::BindableLong objvar_3_type; + DB::BindableString<50> objvar_3_value; + DB::BindableString<50> objvar_4_name; + DB::BindableLong objvar_4_type; + DB::BindableString<50> objvar_4_value; + DB::BindableString<50> objvar_5_name; + DB::BindableLong objvar_5_type; + DB::BindableString<50> objvar_5_value; + DB::BindableString<50> objvar_6_name; + DB::BindableLong objvar_6_type; + DB::BindableString<50> objvar_6_value; + DB::BindableString<50> objvar_7_name; + DB::BindableLong objvar_7_type; + DB::BindableString<50> objvar_7_value; + DB::BindableString<50> objvar_8_name; + DB::BindableLong objvar_8_type; + DB::BindableString<50> objvar_8_value; + DB::BindableString<50> objvar_9_name; + DB::BindableLong objvar_9_type; + DB::BindableString<50> objvar_9_value; + DB::BindableString<50> objvar_10_name; + DB::BindableLong objvar_10_type; + DB::BindableString<50> objvar_10_value; + DB::BindableString<50> objvar_11_name; + DB::BindableLong objvar_11_type; + DB::BindableString<50> objvar_11_value; + DB::BindableString<50> objvar_12_name; + DB::BindableLong objvar_12_type; + DB::BindableString<50> objvar_12_value; + DB::BindableString<50> objvar_13_name; + DB::BindableLong objvar_13_type; + DB::BindableString<50> objvar_13_value; + DB::BindableString<50> objvar_14_name; + DB::BindableLong objvar_14_type; + DB::BindableString<50> objvar_14_value; + DB::BindableString<50> objvar_15_name; + DB::BindableLong objvar_15_type; + DB::BindableString<50> objvar_15_value; + DB::BindableString<50> objvar_16_name; + DB::BindableLong objvar_16_type; + DB::BindableString<50> objvar_16_value; + DB::BindableString<50> objvar_17_name; + DB::BindableLong objvar_17_type; + DB::BindableString<50> objvar_17_value; + DB::BindableString<50> objvar_18_name; + DB::BindableLong objvar_18_type; + DB::BindableString<50> objvar_18_value; + DB::BindableString<50> objvar_19_name; + DB::BindableLong objvar_19_type; + DB::BindableString<50> objvar_19_value; + DB::BindableString<2000> script_list; + + DB::BindableLong container_level; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct ObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableDouble x; + DB::BindableDouble y; + DB::BindableDouble z; + DB::BindableDouble quaternion_w; + DB::BindableDouble quaternion_x; + DB::BindableDouble quaternion_y; + DB::BindableDouble quaternion_z; + DB::BindableLong node_x; + DB::BindableLong node_y; + DB::BindableLong node_z; + DB::BindableLong type_id; + DB::BufferString scene_id; + DB::BindableLong controller_type; + DB::BindableLong deleted; + DB::BufferString object_name; + DB::BindableLong volume; + DB::BindableNetworkId contained_by; + DB::BindableLong slot_arrangement; + DB::BindableBool player_controlled; + DB::BindableLong cache_version; + DB::BindableBool load_contents; + DB::BindableLong cash_balance; + DB::BindableLong bank_balance; + DB::BindableDouble complexity; + DB::BufferString name_string_table; + DB::BufferString name_string_text; + DB::BindableLong object_template_id; + DB::BufferString static_item_name; + DB::BindableLong static_item_version; + DB::BindableLong conversion_id; + DB::BindableNetworkId load_with; + DB::BufferString objvar_0_name; + DB::BindableLong objvar_0_type; + DB::BufferString objvar_0_value; + DB::BufferString objvar_1_name; + DB::BindableLong objvar_1_type; + DB::BufferString objvar_1_value; + DB::BufferString objvar_2_name; + DB::BindableLong objvar_2_type; + DB::BufferString objvar_2_value; + DB::BufferString objvar_3_name; + DB::BindableLong objvar_3_type; + DB::BufferString objvar_3_value; + DB::BufferString objvar_4_name; + DB::BindableLong objvar_4_type; + DB::BufferString objvar_4_value; + DB::BufferString objvar_5_name; + DB::BindableLong objvar_5_type; + DB::BufferString objvar_5_value; + DB::BufferString objvar_6_name; + DB::BindableLong objvar_6_type; + DB::BufferString objvar_6_value; + DB::BufferString objvar_7_name; + DB::BindableLong objvar_7_type; + DB::BufferString objvar_7_value; + DB::BufferString objvar_8_name; + DB::BindableLong objvar_8_type; + DB::BufferString objvar_8_value; + DB::BufferString objvar_9_name; + DB::BindableLong objvar_9_type; + DB::BufferString objvar_9_value; + DB::BufferString objvar_10_name; + DB::BindableLong objvar_10_type; + DB::BufferString objvar_10_value; + DB::BufferString objvar_11_name; + DB::BindableLong objvar_11_type; + DB::BufferString objvar_11_value; + DB::BufferString objvar_12_name; + DB::BindableLong objvar_12_type; + DB::BufferString objvar_12_value; + DB::BufferString objvar_13_name; + DB::BindableLong objvar_13_type; + DB::BufferString objvar_13_value; + DB::BufferString objvar_14_name; + DB::BindableLong objvar_14_type; + DB::BufferString objvar_14_value; + DB::BufferString objvar_15_name; + DB::BindableLong objvar_15_type; + DB::BufferString objvar_15_value; + DB::BufferString objvar_16_name; + DB::BindableLong objvar_16_type; + DB::BufferString objvar_16_value; + DB::BufferString objvar_17_name; + DB::BindableLong objvar_17_type; + DB::BufferString objvar_17_value; + DB::BufferString objvar_18_name; + DB::BindableLong objvar_18_type; + DB::BufferString objvar_18_value; + DB::BufferString objvar_19_name; + DB::BindableLong objvar_19_type; + DB::BufferString objvar_19_value; + DB::BufferString script_list; + + ObjectBufferRow() : + object_id(), + x(), + y(), + z(), + quaternion_w(), + quaternion_x(), + quaternion_y(), + quaternion_z(), + node_x(), + node_y(), + node_z(), + type_id(), + scene_id(50), + controller_type(), + deleted(), + object_name(127), + volume(), + contained_by(), + slot_arrangement(), + player_controlled(), + cache_version(), + load_contents(), + cash_balance(), + bank_balance(), + complexity(), + name_string_table(500), + name_string_text(500), + object_template_id(), + static_item_name(128), + static_item_version(), + conversion_id(), + load_with(), + objvar_0_name(50), + objvar_0_type(), + objvar_0_value(50), + objvar_1_name(50), + objvar_1_type(), + objvar_1_value(50), + objvar_2_name(50), + objvar_2_type(), + objvar_2_value(50), + objvar_3_name(50), + objvar_3_type(), + objvar_3_value(50), + objvar_4_name(50), + objvar_4_type(), + objvar_4_value(50), + objvar_5_name(50), + objvar_5_type(), + objvar_5_value(50), + objvar_6_name(50), + objvar_6_type(), + objvar_6_value(50), + objvar_7_name(50), + objvar_7_type(), + objvar_7_value(50), + objvar_8_name(50), + objvar_8_type(), + objvar_8_value(50), + objvar_9_name(50), + objvar_9_type(), + objvar_9_value(50), + objvar_10_name(50), + objvar_10_type(), + objvar_10_value(50), + objvar_11_name(50), + objvar_11_type(), + objvar_11_value(50), + objvar_12_name(50), + objvar_12_type(), + objvar_12_value(50), + objvar_13_name(50), + objvar_13_type(), + objvar_13_value(50), + objvar_14_name(50), + objvar_14_type(), + objvar_14_value(50), + objvar_15_name(50), + objvar_15_type(), + objvar_15_value(50), + objvar_16_name(50), + objvar_16_type(), + objvar_16_value(50), + objvar_17_name(50), + objvar_17_type(), + objvar_17_value(50), + objvar_18_name(50), + objvar_18_type(), + objvar_18_value(50), + objvar_19_name(50), + objvar_19_type(), + objvar_19_value(50), + script_list(2000) + { + } + + ObjectBufferRow(const ObjectRow & rhs) : + object_id(rhs.object_id), + x(rhs.x), + y(rhs.y), + z(rhs.z), + quaternion_w(rhs.quaternion_w), + quaternion_x(rhs.quaternion_x), + quaternion_y(rhs.quaternion_y), + quaternion_z(rhs.quaternion_z), + node_x(rhs.node_x), + node_y(rhs.node_y), + node_z(rhs.node_z), + type_id(rhs.type_id), + scene_id(rhs.scene_id), + controller_type(rhs.controller_type), + deleted(rhs.deleted), + object_name(rhs.object_name), + volume(rhs.volume), + contained_by(rhs.contained_by), + slot_arrangement(rhs.slot_arrangement), + player_controlled(rhs.player_controlled), + cache_version(rhs.cache_version), + load_contents(rhs.load_contents), + cash_balance(rhs.cash_balance), + bank_balance(rhs.bank_balance), + complexity(rhs.complexity), + name_string_table(rhs.name_string_table), + name_string_text(rhs.name_string_text), + object_template_id(rhs.object_template_id), + static_item_name(rhs.static_item_name), + static_item_version(rhs.static_item_version), + conversion_id(rhs.conversion_id), + load_with(rhs.load_with), + objvar_0_name(rhs.objvar_0_name), + objvar_0_type(rhs.objvar_0_type), + objvar_0_value(rhs.objvar_0_value), + objvar_1_name(rhs.objvar_1_name), + objvar_1_type(rhs.objvar_1_type), + objvar_1_value(rhs.objvar_1_value), + objvar_2_name(rhs.objvar_2_name), + objvar_2_type(rhs.objvar_2_type), + objvar_2_value(rhs.objvar_2_value), + objvar_3_name(rhs.objvar_3_name), + objvar_3_type(rhs.objvar_3_type), + objvar_3_value(rhs.objvar_3_value), + objvar_4_name(rhs.objvar_4_name), + objvar_4_type(rhs.objvar_4_type), + objvar_4_value(rhs.objvar_4_value), + objvar_5_name(rhs.objvar_5_name), + objvar_5_type(rhs.objvar_5_type), + objvar_5_value(rhs.objvar_5_value), + objvar_6_name(rhs.objvar_6_name), + objvar_6_type(rhs.objvar_6_type), + objvar_6_value(rhs.objvar_6_value), + objvar_7_name(rhs.objvar_7_name), + objvar_7_type(rhs.objvar_7_type), + objvar_7_value(rhs.objvar_7_value), + objvar_8_name(rhs.objvar_8_name), + objvar_8_type(rhs.objvar_8_type), + objvar_8_value(rhs.objvar_8_value), + objvar_9_name(rhs.objvar_9_name), + objvar_9_type(rhs.objvar_9_type), + objvar_9_value(rhs.objvar_9_value), + objvar_10_name(rhs.objvar_10_name), + objvar_10_type(rhs.objvar_10_type), + objvar_10_value(rhs.objvar_10_value), + objvar_11_name(rhs.objvar_11_name), + objvar_11_type(rhs.objvar_11_type), + objvar_11_value(rhs.objvar_11_value), + objvar_12_name(rhs.objvar_12_name), + objvar_12_type(rhs.objvar_12_type), + objvar_12_value(rhs.objvar_12_value), + objvar_13_name(rhs.objvar_13_name), + objvar_13_type(rhs.objvar_13_type), + objvar_13_value(rhs.objvar_13_value), + objvar_14_name(rhs.objvar_14_name), + objvar_14_type(rhs.objvar_14_type), + objvar_14_value(rhs.objvar_14_value), + objvar_15_name(rhs.objvar_15_name), + objvar_15_type(rhs.objvar_15_type), + objvar_15_value(rhs.objvar_15_value), + objvar_16_name(rhs.objvar_16_name), + objvar_16_type(rhs.objvar_16_type), + objvar_16_value(rhs.objvar_16_value), + objvar_17_name(rhs.objvar_17_name), + objvar_17_type(rhs.objvar_17_type), + objvar_17_value(rhs.objvar_17_value), + objvar_18_name(rhs.objvar_18_name), + objvar_18_type(rhs.objvar_18_type), + objvar_18_value(rhs.objvar_18_value), + objvar_19_name(rhs.objvar_19_name), + objvar_19_type(rhs.objvar_19_type), + objvar_19_value(rhs.objvar_19_value), + script_list(rhs.script_list) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct PlanetObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableString<100> planet_name; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct PlanetObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BufferString planet_name; + + PlanetObjectBufferRow() : + object_id(), + planet_name(100) + { + } + + PlanetObjectBufferRow(const PlanetObjectRow & rhs) : + object_id(rhs.object_id), + planet_name(rhs.planet_name) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct PlayerQuestObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableString<256> title; + DB::BindableString<4000> description; + DB::BindableNetworkId creator; + DB::BindableLong total_tasks; + DB::BindableLong difficulty; + DB::BindableString<128> task_title1; + DB::BindableString<4000> task_description1; + DB::BindableString<128> task_title2; + DB::BindableString<4000> task_description2; + DB::BindableString<128> task_title3; + DB::BindableString<4000> task_description3; + DB::BindableString<128> task_title4; + DB::BindableString<4000> task_description4; + DB::BindableString<128> task_title5; + DB::BindableString<4000> task_description5; + DB::BindableString<128> task_title6; + DB::BindableString<4000> task_description6; + DB::BindableString<128> task_title7; + DB::BindableString<4000> task_description7; + DB::BindableString<128> task_title8; + DB::BindableString<4000> task_description8; + DB::BindableString<128> task_title9; + DB::BindableString<4000> task_description9; + DB::BindableString<128> task_title10; + DB::BindableString<4000> task_description10; + DB::BindableString<128> task_title11; + DB::BindableString<4000> task_description11; + DB::BindableString<128> task_title12; + DB::BindableString<4000> task_description12; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct PlayerQuestObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BufferString title; + DB::BufferString description; + DB::BindableNetworkId creator; + DB::BindableLong total_tasks; + DB::BindableLong difficulty; + DB::BufferString task_title1; + DB::BufferString task_description1; + DB::BufferString task_title2; + DB::BufferString task_description2; + DB::BufferString task_title3; + DB::BufferString task_description3; + DB::BufferString task_title4; + DB::BufferString task_description4; + DB::BufferString task_title5; + DB::BufferString task_description5; + DB::BufferString task_title6; + DB::BufferString task_description6; + DB::BufferString task_title7; + DB::BufferString task_description7; + DB::BufferString task_title8; + DB::BufferString task_description8; + DB::BufferString task_title9; + DB::BufferString task_description9; + DB::BufferString task_title10; + DB::BufferString task_description10; + DB::BufferString task_title11; + DB::BufferString task_description11; + DB::BufferString task_title12; + DB::BufferString task_description12; + + PlayerQuestObjectBufferRow() : + object_id(), + title(256), + description(4000), + creator(), + total_tasks(), + difficulty(), + task_title1(128), + task_description1(4000), + task_title2(128), + task_description2(4000), + task_title3(128), + task_description3(4000), + task_title4(128), + task_description4(4000), + task_title5(128), + task_description5(4000), + task_title6(128), + task_description6(4000), + task_title7(128), + task_description7(4000), + task_title8(128), + task_description8(4000), + task_title9(128), + task_description9(4000), + task_title10(128), + task_description10(4000), + task_title11(128), + task_description11(4000), + task_title12(128), + task_description12(4000) + { + } + + PlayerQuestObjectBufferRow(const PlayerQuestObjectRow & rhs) : + object_id(rhs.object_id), + title(rhs.title), + description(rhs.description), + creator(rhs.creator), + total_tasks(rhs.total_tasks), + difficulty(rhs.difficulty), + task_title1(rhs.task_title1), + task_description1(rhs.task_description1), + task_title2(rhs.task_title2), + task_description2(rhs.task_description2), + task_title3(rhs.task_title3), + task_description3(rhs.task_description3), + task_title4(rhs.task_title4), + task_description4(rhs.task_description4), + task_title5(rhs.task_title5), + task_description5(rhs.task_description5), + task_title6(rhs.task_title6), + task_description6(rhs.task_description6), + task_title7(rhs.task_title7), + task_description7(rhs.task_description7), + task_title8(rhs.task_title8), + task_description8(rhs.task_description8), + task_title9(rhs.task_title9), + task_description9(rhs.task_description9), + task_title10(rhs.task_title10), + task_description10(rhs.task_description10), + task_title11(rhs.task_title11), + task_description11(rhs.task_description11), + task_title12(rhs.task_title12), + task_description12(rhs.task_description12) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct PropertyListRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong list_id; + DB::BindableString<500> value; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct PropertyListBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong list_id; + DB::BufferString value; + + PropertyListBufferRow() : + object_id(), + list_id(), + value(500) + { + } + + PropertyListBufferRow(const PropertyListRow & rhs) : + object_id(rhs.object_id), + list_id(rhs.list_id), + value(rhs.value) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct ResourceContainerObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableNetworkId resource_type; + DB::BindableLong quantity; + DB::BindableNetworkId source; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct ResourceContainerObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableNetworkId resource_type; + DB::BindableLong quantity; + DB::BindableNetworkId source; + + ResourceContainerObjectBufferRow() : + object_id(), + resource_type(), + quantity(), + source() + { + } + + ResourceContainerObjectBufferRow(const ResourceContainerObjectRow & rhs) : + object_id(rhs.object_id), + resource_type(rhs.resource_type), + quantity(rhs.quantity), + source(rhs.source) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct ResourceTypeRow : public DB::Row +{ + DB::BindableNetworkId resource_id; + DB::BindableString<100> resource_name; + DB::BindableString<100> resource_class; + DB::BindableString<1024> attributes; + DB::BindableString<1024> fractal_seeds; + DB::BindableLong depleted_timestamp; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct ResourceTypeBufferRow : public DB::Row +{ + DB::BindableNetworkId resource_id; + DB::BufferString resource_name; + DB::BufferString resource_class; + DB::BufferString attributes; + DB::BufferString fractal_seeds; + DB::BindableLong depleted_timestamp; + + ResourceTypeBufferRow() : + resource_id(), + resource_name(100), + resource_class(100), + attributes(1024), + fractal_seeds(1024), + depleted_timestamp() + { + } + + ResourceTypeBufferRow(const ResourceTypeRow & rhs) : + resource_id(rhs.resource_id), + resource_name(rhs.resource_name), + resource_class(rhs.resource_class), + attributes(rhs.attributes), + fractal_seeds(rhs.fractal_seeds), + depleted_timestamp(rhs.depleted_timestamp) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct ScriptRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong sequence_no; + DB::BindableString<100> script; + DB::BindableLong detached; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct ScriptBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong sequence_no; + DB::BufferString script; + DB::BindableLong detached; + + ScriptBufferRow() : + object_id(), + sequence_no(), + script(100), + detached() + { + } + + ScriptBufferRow(const ScriptRow & rhs) : + object_id(rhs.object_id), + sequence_no(rhs.sequence_no), + script(rhs.script), + detached(rhs.detached) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } +}; + +struct ShipObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableDouble slide_dampener; + DB::BindableDouble current_chassis_hit_points; + DB::BindableDouble maximum_chassis_hit_points; + DB::BindableLong chassis_type; + DB::BindableString<400> cmp_armor_hp_maximum; + DB::BindableString<400> cmp_armor_hp_current; + DB::BindableString<400> cmp_efficiency_general; + DB::BindableString<400> cmp_efficiency_eng; + DB::BindableString<400> cmp_eng_maintenance; + DB::BindableString<400> cmp_mass; + DB::BindableString<500> cmp_crc; + DB::BindableString<400> cmp_hp_current; + DB::BindableString<400> cmp_hp_maximum; + DB::BindableString<400> cmp_flags; + DB::BindableString<4000> cmp_names; + DB::BindableString<400> weapon_damage_maximum; + DB::BindableString<400> weapon_damage_minimum; + DB::BindableString<400> weapon_effectiveness_shields; + DB::BindableString<400> weapon_effectiveness_armor; + DB::BindableString<400> weapon_eng_per_shot; + DB::BindableString<400> weapon_refire_rate; + DB::BindableString<400> weapon_ammo_current; + DB::BindableString<400> weapon_ammo_maximum; + DB::BindableString<400> weapon_ammo_type; + DB::BindableDouble shield_hp_front_maximum; + DB::BindableDouble shield_hp_back_maximum; + DB::BindableDouble shield_recharge_rate; + DB::BindableDouble capacitor_eng_maximum; + DB::BindableDouble capacitor_eng_recharge_rate; + DB::BindableDouble engine_acc_rate; + DB::BindableDouble engine_deceleration_rate; + DB::BindableDouble engine_pitch_acc_rate; + DB::BindableDouble engine_yaw_acc_rate; + DB::BindableDouble engine_roll_acc_rate; + DB::BindableDouble engine_pitch_rate_maximum; + DB::BindableDouble engine_yaw_rate_maximum; + DB::BindableDouble engine_roll_rate_maximum; + DB::BindableDouble engine_speed_maximum; + DB::BindableDouble reactor_eng_generation_rate; + DB::BindableDouble booster_eng_maximum; + DB::BindableDouble booster_eng_recharge_rate; + DB::BindableDouble booster_eng_consumption_rate; + DB::BindableDouble booster_acc; + DB::BindableDouble booster_speed_maximum; + DB::BindableDouble droid_if_cmd_speed; + DB::BindableNetworkId installed_dcd; + DB::BindableDouble chassis_cmp_mass_maximum; + DB::BindableString<400> cmp_creators; + DB::BindableLong cargo_hold_contents_maximum; + DB::BindableLong cargo_hold_contents_current; + DB::BindableString<500> cargo_hold_contents; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct ShipObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableDouble slide_dampener; + DB::BindableDouble current_chassis_hit_points; + DB::BindableDouble maximum_chassis_hit_points; + DB::BindableLong chassis_type; + DB::BufferString cmp_armor_hp_maximum; + DB::BufferString cmp_armor_hp_current; + DB::BufferString cmp_efficiency_general; + DB::BufferString cmp_efficiency_eng; + DB::BufferString cmp_eng_maintenance; + DB::BufferString cmp_mass; + DB::BufferString cmp_crc; + DB::BufferString cmp_hp_current; + DB::BufferString cmp_hp_maximum; + DB::BufferString cmp_flags; + DB::BufferString cmp_names; + DB::BufferString weapon_damage_maximum; + DB::BufferString weapon_damage_minimum; + DB::BufferString weapon_effectiveness_shields; + DB::BufferString weapon_effectiveness_armor; + DB::BufferString weapon_eng_per_shot; + DB::BufferString weapon_refire_rate; + DB::BufferString weapon_ammo_current; + DB::BufferString weapon_ammo_maximum; + DB::BufferString weapon_ammo_type; + DB::BindableDouble shield_hp_front_maximum; + DB::BindableDouble shield_hp_back_maximum; + DB::BindableDouble shield_recharge_rate; + DB::BindableDouble capacitor_eng_maximum; + DB::BindableDouble capacitor_eng_recharge_rate; + DB::BindableDouble engine_acc_rate; + DB::BindableDouble engine_deceleration_rate; + DB::BindableDouble engine_pitch_acc_rate; + DB::BindableDouble engine_yaw_acc_rate; + DB::BindableDouble engine_roll_acc_rate; + DB::BindableDouble engine_pitch_rate_maximum; + DB::BindableDouble engine_yaw_rate_maximum; + DB::BindableDouble engine_roll_rate_maximum; + DB::BindableDouble engine_speed_maximum; + DB::BindableDouble reactor_eng_generation_rate; + DB::BindableDouble booster_eng_maximum; + DB::BindableDouble booster_eng_recharge_rate; + DB::BindableDouble booster_eng_consumption_rate; + DB::BindableDouble booster_acc; + DB::BindableDouble booster_speed_maximum; + DB::BindableDouble droid_if_cmd_speed; + DB::BindableNetworkId installed_dcd; + DB::BindableDouble chassis_cmp_mass_maximum; + DB::BufferString cmp_creators; + DB::BindableLong cargo_hold_contents_maximum; + DB::BindableLong cargo_hold_contents_current; + DB::BufferString cargo_hold_contents; + + ShipObjectBufferRow() : + object_id(), + slide_dampener(), + current_chassis_hit_points(), + maximum_chassis_hit_points(), + chassis_type(), + cmp_armor_hp_maximum(400), + cmp_armor_hp_current(400), + cmp_efficiency_general(400), + cmp_efficiency_eng(400), + cmp_eng_maintenance(400), + cmp_mass(400), + cmp_crc(500), + cmp_hp_current(400), + cmp_hp_maximum(400), + cmp_flags(400), + cmp_names(4000), + weapon_damage_maximum(400), + weapon_damage_minimum(400), + weapon_effectiveness_shields(400), + weapon_effectiveness_armor(400), + weapon_eng_per_shot(400), + weapon_refire_rate(400), + weapon_ammo_current(400), + weapon_ammo_maximum(400), + weapon_ammo_type(400), + shield_hp_front_maximum(), + shield_hp_back_maximum(), + shield_recharge_rate(), + capacitor_eng_maximum(), + capacitor_eng_recharge_rate(), + engine_acc_rate(), + engine_deceleration_rate(), + engine_pitch_acc_rate(), + engine_yaw_acc_rate(), + engine_roll_acc_rate(), + engine_pitch_rate_maximum(), + engine_yaw_rate_maximum(), + engine_roll_rate_maximum(), + engine_speed_maximum(), + reactor_eng_generation_rate(), + booster_eng_maximum(), + booster_eng_recharge_rate(), + booster_eng_consumption_rate(), + booster_acc(), + booster_speed_maximum(), + droid_if_cmd_speed(), + installed_dcd(), + chassis_cmp_mass_maximum(), + cmp_creators(400), + cargo_hold_contents_maximum(), + cargo_hold_contents_current(), + cargo_hold_contents(500) + { + } + + ShipObjectBufferRow(const ShipObjectRow & rhs) : + object_id(rhs.object_id), + slide_dampener(rhs.slide_dampener), + current_chassis_hit_points(rhs.current_chassis_hit_points), + maximum_chassis_hit_points(rhs.maximum_chassis_hit_points), + chassis_type(rhs.chassis_type), + cmp_armor_hp_maximum(rhs.cmp_armor_hp_maximum), + cmp_armor_hp_current(rhs.cmp_armor_hp_current), + cmp_efficiency_general(rhs.cmp_efficiency_general), + cmp_efficiency_eng(rhs.cmp_efficiency_eng), + cmp_eng_maintenance(rhs.cmp_eng_maintenance), + cmp_mass(rhs.cmp_mass), + cmp_crc(rhs.cmp_crc), + cmp_hp_current(rhs.cmp_hp_current), + cmp_hp_maximum(rhs.cmp_hp_maximum), + cmp_flags(rhs.cmp_flags), + cmp_names(rhs.cmp_names), + weapon_damage_maximum(rhs.weapon_damage_maximum), + weapon_damage_minimum(rhs.weapon_damage_minimum), + weapon_effectiveness_shields(rhs.weapon_effectiveness_shields), + weapon_effectiveness_armor(rhs.weapon_effectiveness_armor), + weapon_eng_per_shot(rhs.weapon_eng_per_shot), + weapon_refire_rate(rhs.weapon_refire_rate), + weapon_ammo_current(rhs.weapon_ammo_current), + weapon_ammo_maximum(rhs.weapon_ammo_maximum), + weapon_ammo_type(rhs.weapon_ammo_type), + shield_hp_front_maximum(rhs.shield_hp_front_maximum), + shield_hp_back_maximum(rhs.shield_hp_back_maximum), + shield_recharge_rate(rhs.shield_recharge_rate), + capacitor_eng_maximum(rhs.capacitor_eng_maximum), + capacitor_eng_recharge_rate(rhs.capacitor_eng_recharge_rate), + engine_acc_rate(rhs.engine_acc_rate), + engine_deceleration_rate(rhs.engine_deceleration_rate), + engine_pitch_acc_rate(rhs.engine_pitch_acc_rate), + engine_yaw_acc_rate(rhs.engine_yaw_acc_rate), + engine_roll_acc_rate(rhs.engine_roll_acc_rate), + engine_pitch_rate_maximum(rhs.engine_pitch_rate_maximum), + engine_yaw_rate_maximum(rhs.engine_yaw_rate_maximum), + engine_roll_rate_maximum(rhs.engine_roll_rate_maximum), + engine_speed_maximum(rhs.engine_speed_maximum), + reactor_eng_generation_rate(rhs.reactor_eng_generation_rate), + booster_eng_maximum(rhs.booster_eng_maximum), + booster_eng_recharge_rate(rhs.booster_eng_recharge_rate), + booster_eng_consumption_rate(rhs.booster_eng_consumption_rate), + booster_acc(rhs.booster_acc), + booster_speed_maximum(rhs.booster_speed_maximum), + droid_if_cmd_speed(rhs.droid_if_cmd_speed), + installed_dcd(rhs.installed_dcd), + chassis_cmp_mass_maximum(rhs.chassis_cmp_mass_maximum), + cmp_creators(rhs.cmp_creators), + cargo_hold_contents_maximum(rhs.cargo_hold_contents_maximum), + cargo_hold_contents_current(rhs.cargo_hold_contents_current), + cargo_hold_contents(rhs.cargo_hold_contents) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct StaticObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct StaticObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + + StaticObjectBufferRow() : + object_id() + { + } + + StaticObjectBufferRow(const StaticObjectRow & rhs) : + object_id(rhs.object_id) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct TangibleObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong max_hit_points; + DB::BindableNetworkId owner_id; + DB::BindableBool visible; + DB::BindableString<2000> appearance_data; + DB::BindableLong interest_radius; + DB::BindableLong pvp_type; + DB::BindableLong pvp_faction; + DB::BindableLong damage_taken; + DB::BindableString<2000> custom_appearance; + DB::BindableLong count; + DB::BindableLong condition; + DB::BindableNetworkId creator_id; + DB::BindableLong source_draft_schematic; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct TangibleObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong max_hit_points; + DB::BindableNetworkId owner_id; + DB::BindableBool visible; + DB::BufferString appearance_data; + DB::BindableLong interest_radius; + DB::BindableLong pvp_type; + DB::BindableLong pvp_faction; + DB::BindableLong damage_taken; + DB::BufferString custom_appearance; + DB::BindableLong count; + DB::BindableLong condition; + DB::BindableNetworkId creator_id; + DB::BindableLong source_draft_schematic; + + TangibleObjectBufferRow() : + object_id(), + max_hit_points(), + owner_id(), + visible(), + appearance_data(2000), + interest_radius(), + pvp_type(), + pvp_faction(), + damage_taken(), + custom_appearance(2000), + count(), + condition(), + creator_id(), + source_draft_schematic() + { + } + + TangibleObjectBufferRow(const TangibleObjectRow & rhs) : + object_id(rhs.object_id), + max_hit_points(rhs.max_hit_points), + owner_id(rhs.owner_id), + visible(rhs.visible), + appearance_data(rhs.appearance_data), + interest_radius(rhs.interest_radius), + pvp_type(rhs.pvp_type), + pvp_faction(rhs.pvp_faction), + damage_taken(rhs.damage_taken), + custom_appearance(rhs.custom_appearance), + count(rhs.count), + condition(rhs.condition), + creator_id(rhs.creator_id), + source_draft_schematic(rhs.source_draft_schematic) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct TokenObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableNetworkId reference; + DB::BindableString<500> target_server_template_name; + DB::BindableString<500> target_shared_template_name; + DB::BindableNetworkId waypoint; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct TokenObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableNetworkId reference; + DB::BufferString target_server_template_name; + DB::BufferString target_shared_template_name; + DB::BindableNetworkId waypoint; + + TokenObjectBufferRow() : + object_id(), + reference(), + target_server_template_name(500), + target_shared_template_name(500), + waypoint() + { + } + + TokenObjectBufferRow(const TokenObjectRow & rhs) : + object_id(rhs.object_id), + reference(rhs.reference), + target_server_template_name(rhs.target_server_template_name), + target_shared_template_name(rhs.target_shared_template_name), + waypoint(rhs.waypoint) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct UniverseObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct UniverseObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + + UniverseObjectBufferRow() : + object_id() + { + } + + UniverseObjectBufferRow(const UniverseObjectRow & rhs) : + object_id(rhs.object_id) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct VehicleObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong bogus; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct VehicleObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong bogus; + + VehicleObjectBufferRow() : + object_id(), + bogus() + { + } + + VehicleObjectBufferRow(const VehicleObjectRow & rhs) : + object_id(rhs.object_id), + bogus(rhs.bogus) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct WeaponObjectRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong min_damage; + DB::BindableLong max_damage; + DB::BindableLong damage_type; + DB::BindableLong elemental_type; + DB::BindableLong elemental_value; + DB::BindableDouble attack_speed; + DB::BindableDouble wound_chance; + DB::BindableLong accuracy; + DB::BindableLong attack_cost; + DB::BindableDouble damage_radius; + DB::BindableDouble min_range; + DB::BindableDouble max_range; + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + +struct WeaponObjectBufferRow : public DB::Row +{ + DB::BindableNetworkId object_id; + DB::BindableLong min_damage; + DB::BindableLong max_damage; + DB::BindableLong damage_type; + DB::BindableLong elemental_type; + DB::BindableLong elemental_value; + DB::BindableDouble attack_speed; + DB::BindableDouble wound_chance; + DB::BindableLong accuracy; + DB::BindableLong attack_cost; + DB::BindableDouble damage_radius; + DB::BindableDouble min_range; + DB::BindableDouble max_range; + + WeaponObjectBufferRow() : + object_id(), + min_damage(), + max_damage(), + damage_type(), + elemental_type(), + elemental_value(), + attack_speed(), + wound_chance(), + accuracy(), + attack_cost(), + damage_radius(), + min_range(), + max_range() + { + } + + WeaponObjectBufferRow(const WeaponObjectRow & rhs) : + object_id(rhs.object_id), + min_damage(rhs.min_damage), + max_damage(rhs.max_damage), + damage_type(rhs.damage_type), + elemental_type(rhs.elemental_type), + elemental_value(rhs.elemental_value), + attack_speed(rhs.attack_speed), + wound_chance(rhs.wound_chance), + accuracy(rhs.accuracy), + attack_cost(rhs.attack_cost), + damage_radius(rhs.damage_radius), + min_range(rhs.min_range), + max_range(rhs.max_range) + { + } + + virtual void copy(const DB::Row &rhs) + { + *this = dynamic_cast(rhs); + } + + void setPrimaryKey(const NetworkId &keyValue) + { + object_id.setValue(keyValue); + } + + NetworkId getPrimaryKey() const + { + return object_id.getValue(); + } +}; + //!!!END GENERATED DECLARATIONS }