PyDict *SimpleSystemEntity::MakeSlimItem() const {
PyDict *slim = new PyDict();
slim->SetItemString("typeID", new PyInt(data.typeID));
slim->SetItemString("ownerID", new PyInt(1));
slim->SetItemString("itemID", new PyInt(data.itemID));
return slim;
}
PyDict *ItemSystemEntity::MakeSlimItem() const {
PyDict *slim = new PyDict();
slim->SetItemString("itemID", new PyInt(Item()->itemID()));
slim->SetItemString("typeID", new PyInt(Item()->typeID()));
slim->SetItemString("ownerID", new PyInt(Item()->ownerID()));
return(slim);
}
PyObject *DBRowToRow(DBResultRow &row, const char *type)
{
PyDict *args = new PyDict();
PyObject *res = new PyObject( type, args );
//list off the column names:
uint32 cc = row.ColumnCount();
PyList *header = new PyList(cc);
args->SetItemString("header", header);
for(uint32 r = 0; r < cc; r++) {
header->SetItemString(r, row.ColumnName(r));
}
//lines:
PyList *rowlist = new PyList(cc);
args->SetItemString("line", rowlist);
//add a line entry for the row:
for(uint32 r = 0; r < cc; r++) {
rowlist->SetItem(r, DBColumnToPyRep(row, r));
}
return res;
}
PyDict *SystemStationEntity::MakeSlimItem() const {
PyDict *slim = new PyDict();
slim->SetItemString("typeID", new PyInt(data.typeID));
//HACKED:::
slim->SetItemString("ownerID", new PyInt(1000044));
slim->SetItemString("itemID", new PyInt(data.itemID));
return(slim);
}
PyDict* UserError::_CreateKeywords( const char* msg )
{
PyDict* keywords = new PyDict;
keywords->SetItemString( "msg", new PyString( msg ) );
keywords->SetItemString( "dict", new PyDict );
return keywords;
}
//this is a crap load of work... there HAS to be a better way to do this..
PyRep *MarketDB::GetMarketGroups() {
DBQueryResult res;
DBResultRow row;
if(!sDatabase.RunQuery(res,
"SELECT * "
" FROM invMarketGroups"))
{
codelog(MARKET__ERROR, "Error in query: %s", res.error.c_str());
return NULL;
}
DBRowDescriptor *header = new DBRowDescriptor(res);
CFilterRowSet *filterRowset = new CFilterRowSet(&header);
PyDict *keywords = filterRowset->GetKeywords();
keywords->SetItemString("giveMeSets", new PyBool(false)); //+
keywords->SetItemString("allowDuplicateCompoundKeys", new PyBool(false)); //+
keywords->SetItemString("indexName", new PyNone); //+
keywords->SetItemString("columnName", new PyString("parentGroupID")); //+
std::map< int, PyRep* > tt;
while( res.GetRow(row) )
{
int parentGroupID = ( row.IsNull( 0 ) ? -1 : row.GetUInt( 0 ) );
PyRep *pid;
CRowSet *rowset;
if(tt.count(parentGroupID) == 0) {
pid = parentGroupID!=-1 ? (PyRep*)new PyInt(parentGroupID) : (PyRep*)new PyNone();
tt.insert( std::pair<int, PyRep*>(parentGroupID, pid) );
rowset = filterRowset->NewRowset(pid);
} else {
pid = tt[parentGroupID];
rowset = filterRowset->GetRowset(pid);
}
PyPackedRow* pyrow = rowset->NewRow();
pyrow->SetField((uint32)0, pid); //prentGroupID
pyrow->SetField(1, new PyInt(row.GetUInt( 1 ) ) ); //marketGroupID
pyrow->SetField(2, new PyString(row.GetText( 2 ) ) ); //marketGroupName
pyrow->SetField(3, new PyString(row.GetText( 3 ) ) ); //description
pyrow->SetField(4, row.IsNull( 4 ) ?
(PyRep*)(new PyNone()) : new PyInt(row.GetUInt( 4 )) ); //graphicID
pyrow->SetField(5, new PyBool(row.GetBool( 5 ) ) ); //hasTypes
pyrow->SetField(6, row.IsNull( 6 ) ?
(PyRep*)(new PyNone()) : new PyInt(row.GetUInt( 6 )) ); // iconID
pyrow->SetField(7, new PyInt( row.GetUInt(7) ) ); //dataID
pyrow->SetField(8, new PyInt( row.GetUInt(8) ) ); //marketGroupNameID
pyrow->SetField(9, new PyInt( row.GetUInt(9) ) ); //descriptionID
}
return filterRowset;
}
PyDict* CFilterRowSet::_CreateKeywords(DBRowDescriptor* rowDesc)
{
assert( rowDesc );
PyDict* keywords = new PyDict;
keywords->SetItemString( "header", rowDesc );
keywords->SetItemString( "columnName", rowDesc->GetColumnName(0) );
return keywords;
}
PyRep* FactionWarMgrDB::GetFacWarSystems()
{
sLog.Debug( "FactionWarMgrDB", "Called GetFacWarSystems stub." );
//fill some crap
PyDict* result = new PyDict;
PyDict* dict;
dict = new PyDict;
dict->SetItemString( "occupierID", new PyInt( 500002 ) );
dict->SetItemString( "factionID", new PyInt( 500002 ) );
result->SetItem( new PyInt( 30002097 ), dict );
return result;
}
PyDict* CRowSet::_CreateKeywords(DBRowDescriptor* rowDesc)
{
assert( rowDesc );
PyDict* keywords = new PyDict;
keywords->SetItemString( "header", rowDesc );
uint32 cc = rowDesc->ColumnCount();
PyList* columns = new PyList( cc );
for( uint32 i = 0; i < cc; i++ )
columns->SetItem( i, new PyString( *rowDesc->GetColumnName( i ) ) );
keywords->SetItemString( "columns", columns );
return keywords;
}
PyDict *SystemStargateEntity::MakeSlimItem() const {
PyDict *slim = SystemStationEntity::MakeSlimItem();
if(m_jumps != NULL) {
PyIncRef(m_jumps);
slim->SetItemString("jumps", m_jumps);
}
return slim;
}
PyObject *DBRowToKeyVal(DBResultRow &row) {
PyDict *args = new PyDict();
PyObject *res = new PyObject( "util.KeyVal", args );
uint32 cc = row.ColumnCount();
for( uint32 r = 0; r < cc; r++ )
args->SetItemString( row.ColumnName(r), DBColumnToPyRep(row, r));
return res;
}
PyObject *DBResultToIndexRowset(DBQueryResult &result, uint32 key_index) {
uint32 cc = result.ColumnCount();
//start building the IndexRowset
PyDict *args = new PyDict();
PyObject *res = new PyObject(
new PyString( "util.IndexRowset" ), args
);
if(cc == 0 || cc < key_index)
return res;
//list off the column names:
PyList *header = new PyList(cc);
args->SetItemString("header", header);
for(uint32 i = 0; i < cc; i++)
header->SetItemString(i, result.ColumnName(i));
//RowClass:
args->SetItemString("RowClass", new PyToken("util.Row"));
//idName:
args->SetItemString("idName", new PyString( result.ColumnName(key_index) ));
//items:
PyDict *items = new PyDict();
args->SetItemString("items", items);
//add a line entry for each result row:
DBResultRow row;
while(result.GetRow(row)) {
PyRep *key = DBColumnToPyRep(row, key_index);
PyList *line = new PyList(cc);
for(uint32 i = 0; i < cc; i++)
line->SetItem(i, DBColumnToPyRep(row, i));
items->SetItem(key, line);
}
return res;
}
PyObject *DBResultToRowset(DBQueryResult &result)
{
uint32 r;
uint32 cc = result.ColumnCount();
PyDict *args = new PyDict();
PyObject *res = new PyObject(
new PyString( "util.Rowset" ), args
);
/* check if we have a empty query result and return a empty RowSet */
if( cc == 0 )
return res;
//list off the column names:
PyList *header = new PyList( cc );
args->SetItemString("header", header);
for(r = 0; r < cc; r++) {
header->SetItemString( r, result.ColumnName(r));
}
//RowClass:
args->SetItemString("RowClass", new PyToken("util.Row"));
//lines:
PyList *rowlist = new PyList();
args->SetItemString("lines", rowlist);
//add a line entry for each result row:
DBResultRow row;
while(result.GetRow(row)) {
PyList *linedata = new PyList( cc );
rowlist->AddItem(linedata);
for(r = 0; r < cc; r++) {
linedata->SetItem( r, DBColumnToPyRep(row, r) );
}
}
return res;
}
PyResult BulkMgrService::Handle_UpdateBulk(PyCallArgs &call)
{
Call_UpdateBulk args;
if(!args.Decode(&call.tuple)) {
codelog(CLIENT__ERROR, "Invalid arguments");
return NULL;
}
PyDict* test = new PyDict();
test->SetItemString("type", new PyInt(updateBulkStatusOK));
test->SetItemString("allowUnsubmitted", new PyBool(false));
return test;
}
PyResult MailMgrService::Handle_SyncMail(PyCallArgs &call)
{
int firstId = 0, secondId = 0;
if (call.tuple->size() == 2 && !call.tuple->GetItem(0)->IsNone() && !call.tuple->GetItem(1)->IsNone())
{
Call_TwoIntegerArgs args;
if (!args.Decode(&call.tuple))
{
codelog(CLIENT__ERROR, "Failed to decode SyncMail args");
return NULL;
}
// referring to a mail id range
int firstId = args.arg1, secondId = args.arg2;
}
PyDict* dummy = new PyDict;
dummy->SetItemString("oldMail", new PyNone());
dummy->SetItemString("newMail", m_db->GetNewMail(call.client->GetCharacterID()));
dummy->SetItemString("mailStatus", m_db->GetMailStatus(call.client->GetCharacterID()));
return new PyObject("util.KeyVal", dummy);
}
PyResult ContractMgrService::Handle_NumRequiringAttention( PyCallArgs& call )
{
uint32 requiresAttentionCorp = 0;
uint32 requiresAttention = 0;
std::map<uint32, ContractRef>::const_iterator cur, end;
std::map<uint32, ContractRef> contracts = m_contractManager->GetContractList();
cur = contracts.begin();
end = contracts.end();
for(; cur != end; cur++ )
{
ContractRef contract = cur->second;
if( contract->requiresAttention() )
{
if( contract->issuerCorpID() == call.client->GetCorporationID() )
{
requiresAttentionCorp += 1;
}else if( contract->issuerID() == call.client->GetCharacterID() ){
requiresAttention += 1;
}else if( contract->acceptorID() == call.client->GetCharacterID() ){
requiresAttention += 1;
}else if( contract->assigneeID() == call.client->GetCharacterID() ){
requiresAttention += 1;
}
}
}
PyDict* args = new PyDict;
args->SetItemString( "n", new PyInt( requiresAttention ) );
args->SetItemString( "ncorp", new PyInt( requiresAttentionCorp ) );
return new PyObject(
new PyString( "util.KeyVal" ), args
);
}
PyDict* CRowSet::_CreateKeywords(DBRowDescriptor* rowDesc)
{
assert( rowDesc );
PyDict* keywords = new PyDict;
keywords->SetItemString( "header", rowDesc );
//uint32 cc = rowDesc->ColumnCount();
//PyList* columns = new PyList( cc );
//for( uint32 i = 0; i < cc; i++ )
// columns->SetItem( i, new PyString( *rowDesc->GetColumnName( i ) ) );
//keywords->SetItemString( "columns", columns ); //The Type_2 i had no longer used this
return keywords;
}
PyDict* GPSTransportClosed::_CreateKeywords( const char* reason )
{
PyDict* keywords = new PyDict;
//keywords->SetItemString( "origin", new PyString( "proxy" ) );
keywords->SetItemString( "reasonArgs", new PyDict );
keywords->SetItemString( "clock", new PyLong( Win32TimeNow() ) );
//keywords->SetItemString( "loggedOnUserCount", );
keywords->SetItemString( "region", new PyString( EVEProjectRegion ) );
keywords->SetItemString( "reason", new PyString( reason ) );
keywords->SetItemString( "version", new PyFloat( EVEVersionNumber ) );
keywords->SetItemString( "build", new PyInt( EVEBuildVersion ) );
//keywords->SetItemString( "reasonCode", );
keywords->SetItemString( "codename", new PyString( EVEProjectCodename ) );
keywords->SetItemString( "machoVersion", new PyInt( MachoNetVersion ) );
return keywords;
}
PyResult InfoGatheringService::Handle_GetStateAndConfig(PyCallArgs &call) {
sLog.Debug("Server", "Called GetStateAndConfig");
PyDict* args = new PyDict;
args->SetItemString( "clientWorkerInterval", new PyInt( 0 ) );
args->SetItemString( "isEnabled", new PyInt( 0 ) );
args->SetItemString( "infoTypeAggregates", new PyDict );
args->SetItemString( "infoTypesOncePerRun", new PyDict );
args->SetItemString( "infoTypeParameters", new PyDict );
args->SetItemString( "infoTypes", new PyDict );
return new PyObject( "util.KeyVal", args );
}
PyResult InfoGatheringMgr::Handle_GetStateAndConfig(PyCallArgs &call) {
PyDict *rsp = new PyDict;
rsp->SetItemString("clientWorkerInterval", new PyInt(600000)); //Default From packetlogs is 600000
rsp->SetItemString("isEnabled", new PyInt(0)); //0 = Disabled, 1 = Enabled. Set to 0 becuase jsut gettting rid of exception.
rsp->SetItemString("infoTypeAggregates", new PyNone());
rsp->SetItemString("infoTypesOncePerRun", new PyNone());
rsp->SetItemString("infoTypeParameters", new PyNone());
PyList *infoTypes = new PyList;
infoTypes->AddItemInt(999); //Adding a value that was not in live so when its checks list it will always return false for now.
rsp->SetItemString("infoTypes", new PyObjectEx_Type1( new PyToken("__builtin__.set"), new_tuple(infoTypes)));
return new PyObject( "util.KeyVal", rsp );
}
PyDict *SystemStargateEntity::MakeSlimItem() const {
PyDict *slim = SystemStationEntity::MakeSlimItem();
if(m_jumps != NULL)
slim->SetItemString("jumps", m_jumps->Clone());
return(slim);
}
PyResult ContractMgrService::Handle_CollectMyPageInfo( PyCallArgs& call )
{
PyDict* ret = new PyDict;
uint32 numOutstandingContractsNonCorp = 0;
uint32 numOutstandingContractsForCorp = 0;
uint32 numContractsLeft = 0;
uint32 numRequiresAttention = 0;
uint32 numRequiresAttentionCorp = 0;
uint32 numAssignedTo = 0;
uint32 numAssignedToCorp = 0;
uint32 numBiddingOn = 0;
uint32 numInProgress = 0;
uint32 numBiddingOnCorp = 0;
uint32 numInProgressCorp = 0;
std::map<uint32, ContractRef>::const_iterator cur, end;
std::map<uint32, ContractRef> contracts = m_contractManager->GetContractList();
cur = contracts.begin();
end = contracts.end();
for(; cur != end; cur++ )
{
ContractRef contract = cur->second;
if( contract->issuerID() == call.client->GetCharacterID() )
{
if( contract->forCorp() == true )
{
if( contract->requiresAttention() ) numRequiresAttentionCorp += 1;
if( contract->assigneeID() ) numAssignedToCorp += 1;
if( contract->status() == conStatusInProgress ) numInProgressCorp += 1;
numOutstandingContractsForCorp += 1;
}else{
if( contract->requiresAttention() ) numRequiresAttention += 1;
if( contract->assigneeID() ) numAssignedTo += 1;
if( contract->status() == conStatusInProgress ) numInProgress += 1;
numOutstandingContractsNonCorp += 1;
}
}
}
ret->SetItemString( "numOutstandingContractsNonCorp", new PyInt( numOutstandingContractsNonCorp ) );
ret->SetItemString( "numOutstandingContractsForCorp", new PyInt( numOutstandingContractsForCorp ) );
ret->SetItemString( "numOutstandingContracts", new PyInt( numOutstandingContractsNonCorp + numOutstandingContractsForCorp ) );
ret->SetItemString( "numContractsLeft", new PyInt( numContractsLeft ) );
ret->SetItemString( "numRequiresAttention", new PyInt( numRequiresAttention ) );
ret->SetItemString( "numRequiresAttentionCorp", new PyInt( numRequiresAttentionCorp ) );
ret->SetItemString( "numAssignedTo", new PyInt( numAssignedTo ) );
ret->SetItemString( "numAssignedToCorp", new PyInt( numAssignedToCorp ) );
ret->SetItemString( "numBiddingOn", new PyInt( numBiddingOn ) );
ret->SetItemString( "numInProgress", new PyInt( numInProgress ) );
ret->SetItemString( "numBiddingOnCorp", new PyInt( numBiddingOnCorp ) );
ret->SetItemString( "numInProgressCorp", new PyInt( numInProgressCorp ) );
return new PyObject(
new PyString( "util.KeyVal" ), ret
);
}
//this is a big hack just to document the kind of stuff a dungeon conveys.
PyDict *SystemDungeonEntranceEntity::MakeSlimItem() const {
PyDict *slim = ItemSystemEntity::MakeSlimItem();
if(slim == NULL)
return NULL;
//slim->SetItemString("itemID", new PyInt(2100000396));
//slim->SetItemString("typeID", new PyInt(12273));
//slim->SetItemString("ownerID", new PyInt(500021));
slim->SetItemString("dunSkillLevel", new PyInt(0));
slim->SetItemString("dunSkillTypeID", new PyNone);
slim->SetItemString("dunObjectID", new PyInt(160449));
slim->SetItemString("dunWipeNPC", new PyInt(1));
slim->SetItemString("dunToGateID", new PyInt(160484));
slim->SetItemString("dunCloaked", new PyInt(0));
slim->SetItemString("dunScenarioID", new PyInt(23));
slim->SetItemString("dunSpawnID", new PyInt(4));
slim->SetItemString("dunAmount", new PyFloat(0.0));
slim->SetItemString("dunShipClasses", new PyList(/*237, 31*/));
slim->SetItemString("dunDirection", new PyList(/*235, 0, 1*/));
slim->SetItemString("dunKeyLock", new PyInt(0));
//slim->SetItemString("dunKeyQuantity", new PyInt(1));
//slim->SetItemString("dunKeyTypeID", new PyInt(21839));
//slim->SetItemString("dunOpenUntil", new PyInt(Win32TimeNow()+Win32Time_Hour));
slim->SetItemString("dunMusicUrl", new PyString("res:/Sound/Music/Ambient031combat.ogg"));
return(slim);
}
PyRep *MarketDB::CollectMyPageInfo( uint32 clientID )
{
DBQueryResult res;
DBResultRow row;
if(!sDatabase.RunQuery(res,
"SELECT numOutstandingContractsNonCorp,"
" numOutstandingContractsForCorp,"
" numOutstandingContracts,"
" numContractsLeft,"
" numRequiresAttention,"
" numRequiresAttentionCorp,"
" numAssignedTo,"
" numAssignedToCorp,"
" numBiddingOn,"
" numInProgress,"
" numBiddingOnCorp,"
" numInProgressCorp"
" FROM chrcontractinfo"
" WHERE characterID=%d", clientID))
{
codelog( MARKET__ERROR, "Error in query: %s", res.error.c_str() );
return NULL;
}
if(!res.GetRow(row)) {
codelog(MARKET__ERROR, "Player %u chrcontractinfo not found.", clientID);
return NULL;
}
PyDict* PageInfo = new PyDict;
PageInfo->SetItemString( "numOutstandingContractsNonCorp", new PyInt( row.GetInt( 0 ) ) );
PageInfo->SetItemString( "numOutstandingContractsForCorp", new PyInt( row.GetInt( 1 ) ) );
PageInfo->SetItemString( "numOutstandingContracts", new PyInt( row.GetInt( 2 ) ) );
PageInfo->SetItemString( "numContractsLeft", new PyInt( row.GetInt( 3 ) ) );
PageInfo->SetItemString( "numRequiresAttention", new PyInt( row.GetInt( 4 ) ) );
PageInfo->SetItemString( "numRequiresAttentionCorp", new PyInt( row.GetInt( 5 ) ) );
PageInfo->SetItemString( "numAssignedTo", new PyInt( row.GetInt( 6 ) ) );
PageInfo->SetItemString( "numAssignedToCorp", new PyInt( row.GetInt( 7 ) ) );
PageInfo->SetItemString( "numBiddingOn", new PyInt( row.GetInt( 8 ) ) );
PageInfo->SetItemString( "numInProgress", new PyInt( row.GetInt( 9 ) ) );
PageInfo->SetItemString( "numBiddingOnCorp", new PyInt( row.GetInt( 10 ) ) );
PageInfo->SetItemString( "numInProgressCorp", new PyInt( row.GetInt( 11 ) ) );
return PageInfo;
}
//this is a crap load of work... there HAS to be a better way to do this..
PyObject *MarketDB::GetMarketGroups() {
DBQueryResult res;
//returns cached object marketProxy.GetMarketGroups
//marketGroupID, parentGroupID, marketGroupName, description, graphicID, hasTypes, types
//this is going to be a real pain... another "nested" query thing...
// I really wanna know how they do this crap with their MS SQL server..
// I hope its not as much of a nightmare as it is for us....
//first we need to query out all the types because we need them to
// fill in the 'types' subquery for each row of the result
std::map< int, std::set<uint32> > types; //maps marketGroupID -> typeID
if(!sDatabase.RunQuery(res,
"SELECT"
" marketGroupID,typeID"
" FROM invTypes"
" WHERE marketGroupID IS NOT NULL"
" ORDER BY marketGroupID"))
{
codelog(MARKET__ERROR, "Error in query: %s", res.error.c_str());
return NULL;
}
DBResultRow row;
while(res.GetRow(row))
types[row.GetUInt(0)].insert(row.GetUInt(1));
if(!sDatabase.RunQuery(res,
"SELECT"
" marketGroupID, parentGroupID"
" FROM invMarketGroups"))
{
codelog(MARKET__ERROR, "Error in query: %s", res.error.c_str());
return NULL;
}
std::map<int, int> parentChild; //maps child -> parent
std::map<int, std::set<int> > childParent; //maps parent -> all children.
while(res.GetRow(row)) {
//figure out the parent ID, mapping NULL to -1 for our map.
int marketGroupID = row.GetUInt(0);
int parentGroupID = row.IsNull(1) ? -1 : row.GetUInt(1);
parentChild[marketGroupID] = parentGroupID;
childParent[parentGroupID].insert(marketGroupID);
}
//now we need to propigate all of the items up the tree (a parent group's items list contains ALL items of its children.)
_PropigateItems(types, parentChild, childParent, -1);
//now we get to do the other query.
if(!sDatabase.RunQuery(res,
"SELECT"
" marketGroupID, parentGroupID, marketGroupName, description, graphicID, hasTypes"
" FROM invMarketGroups"))
{
codelog(MARKET__ERROR, "Error in query: %s", res.error.c_str());
return NULL;
}
//doing this the long (non XML) way to avoid the extra copies due to the huge volume of data here.
PyDict *args = new PyDict();
PyDict *parentSets = new PyDict();
PyList *header = new PyList();
header->AddItemString("marketGroupID");
header->AddItemString("parentGroupID");
header->AddItemString("marketGroupName");
header->AddItemString("description");
header->AddItemString("graphicID");
header->AddItemString("hasTypes");
header->AddItemString("types"); //this column really contains an entire list.
header->AddItemString("dataID");
args->SetItemString("header", header);
args->SetItemString("idName", new PyString("parentGroupID"));
args->SetItemString("RowClass", new PyToken("util.Row"));
args->SetItemString("idName2", new PyNone);
args->SetItemString("items", parentSets);
//now fill in items.
// we have to satisfy this structure... which uses parentGroupID as the
// main dict key, each dict entry is then a list of MarketGroup_Entrys
// which have that parentGroupID
//marketGroupID, parentGroupID, marketGroupName, description, graphicID, hasTypes, types
std::map< int, std::set<uint32> >::const_iterator tt;
MarketGroup_Entry entry;
PyList* list;
PyList* parents = new PyList();
while( res.GetRow(row) )
{
entry.marketGroupID = row.GetUInt( 0 );
//figure out the parent ID, mapping NULL to -1 for our map.
entry.parentGroupID = ( row.IsNull( 1 ) ? -1 : row.GetUInt( 1 ) );
entry.marketGroupName = row.GetText( 2 );
entry.description = row.GetText( 3 );
entry.graphicID = ( row.IsNull( 4 ) ? -1 : row.GetUInt( 4 ) );
entry.hasTypes = row.GetUInt( 5 );
// Insert all types
entry.types.clear();
tt = types.find( entry.marketGroupID );
if( tt != types.end() )
entry.types.insert( entry.types.begin(), tt->second.begin(), tt->second.end() );
if(entry.parentGroupID == -1)
list = parents;
else
list = static_cast<PyList*> (parentSets->GetItem(new PyInt( entry.parentGroupID )));
if(list == NULL)
list = new PyList();
list->AddItem(entry.Encode());
PySafeIncRef(list);
if(entry.parentGroupID != -1)
parentSets->SetItem(new PyInt(entry.parentGroupID), list);
}
parentSets->SetItem(new PyNone, parents);
return new PyObject( "util.FilterRowset", args );
}