void SchematicManager::handleDatabaseJobComplete(void* ref,swganh::database::DatabaseResult* result)
{
ScMAsyncContainer* asyncContainer = reinterpret_cast<ScMAsyncContainer*>(ref);
switch(asyncContainer->mQueryType)
{
// index table for experimentation properties
case ScMQuery_ExperimentationGroups:
{
BString expGroup;
swganh::database::DataBinding* binding = mDatabase->createDataBinding(1);
binding->addField(swganh::database::DFT_bstring,0,64,1);
uint64 count = result->getRowCount();
mvExpGroups.reserve((uint32)count);
for(uint64 i = 0; i < count; i++)
{
result->getNextRow(binding,&expGroup);
mvExpGroups.push_back(expGroup.getAnsi());
}
mDatabase->destroyDataBinding(binding);
//gLogger->log(LogManager::DEBUG,"Finished Loading Experimentation Groups.");
}
break;
case ScMQuery_SchematicGroups:
{
SchematicGroup* scGroup;
swganh::database::DataBinding* binding = mDatabase->createDataBinding(2);
binding->addField(swganh::database::DFT_uint32,offsetof(SchematicGroup,mId),4,0);
binding->addField(swganh::database::DFT_bstring,offsetof(SchematicGroup,mName),64,1);
uint64 count = mGroupCount = mGroupLoadCount = static_cast<uint32>(result->getRowCount());
mSchematicGroupList.reserve((uint32)count);
for(uint64 i = 0; i < count; i++)
{
scGroup = new SchematicGroup();
result->getNextRow(binding,scGroup);
mSchematicGroupList.push_back(scGroup);
}
mDatabase->destroyDataBinding(binding);
ScMAsyncContainer* asContainer;
DLOG(info) << "Started Loading Schematics";
asContainer = new(mDBAsyncPool.ordered_malloc()) ScMAsyncContainer(ScMQuery_GroupSchematics);
mDatabase->executeSqlAsync(this,asContainer,"SELECT object_string,weightsbatch_id,complexity,datasize,subCategory,craftEnabled,group_id FROM %s.draft_schematics",mDatabase->galaxy());
}
break;
case ScMQuery_GroupSchematics:
{
DraftSchematic* schematic = NULL;
swganh::database::DataBinding* binding = mDatabase->createDataBinding(7);
binding->addField(swganh::database::DFT_bstring,offsetof(DraftSchematic,mModel),128,0);
binding->addField(swganh::database::DFT_uint32,offsetof(DraftSchematic,mWeightsBatchId),4,1);
binding->addField(swganh::database::DFT_uint32,offsetof(DraftSchematic,mComplexity),4,2);
binding->addField(swganh::database::DFT_uint32,offsetof(DraftSchematic,mDataSize),4,3);
binding->addField(swganh::database::DFT_uint32,offsetof(DraftSchematic,mSubCategory),4,4);
binding->addField(swganh::database::DFT_uint8,offsetof(DraftSchematic,mCraftEnabled),1,5);
binding->addField(swganh::database::DFT_uint32,offsetof(DraftSchematic,mGroupId),4,6);
uint64 count = result->getRowCount();
//mSchematicList.reserve((uint32)count);
uint32 num = 0;
for(uint64 i = 0; i < count; i++)
{
schematic = new DraftSchematic();
result->getNextRow(binding,schematic);
schematic->template_string_ = schematic->mModel.getAnsi();
// gotta get shared_ into the name
BStringVector splits;
int elements = schematic->mModel.split(splits,'/');
if(elements < 3)
{
LOG(error) << "Error in Schematic String";
break;
}
//uint32 size = schematic->mModel.getLength();
schematic->mModel.setLength(256);
schematic->mModel = splits[0].getAnsi();
for(int j = 1; j < elements - 1; j++)
schematic->mModel << "/" << splits[j].getAnsi();
schematic->mModel << "/shared_" << splits[elements-1].getAnsi();
// glue our ids and insert into maps
uint64 schem_crc = schematic->mModel.getCrc();
schematic->setId((schem_crc << 32) | (schematic->mWeightsBatchId));
//added temporary log in order to dump schematic ids for DB insertion
//gLogger->log(LogManager::DEBUG,"Schematic,%"PRIu64",%u",schematic->mId,schematic->mWeightsBatchId);
//mSchematicList.push_back(schematic);
mSchematicList.insert(std::make_pair(schematic->getWeightsBatchId(), schematic));
mSchematicGroupList[schematic->getGroupId()-1]->mSchematics.push_back(schematic);
mSchematicSlotMap.insert(std::make_pair(schematic->mModel.getCrc(),schematic));
mSchematicWeightMap.insert(std::make_pair((schematic->mWeightsBatchId ),schematic));
num++;
}
mSchematicCount += static_cast<uint32>(count);
DLOG(info) << "Started Loading Schematic Draft Slots.";
// now query the draftslots
ScMAsyncContainer* asContainer = new(mDBAsyncPool.ordered_malloc()) ScMAsyncContainer(ScMQuery_SchematicSlots);
int8 sql[2048];
sprintf(sql,"SELECT draft_slots.component_file, draft_slots.component_name, draft_slots.resource_name, draft_slots.amount, draft_slots.optional, draft_slots.`type`, draft_schematics.weightsbatch_id"
" FROM %s.draft_slots"
" INNER JOIN %s.draft_schematics_slots ON (draft_slots.id = draft_schematics_slots.draft_slot_id)"
" INNER JOIN %s.schem_crc ON (draft_schematics_slots.schematic_id = schem_crc.crc)"
" INNER JOIN %s.draft_schematics ON (schem_crc.object_string = draft_schematics.object_string)",
mDatabase->galaxy(),mDatabase->galaxy(),mDatabase->galaxy(),mDatabase->galaxy());
mDatabase->executeSqlAsync(this,asContainer,sql);
DLOG(info) << "Started Loading Schematic Assembly Batches.";
// assemblybatches
asContainer = new(mDBAsyncPool.ordered_malloc()) ScMAsyncContainer(ScMQuery_SchematicAssemblyBatches);
sprintf(sql,"SELECT draft_assembly_batches.id,draft_assembly_batches.list_id,draft_weights.id"
" FROM %s.draft_weights"
" INNER JOIN %s.draft_assembly_batches ON (draft_weights.assembly_batch_id = draft_assembly_batches.id)"
" ORDER BY draft_weights.id",
mDatabase->galaxy(),mDatabase->galaxy());
mDatabase->executeSqlAsync(this,asContainer,sql);
DLOG(info) << "Started Loading Schematic Experimentation Batches.";
// experimentbatches
asContainer = new(mDBAsyncPool.ordered_malloc()) ScMAsyncContainer(ScMQuery_SchematicExperimentBatches);
sprintf(sql,"SELECT draft_experiment_batches.id,draft_experiment_batches.list_id,draft_schematics.weightsbatch_id"
" FROM %s.draft_weights "
" INNER JOIN %s.draft_experiment_batches ON (draft_weights.experiment_batch_id = draft_experiment_batches.id) "
" INNER JOIN %s.draft_schematics ON(draft_weights.id = draft_schematics.weightsbatch_id) "
" ORDER BY draft_experiment_batches.list_id ",
mDatabase->galaxy(),mDatabase->galaxy(),mDatabase->galaxy());
mDatabase->executeSqlAsync(this,asContainer,sql);
DLOG(info) << "Started Loading Schematic Crafting Batches.";
// craftingbatches
asContainer = new(mDBAsyncPool.ordered_malloc()) ScMAsyncContainer(ScMQuery_SchematicCraftBatches);
sprintf(sql,"SELECT draft_craft_batches.id,draft_craft_batches.list_id,draft_craft_batches.expGroup,draft_schematics.weightsbatch_id"
" FROM %s.draft_weights "
" INNER JOIN %s.draft_craft_batches ON (draft_weights.craft_batch_id = draft_craft_batches.id) "
" INNER JOIN %s.draft_schematics ON(draft_weights.id = draft_schematics.weightsbatch_id) "
" ORDER BY draft_craft_batches.list_id ",
mDatabase->galaxy(),mDatabase->galaxy(),mDatabase->galaxy());
mDatabase->executeSqlAsync(this,asContainer,sql);
if(!--mGroupLoadCount)
{
DLOG(info) << "Finished Loading " << num << " Groups and Schematics out of " << count;
}
mDatabase->destroyDataBinding(binding);
}
break;
case ScMQuery_SchematicSlots:
{
DraftSchematic* schematic = NULL;//asyncContainer->mSchematic;
DraftSlot* slot;
swganh::database::DataBinding* binding = mDatabase->createDataBinding(7);
binding->addField(swganh::database::DFT_bstring,offsetof(DraftSlot,mFile),64,0);
binding->addField(swganh::database::DFT_bstring,offsetof(DraftSlot,mName),64,1);
binding->addField(swganh::database::DFT_bstring,offsetof(DraftSlot,mResourceName),128,2);
binding->addField(swganh::database::DFT_uint32,offsetof(DraftSlot,mAmount),4,3);
binding->addField(swganh::database::DFT_uint8,offsetof(DraftSlot,mOptional),1,4);
binding->addField(swganh::database::DFT_uint8,offsetof(DraftSlot,mType),1,5);
binding->addField(swganh::database::DFT_uint32,offsetof(DraftSlot,mSchemWeightBatch),4,6);
uint64 count = result->getRowCount();
uint32 num=0;
for(uint64 i = 0; i < count; i++)
{
slot = new DraftSlot();
result->getNextRow(binding,slot);
if((schematic == NULL) || (schematic->getWeightsBatchId() != slot->getSchemWeightBatch()))
{
schematic = getSchematicByWeightID(slot->getSchemWeightBatch());
}
if(schematic != NULL)
{
schematic->mDraftSlots.push_back(slot);
num++;
}
slot->mResourceName.convert(BSTRType_Unicode16);
}
mDatabase->destroyDataBinding(binding);
//gLogger->log(LogManager::DEBUG,"Finished Loading %u Schematic Draft Slots out of %u.",num,count);
}
break;
case ScMQuery_SchematicAssemblyBatches:
{
DraftSchematic* schematic = NULL;//asyncContainer->mSchematic;
WeightsBatch* batch;
swganh::database::DataBinding* binding = mDatabase->createDataBinding(3);
binding->addField(swganh::database::DFT_uint32,offsetof(WeightsBatch,mId),4,0);
binding->addField(swganh::database::DFT_uint32,offsetof(WeightsBatch,mListId),4,1);
binding->addField(swganh::database::DFT_uint32,offsetof(WeightsBatch,mSchemWeightBatch),4,2);
uint64 count = result->getRowCount();
uint32 num=0;
for(uint64 i = 0; i < count; i++)
{
batch = new WeightsBatch();
result->getNextRow(binding,batch);
if((schematic == NULL) || (schematic->getId() != batch->getSchemWeightBatch()))
{
schematic = getSchematicByWeightID(batch->getSchemWeightBatch());
}
if(schematic != NULL)
{
schematic->mAssemblyBatch.push_back(batch);
num++;
}
}
// query list items
ScMAsyncContainer* asContainer = new(mDBAsyncPool.ordered_malloc()) ScMAsyncContainer(ScMQuery_SchematicAssemblyWeights);
mDatabase->executeSqlAsync(this,asContainer,"SELECT datatype,distribution,draft_weights.id,draft_assembly_batches.list_id"
" FROM %s.draft_assembly_lists"
" INNER JOIN %s.draft_assembly_batches ON(draft_assembly_batches.list_id = draft_assembly_lists.id)"
" INNER JOIN %s.draft_weights ON(draft_weights.assembly_batch_id = draft_assembly_batches.id)"
" ORDER BY draft_weights.id",
mDatabase->galaxy(),mDatabase->galaxy(),mDatabase->galaxy());
mDatabase->destroyDataBinding(binding);
}
break;
case ScMQuery_SchematicExperimentBatches:
{
DraftSchematic* schematic = NULL;//asyncContainer->mSchematic;
WeightsBatch* batch;
swganh::database::DataBinding* binding = mDatabase->createDataBinding(3);
binding->addField(swganh::database::DFT_uint32,offsetof(WeightsBatch,mId),4,0);
binding->addField(swganh::database::DFT_uint32,offsetof(WeightsBatch,mListId),4,1);
binding->addField(swganh::database::DFT_uint32,offsetof(WeightsBatch,mSchemWeightBatch),4,2);
uint64 count = result->getRowCount();
uint32 num=0;
for(uint64 i = 0; i < count; i++)
{
batch = new WeightsBatch();
result->getNextRow(binding,batch);
if((schematic == NULL) || (schematic->getId() != batch->getSchemWeightBatch()))
{
schematic = getSchematicByWeightID(batch->getSchemWeightBatch());
}
if(schematic != NULL)
{
schematic->mExperimentBatch.push_back(batch);
num++;
}
}
// query list items
ScMAsyncContainer* asContainer = new(mDBAsyncPool.ordered_malloc()) ScMAsyncContainer(ScMQuery_SchematicExperimentWeights);
mDatabase->executeSqlAsync(this,asContainer,"SELECT datatype,distribution,draft_weights.id,draft_experiment_batches.list_id "
" FROM %s.draft_experiment_lists "
" INNER JOIN %s.draft_experiment_batches ON(draft_experiment_batches.list_id = draft_experiment_lists.id)"
" INNER JOIN %s.draft_weights ON (draft_weights.experiment_batch_id = draft_experiment_batches.id)"
" ORDER BY draft_weights.id",
mDatabase->galaxy(),mDatabase->galaxy(),mDatabase->galaxy());
mDatabase->destroyDataBinding(binding);
}
break;
case ScMQuery_SchematicCraftBatches:
{
DraftSchematic* schematic = NULL;//asyncContainer->mSchematic;
CraftBatch* batch;
swganh::database::DataBinding* binding = mDatabase->createDataBinding(4);
binding->addField(swganh::database::DFT_uint32,offsetof(CraftBatch,mId),4,0);
binding->addField(swganh::database::DFT_uint32,offsetof(CraftBatch,mListId),4,1);
binding->addField(swganh::database::DFT_uint32,offsetof(CraftBatch,mExpGroup),4,2);
binding->addField(swganh::database::DFT_uint32,offsetof(CraftBatch,mSchemWeightBatch),4,3);
uint64 count = result->getRowCount();
uint32 num=0;
for(uint64 i = 0; i < count; i++)
{
batch = new CraftBatch();
result->getNextRow(binding,batch);
if((schematic == NULL) || (schematic->getId() != batch->getSchemWeightBatch()))
{
schematic = getSchematicByWeightID(batch->getSchemWeightBatch());
}
if(schematic != NULL)
{
schematic->mCraftBatch.push_back(batch);
num++;
}
}
// query weight distribution
ScMAsyncContainer* asContainer = new(mDBAsyncPool.ordered_malloc()) ScMAsyncContainer(ScMQuery_SchematicCraftWeights);
mDatabase->executeSqlAsync(this,asContainer,"SELECT type,distribution,draft_weights.id,draft_craft_batches.list_id "
" FROM %s.draft_craft_attribute_weights"
" INNER JOIN %s.draft_craft_batches ON(draft_craft_attribute_weights.id = draft_craft_batches.list_id)"
" INNER JOIN %s.draft_weights ON(draft_weights.craft_batch_id = draft_craft_batches.id)"
" ORDER BY draft_weights.id",
mDatabase->galaxy(),mDatabase->galaxy(),mDatabase->galaxy());
// query attribute links and ranges
asContainer = new(mDBAsyncPool.ordered_malloc()) ScMAsyncContainer(ScMQuery_SchematicCraftAttributeLinks);
mDatabase->executeSqlAsync(this,asContainer,
"SELECT attributes.name,dcial.item_attribute,dcial.attribute_min,dcial.attribute_max,dcial.attribute_type,draft_craft_batches.id,dcial.list_id "
" FROM %s.draft_craft_item_attribute_link as dcial"
" INNER JOIN %s.attributes ON (dcial.item_attribute = attributes.id)"
" INNER JOIN %s.draft_craft_batches ON(dcial.list_id = draft_craft_batches.list_id)"
" ORDER BY draft_craft_batches.id",
mDatabase->galaxy(),mDatabase->galaxy(),mDatabase->galaxy());
// query attribute weighting for component crafting
asContainer = new(mDBAsyncPool.ordered_malloc()) ScMAsyncContainer(ScMQuery_SchematicCraftAttributeWeights);
//gLogger->log(LogManager::DEBUG,"Started Loading Schematic Craft Attribute Weights.");
mDatabase->executeSqlAsync(this,asContainer,
"SELECT dsam.Attribute, dsam.AffectedAttribute, dsam.Manipulation, a.name, b.name,draft_schematics.weightsbatch_id "
" FROM %s.draft_schematic_attribute_manipulation as dsam"
" INNER JOIN %s.attributes as a ON (dsam.attribute = a.id)"
" INNER JOIN %s.attributes as b ON (dsam.affectedattribute = b.id)"
" INNER JOIN %s.draft_schematics ON(dsam.Draft_Schematic = draft_schematics.weightsbatch_id)",
mDatabase->galaxy(),mDatabase->galaxy(),mDatabase->galaxy(),mDatabase->galaxy());
mDatabase->destroyDataBinding(binding);
//gLogger->log(LogManager::DEBUG,"Finished Loading %u Schematic Crafting Batches out of %u.",num,count);
}
break;
case ScMQuery_SchematicCraftAttributeWeights:
{
// "SELECT dsam.Attribute, dsam.AffectedAttribute, dsam.Manipulation, a.name, b.name "
DraftSchematic* schematic = NULL;//asyncContainer->mSchematic;
CraftAttributeWeight* craftAttributeWeight;
swganh::database::DataBinding* binding = mDatabase->createDataBinding(6);
binding->addField(swganh::database::DFT_uint32,offsetof(CraftAttributeWeight,mAttributeId),4,0);
binding->addField(swganh::database::DFT_uint32,offsetof(CraftAttributeWeight,mAffectedAttributeId),4,1);
binding->addField(swganh::database::DFT_uint32,offsetof(CraftAttributeWeight,mManipulation),4,2);
binding->addField(swganh::database::DFT_stdstring,offsetof(CraftAttributeWeight,mAttributeKey),255,3);
binding->addField(swganh::database::DFT_stdstring,offsetof(CraftAttributeWeight,mAffectedAttributeKey),255,4);
binding->addField(swganh::database::DFT_uint32,offsetof(CraftAttributeWeight,mSchemWeightBatch),4,5);
uint64 count = result->getRowCount();
uint32 num = 0;
for(uint64 i = 0; i < count; i++)
{
craftAttributeWeight = new CraftAttributeWeight();
result->getNextRow(binding,craftAttributeWeight);
if((schematic == NULL) || (schematic->getId() != craftAttributeWeight->getSchemWeightBatch()))
{
schematic = getSchematicByWeightID(craftAttributeWeight->getSchemWeightBatch());
}
if(schematic != NULL)
{
//CraftBatch* batch = schematic->getCraftBatchByListId(asyncContainer->mBatchId);
schematic->mAttributeWeights.push_back(craftAttributeWeight);
num++;
}
}
mDatabase->destroyDataBinding(binding);
//gLogger->log(LogManager::DEBUG,"Finished Loading %u Schematic Craft Attribute Weights out of %u",num,count);
}
break;
case ScMQuery_SchematicCraftAttributeLinks:
{
DraftSchematic* schematic = NULL;//asyncContainer->mSchematic;
CraftAttribute* craftAttribute;
swganh::database::DataBinding* binding = mDatabase->createDataBinding(7);
binding->addField(swganh::database::DFT_stdstring,offsetof(CraftAttribute,mAttributeKey),255,0);
binding->addField(swganh::database::DFT_uint32,offsetof(CraftAttribute,mAttributeId),4,1);
binding->addField(swganh::database::DFT_float,offsetof(CraftAttribute,mMin),4,2);
binding->addField(swganh::database::DFT_float,offsetof(CraftAttribute,mMax),4,3);
binding->addField(swganh::database::DFT_uint8,offsetof(CraftAttribute,mType),1,4);
binding->addField(swganh::database::DFT_uint32,offsetof(CraftAttribute,mSchemWeightBatch),4,5);
binding->addField(swganh::database::DFT_uint32,offsetof(CraftAttribute,mListId),4,6);
uint64 count = result->getRowCount();
uint32 num = 0;
for(uint64 i = 0; i < count; i++)
{
craftAttribute = new CraftAttribute();
result->getNextRow(binding,craftAttribute);
if((schematic == NULL) || (schematic->getId() != craftAttribute->getSchemWeightBatch()))
{
schematic = getSchematicByWeightID(craftAttribute->getSchemWeightBatch());
}
if(schematic != NULL)
{
CraftBatch* batch = schematic->getCraftBatchByListId(craftAttribute->getListId());
if(batch != NULL)
{
batch->mAttributes.push_back(craftAttribute);
num++;
}
}
}
mDatabase->destroyDataBinding(binding);
//gLogger->log(LogManager::DEBUG,"Finished Loading %u Schematic Craft Attribute Links out of %u",num,count);
}
break;
case ScMQuery_SchematicCraftWeights:
{
DraftSchematic* schematic = NULL;//asyncContainer->mSchematic;
CraftWeight* weight;
swganh::database::DataBinding* binding = mDatabase->createDataBinding(4);
binding->addField(swganh::database::DFT_uint8,offsetof(CraftWeight,mDataType),1,0);
binding->addField(swganh::database::DFT_float,offsetof(CraftWeight,mDistribution),4,1);
binding->addField(swganh::database::DFT_uint32,offsetof(CraftWeight,mSchemWeightBatch),4,2);
binding->addField(swganh::database::DFT_uint32,offsetof(CraftWeight,mBatchListId),4,3);
uint64 count = result->getRowCount();
uint32 num = 0;
for(uint64 i = 0; i < count; i++)
{
weight = new CraftWeight();
result->getNextRow(binding,weight);
if((schematic == NULL) || (schematic->getId() != weight->getSchemWeightBatch()))
{
schematic = getSchematicByWeightID(weight->getSchemWeightBatch());
}
if(schematic != NULL)
{
CraftBatch* batch = schematic->getCraftBatchByListId(weight->getBatchListId());
if(batch != NULL)
{
batch->mWeights.push_back(weight);
num++;
}
}
}
mDatabase->destroyDataBinding(binding);
//gLogger->log(LogManager::DEBUG,"Finished Loading %u Schematic Craft Weights out of %u.",num,count);
}
break;
case ScMQuery_SchematicAssemblyWeights:
{
DraftSchematic* schematic = NULL;
DraftWeight* weight;
swganh::database::DataBinding* binding = mDatabase->createDataBinding(4);
binding->addField(swganh::database::DFT_uint8,offsetof(DraftWeight,mDataType),1,0);
binding->addField(swganh::database::DFT_uint8,offsetof(DraftWeight,mDistribution),1,1);
binding->addField(swganh::database::DFT_uint32,offsetof(DraftWeight,mSchemWeightBatch),4,2);
binding->addField(swganh::database::DFT_uint32,offsetof(DraftWeight,mBatchListId),4,3);
uint64 count = result->getRowCount();
uint32 num = 0;
for(uint64 i = 0; i < count; i++)
{
weight = new DraftWeight();
result->getNextRow(binding,weight);
weight->prepareData();
if((schematic == NULL) || (schematic->getId() != weight->getSchemWeightBatch()))
{
schematic = getSchematicByWeightID(weight->getSchemWeightBatch());
}
if(schematic != NULL)
{
WeightsBatch* batch = schematic->getAssemblyWeightsBatchByListId(weight->getBatchListId());
if(batch != NULL)
{
batch->mWeights.push_back(weight);
num++;
}
}
}
mDatabase->destroyDataBinding(binding);
//gLogger->log(LogManager::DEBUG,"Finished Loading %u Schematic Assembly Weights out of %u",num,count);
}
break;
case ScMQuery_SchematicExperimentWeights:
{
DraftSchematic* schematic = NULL;
DraftWeight* weight;
swganh::database::DataBinding* binding = mDatabase->createDataBinding(4);
binding->addField(swganh::database::DFT_uint8,offsetof(DraftWeight,mDataType),1,0);
binding->addField(swganh::database::DFT_uint8,offsetof(DraftWeight,mDistribution),1,1);
binding->addField(swganh::database::DFT_uint32,offsetof(DraftWeight,mSchemWeightBatch),4,2);
binding->addField(swganh::database::DFT_uint32,offsetof(DraftWeight,mBatchListId),4,3);
uint64 count = result->getRowCount();
uint32 num = 0;
for(uint64 i = 0; i < count; i++)
{
weight = new DraftWeight();
result->getNextRow(binding,weight);
weight->prepareData();
if((schematic == NULL) || (schematic->getWeightsBatchId() != weight->getSchemWeightBatch()))
{
schematic = getSchematicByWeightID(weight->getSchemWeightBatch());
}
if(schematic != NULL)
{
WeightsBatch* batch = schematic->getExperimentWeightsBatchByListId(weight->getBatchListId());
if(batch != NULL)
{
batch->mWeights.push_back(weight);
num++;
}
}
}
mDatabase->destroyDataBinding(binding);
//gLogger->log(LogManager::DEBUG,"Finished Loading %u Schematic Experimentation Weights out of %u",num,count);
}
break;
default:
break;
}
mDBAsyncPool.ordered_free(asyncContainer);
}
