657 lines
17 KiB
C++
657 lines
17 KiB
C++
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
|
|
|
#include "stdpch.h"
|
|
|
|
|
|
#include "property_dispatcher.h"
|
|
#include "vision_array.h"
|
|
#include "property_id_translator.h"
|
|
#include "frontend_service.h"
|
|
#include "fe_stat.h"
|
|
//#include <sstream>
|
|
|
|
using namespace std;
|
|
using namespace NLMISC;
|
|
using namespace CLFECOMMON;
|
|
|
|
|
|
/*
|
|
* Constructor
|
|
*/
|
|
CPropertyDispatcher::CPropertyDispatcher() :
|
|
_VisionArray( NULL ),
|
|
_PropTranslator( NULL ),
|
|
_ClientId( 0 )
|
|
/*_HPThreshold( 0 ),
|
|
_HPTDelta( 0 ),*/
|
|
//_NbSentParcelsInCycle( 0 )
|
|
/*NbSetPrio( 0 ),
|
|
NbReenable( 0 )*/
|
|
{
|
|
_NextParcel.Prio = DISABLE_PRIORITY;
|
|
_NextParcel.Offset = INVALID_OFFSET;
|
|
}
|
|
|
|
|
|
/*
|
|
* Initialization
|
|
*/
|
|
void CPropertyDispatcher::init( TClientId clientid )
|
|
{
|
|
_ClientId = clientid;
|
|
_VisionArray = &(CFrontEndService::instance()->PrioSub.VisionArray);
|
|
_PropTranslator = &(CFrontEndService::instance()->PrioSub.PropTranslator);
|
|
|
|
// Initialize highest priority threshold from theorical maxratio
|
|
//_HPThreshold = CFrontEndService::instance()->PrioSub.Prioritizer.MaxRatio / NB_PRIORITIES;
|
|
}
|
|
|
|
|
|
/*
|
|
* Remove from the property dispatcher shelves, or does nothing if offset is INVALID_OFFSET
|
|
*/
|
|
void CPropertyDispatcher::removeProp( const TPropParcelPtr& parcelptr )
|
|
{
|
|
// Remove corresponding item in shelves (do nothing if there is no item yet)
|
|
if ( parcelptr.Offset != INVALID_OFFSET )
|
|
{
|
|
//nlinfo( "FEPRIO: Removing prop from dispatcher: %u-%u", parcelptr.Prio, parcelptr.Offset );
|
|
TPropertyShelf& shelf = getShelf( parcelptr.Prio );
|
|
//TMPDEBUG
|
|
if ( parcelptr.Offset < shelf.size() )
|
|
{
|
|
TPropParcel& parcel = getParcel( shelf, parcelptr.Offset );
|
|
|
|
// Remove parcel
|
|
TPropParcel& lastone = lastParcel( shelf );
|
|
if ( &parcel != &lastone )
|
|
{
|
|
parcel = lastone;
|
|
_VisionArray->updateLink( _ClientId, parcel, parcelptr.Offset );
|
|
}
|
|
shelf.pop_back();
|
|
}
|
|
else
|
|
{
|
|
nlwarning( "Cannot removeProp with invalid offset %hd", parcelptr.Offset );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Remove all corresponding properties from the property dispatcher
|
|
*/
|
|
void CPropertyDispatcher::removePropsFromShelves( TClientId clientid, TCLEntityId ceid )
|
|
{
|
|
sint ppi = 0;
|
|
TPropParcelPtr& parcelptr = _VisionArray->prioLoc( clientid, ceid, ppi );
|
|
removeProp( parcelptr );
|
|
parcelptr.Prio = DISABLE_PRIORITY;
|
|
parcelptr.Offset = INVALID_OFFSET;
|
|
|
|
// Skip special props
|
|
|
|
for ( ppi=3; ppi!=MAX_PROPERTIES_PER_ENTITY; ++ppi )
|
|
{
|
|
TPropParcelPtr& parcelptr = _VisionArray->prioLoc( clientid, ceid, ppi );
|
|
removeProp( parcelptr );
|
|
parcelptr.Prio = DISABLE_PRIORITY;
|
|
parcelptr.Offset = INVALID_OFFSET;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Make a new enabled parcel in the shelf corresponding to parcelptr.Prio and fill the parcelptr.Offset
|
|
*/
|
|
void CPropertyDispatcher::addProp( TPropParcelPtr& parcelptr, TCLEntityId ceid, TPropIndex propindex )
|
|
{
|
|
TPropParcel parcel;
|
|
parcel.CeId = ceid;
|
|
parcel.PropIndex = propindex;
|
|
parcel.Enabled = true;
|
|
|
|
// Add parcel and fill the offset field
|
|
TPropertyShelf& shelf = getShelf( parcelptr.Prio );
|
|
shelf.push_back( parcel );
|
|
parcelptr.Offset = shelf.size() - 1;
|
|
|
|
//printShelves( "after addProp", true );
|
|
}
|
|
|
|
|
|
/*
|
|
* Initialize dispatch cycle
|
|
*/
|
|
void CPropertyDispatcher::initDispatcherCycle( /*bool rescalePriorities*/ )
|
|
{
|
|
// Adjust threshold for highest priority selection
|
|
/*if ( rescalePriorities )
|
|
{
|
|
adjustHPThreshold();
|
|
}*/
|
|
|
|
// Set the pointer ready to advance to the first parcel
|
|
_NextParcel.Prio = INITIAL_PRIORITY;
|
|
_NextParcel.Offset = -1;
|
|
|
|
//_NbSentParcelsInCycle = 0;
|
|
|
|
// Move pointer to first parcel
|
|
incNextParcel();
|
|
|
|
// Display debug info
|
|
//printShelves( "after initDispatcherCycle", false );
|
|
//printShelfSizes();
|
|
}
|
|
|
|
|
|
/*
|
|
* Increment pointer to next parcel
|
|
*/
|
|
void CPropertyDispatcher::incNextParcel()
|
|
{
|
|
if ( _NextParcel.Offset < nbParcels(_NextParcel.Prio) - 1 )
|
|
{
|
|
// Advance to the next parcel in the same shelf
|
|
++_NextParcel.Offset;
|
|
|
|
// Check if the current parcel is enabled, otherwise advance to next one
|
|
if ( ! getParcel( _NextParcel ).Enabled )
|
|
{
|
|
incNextParcel();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( _NextParcel.Prio < LAST_PRIO_SENT )
|
|
{
|
|
// "Carriage return" to the next shelf
|
|
++_NextParcel.Prio;
|
|
_NextParcel.Offset = 0;
|
|
|
|
// Skip any empty shelves
|
|
skipEmptyShelves();
|
|
}
|
|
else
|
|
{
|
|
// Don't go past LAST_PRIO_SENT
|
|
_NextParcel.Offset = INVALID_OFFSET;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Skip any empty shelves
|
|
*/
|
|
inline void CPropertyDispatcher::skipEmptyShelves()
|
|
{
|
|
// Skip empty shelves
|
|
while ( _PropShelves[_NextParcel.Prio].empty() && (_NextParcel.Prio < LAST_PRIO_SENT) )
|
|
{
|
|
++_NextParcel.Prio;
|
|
}
|
|
|
|
// Detect end of data
|
|
if ( _PropShelves[_NextParcel.Prio].empty() )
|
|
{
|
|
_NextParcel.Offset = INVALID_OFFSET;
|
|
}
|
|
else
|
|
{
|
|
// Check if the current parcel is enabled, otherwise advance to next one
|
|
if ( ! getParcel( _NextParcel ).Enabled )
|
|
{
|
|
incNextParcel();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Return which property to send next, or NULL if there is no more.
|
|
*/
|
|
//const TPropParcel *CPropertyDispatcher::getNextParcel()
|
|
|
|
|
|
/*
|
|
* Set status: true if the latest parcel got by getNextParcel() can be sent in the current cycle, otherwise false
|
|
* If true, the parcel gets disabled.
|
|
* Must be called after getNextParcel() every time getNextParcel() is called
|
|
*/
|
|
void CPropertyDispatcher::setParcelStatusTrue()
|
|
{
|
|
// Status is set when the parcel was sent
|
|
if ( _NextParcel.Offset != INVALID_OFFSET )
|
|
{
|
|
//++_NbSentParcelsInCycle;
|
|
TPropParcel& parcel = getParcel( _NextParcel );
|
|
|
|
// Continuous or discreet property ?
|
|
//if ( _PropTranslator->isContinuous( _VisionArray->getEntityIndex( _ClientId, parcel.CeId ), parcel.PropIndex ) )
|
|
if ( parcel.PropIndex < FIRST_DISCREET_PROPINDEX )
|
|
{
|
|
// Continuous: disable the parcel
|
|
parcel.Enabled = false;
|
|
|
|
#ifdef MEASURE_FRONTEND_TABLES
|
|
// Debug: this is ok because the position is a common prop and its propertyid equals the propindex
|
|
if ( (_ClientId == 1) && (parcel.PropIndex == PROPERTY_POSITION) )
|
|
{
|
|
PosSentCntFrame.SeenEntities[parcel.CeId] = 1;
|
|
}
|
|
#endif
|
|
|
|
}
|
|
else
|
|
{
|
|
// Discreet: ask parcel removal and set update status to Updating
|
|
TPropState& propstate = _VisionArray->propState( _ClientId, parcel );
|
|
addToRemoveList( &propstate );
|
|
propstate.UpdateStatus = Updating;
|
|
|
|
// DEBUG DISPLAY
|
|
//nlinfo( "FESEND: Sent discrete property %hu to client %hu slot %hu", propertyid, _ClientId, (uint16)parcel.CeId );
|
|
}
|
|
}
|
|
|
|
// Advance to next parcel
|
|
incNextParcel();
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Remove the parcels that have been added to the remove list (call it after a cycle)
|
|
*/
|
|
void CPropertyDispatcher::flush()
|
|
{
|
|
// Remove all parcels referenced in the remove list
|
|
TRemoveList::iterator irl;
|
|
for ( irl=_RemoveList.begin(); irl!=_RemoveList.end(); ++irl )
|
|
{
|
|
// Remove parcel
|
|
removeProp( *(*irl) );
|
|
|
|
// Remove link
|
|
(*irl)->Prio = DISABLE_PRIORITY;
|
|
(*irl)->Offset = INVALID_OFFSET;
|
|
}
|
|
|
|
// Clear the remove list
|
|
_RemoveList.clear();
|
|
}
|
|
|
|
|
|
/*
|
|
* Return the number of enabled parcels in a shelf
|
|
*/
|
|
TPropParcelOffset CPropertyDispatcher::nbEnabledParcels( TPriority prio )
|
|
{
|
|
nlassert( prio <= NB_PRIORITIES );
|
|
sint32 nb = 0;
|
|
TPropertyShelf::iterator ips;
|
|
for ( ips=_PropShelves[prio].begin(); ips!=_PropShelves[prio].end(); ++ips )
|
|
{
|
|
if ( (*ips).Enabled )
|
|
++nb;
|
|
}
|
|
return (TPropParcelOffset)nb;
|
|
}
|
|
|
|
|
|
/*
|
|
* Adjust HPThreshold (dichotomic)
|
|
*/
|
|
/*void CPropertyDispatcher::adjustHPThreshold()
|
|
{
|
|
uint32 nbhpparcels = (uint32)nbEnabledParcels( HIGHEST_PRIORITY );
|
|
float hpoldvalue = _HPThreshold;
|
|
//nlinfo( "NbHP=%u NbSentParcelsInCycle=%u", (uint32)nbParcels( HIGHEST_PRIORITY ), _NbSentParcelsInCycle );
|
|
if ( nbhpparcels < _NbSentParcelsInCycle / 2 )
|
|
{
|
|
// Increase threshold when HIGHEST_PRIORITY can be filled more
|
|
if ( _HPTDelta < 0 )
|
|
{
|
|
_HPThreshold = _HPThreshold - _HPTDelta/2.0f;
|
|
//nlinfo( "FEPRIO: Stabilizing HPThreshold (+) to %.2f", _HPThreshold );
|
|
}
|
|
else
|
|
{
|
|
_HPThreshold *= 2.0f;
|
|
//nlinfo( "FEPRIO: Rising HPThreshold to %.2f, %u estimated actions", _HPThreshold, CFrontEndService::instance()->SentActionsLastCycle );
|
|
//printShelfSizes();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Decrease threshold when HIGHEST_PRIORITY is overloaded
|
|
if ( nbhpparcels > _NbSentParcelsInCycle )
|
|
{
|
|
if ( _HPTDelta > 0 )
|
|
{
|
|
_HPThreshold = _HPThreshold - _HPTDelta/2.0f;
|
|
//nlinfo( "FEPRIO: Stabilizing HPThreshold (-) to %.2f", _HPThreshold );
|
|
}
|
|
else
|
|
{
|
|
_HPThreshold /= 2.0f; // decrease threshold if HIGHEST_PRIORITY is crowded
|
|
//nlinfo( "FEPRIO: Lowering HPThreshold to %.2f, %u estimated actions", _HPThreshold, CFrontEndService::instance()->SentActionsLastCycle );
|
|
//printShelfSizes();
|
|
}
|
|
}
|
|
}
|
|
|
|
float maxratio = CFrontEndService::instance()->PrioSub.Prioritizer.MaxRatio;
|
|
if ( _HPThreshold >= maxratio )
|
|
{
|
|
// Fix threshold if it is too big after being calculated in adjustHPThreshold()
|
|
_HPThreshold = maxratio* 0.8f;
|
|
_HPTDelta = 0.0f;
|
|
//nlinfo( "FEPRIO: Fixing HPThreshold to %.2f", _HPThreshold );
|
|
} //nlinfo( "FEPRIO: HPThreshold is %.2f", _HPThreshold );
|
|
else
|
|
{
|
|
_HPTDelta = _HPThreshold - hpoldvalue;
|
|
}
|
|
}*/
|
|
|
|
|
|
/*
|
|
* Return the amount of priorities used corresponding to the specified number of actions (e.g. 1.2 means priority 0 is full and priority 1 is 20% filled)
|
|
*/
|
|
float CPropertyDispatcher::getPrioRatio()
|
|
{
|
|
// FEATURE DISABLED (_NbSentParcelsInCycle not calculated)
|
|
uint32 nbactions = 0;//_NbSentParcelsInCycle;
|
|
//nlinfo( "NbSent: %u size0: %u", _NbSentParcelsInCycle, _PropShelves[0].size() );
|
|
float ratio = 0.0f;
|
|
uint32 amount = 0;
|
|
TPriority p;
|
|
for ( p=0; p!=NB_PRIORITIES; ++p )
|
|
{
|
|
uint32 nbenabledinshelf = nbEnabledParcels(p);
|
|
if ( nbactions - amount > nbenabledinshelf )
|
|
{
|
|
// Accumulate amount of full shelf
|
|
amount += _PropShelves[p].size();
|
|
ratio += 1.0f;
|
|
}
|
|
else
|
|
{
|
|
// Accumulate amount of last shelf (decimals)
|
|
if ( ! _PropShelves[p].empty() )
|
|
{
|
|
ratio += (float)(nbactions - amount) / (float)nbenabledinshelf;
|
|
}
|
|
//comment Ben nlinfo( "FEPRIO: %u HP of %u total => ratio %.1f last=%u", _PropShelves[0].size(), nbactions, ratio, p );
|
|
return ratio;
|
|
}
|
|
}
|
|
return ratio;
|
|
}
|
|
|
|
|
|
/*
|
|
* Display the contents of the shelves
|
|
*/
|
|
void CPropertyDispatcher::printShelves( const char *title, bool checkIntegrity, bool proptext, bool hidedisabled ) const
|
|
{
|
|
bool integrity = true;
|
|
//stringstream ss;
|
|
string str;
|
|
string check;
|
|
if ( checkIntegrity )
|
|
{
|
|
check = " checking integrity";
|
|
}
|
|
//ss << "Client: " << _ClientId << /*" HPThreshold: " << _HPThreshold <<*/ " Next parcel: ";
|
|
str += "Client: " + NLMISC::toString(_ClientId) + /*" HPThreshold: " << NLMISC::toString(_HPThreshold) <<*/ " Next parcel: ";
|
|
if ( _NextParcel.Offset == -1 )
|
|
{
|
|
//ss << "Ready to start" << endl;
|
|
str += "Ready to start\n";
|
|
}
|
|
else if ( _NextParcel.Offset == INVALID_OFFSET )
|
|
{
|
|
//ss << "INVALID_OFFSET (prio=" << _NextParcel.Prio << ")" << endl;
|
|
str += "INVALID_OFFSET (prio=" + NLMISC::toString(_NextParcel.Prio) + ")\n";
|
|
}
|
|
else
|
|
{
|
|
//ss << "prio " << _NextParcel.Prio << " offset " << _NextParcel.Offset << endl;
|
|
str += "prio " + NLMISC::toString(_NextParcel.Prio) + " offset " + NLMISC::toString(_NextParcel.Offset) + "\n";
|
|
}
|
|
//ss << "Property shelves " << title << check << ":" << endl;
|
|
str += "Property shelves " + NLMISC::toString(title) + NLMISC::toString(check) + ":\n";
|
|
TPriority p;
|
|
|
|
// Scan all shelves
|
|
for ( p=0; p!=NB_PRIORITIES; ++p )
|
|
{
|
|
if ( ! _PropShelves[p].empty() )
|
|
{
|
|
//ss << p << ':';
|
|
str += NLMISC::toString(p) + ':';
|
|
TPropertyShelf::const_iterator ipr;
|
|
|
|
// Scan all parcels
|
|
for ( ipr=_PropShelves[p].begin(); ipr!=_PropShelves[p].end(); ++ipr )
|
|
{
|
|
const TPropParcel& parcel = (*ipr);
|
|
if ( (!hidedisabled) || parcel.Enabled )
|
|
{
|
|
//ss << ' ' << parcel.CeId << ' ';
|
|
str += " " + NLMISC::toString(parcel.CeId) + " ";
|
|
if ( proptext )
|
|
//ss << getPropText( parcel.PropIndex );
|
|
str += NLMISC::toString(getPropText( parcel.PropIndex ));
|
|
else
|
|
//ss << parcel.PropIndex;
|
|
str += NLMISC::toString(parcel.PropIndex);
|
|
if ( !hidedisabled )
|
|
//ss << ' ' << parcel.Enabled;
|
|
str += " " + NLMISC::toString(parcel.Enabled);
|
|
//ss << " -";
|
|
str += " -";
|
|
}
|
|
|
|
// Check integrity (debugging feature)
|
|
if ( checkIntegrity )
|
|
{
|
|
TPropParcelPtr parcelptr = _VisionArray->propState( _ClientId, parcel );
|
|
if ( ! (parcelptr.Prio == p) &&
|
|
(parcelptr.Offset == TPropParcelOffset(ipr-_PropShelves[p].begin())) )
|
|
{
|
|
integrity = false;
|
|
}
|
|
}
|
|
}
|
|
//ss << endl;
|
|
str += "\n";
|
|
}
|
|
}
|
|
// ss << ends;
|
|
nlwarning( "FEPRIO: %s", str.c_str() );
|
|
if ( ! integrity )
|
|
{
|
|
nlerror( "Property Dispatcher: integrity check failed" );
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Display the sizes of the shelves
|
|
*/
|
|
void CPropertyDispatcher::printShelfSizes() const
|
|
{
|
|
sint prio;
|
|
//InfoLog->display( "FEPRIO: Threshold: %.2f Parcels by prio:", _HPThreshold );
|
|
InfoLog->display( "FEPRIO: Parcels by prio:" );
|
|
for ( prio=HIGHEST_PRIORITY; prio!=NB_PRIORITIES; ++prio )
|
|
{
|
|
InfoLog->displayRaw( " %u", _PropShelves[prio].size() );
|
|
}
|
|
InfoLog->displayRawNL( "" );
|
|
}
|
|
|
|
|
|
/*
|
|
* Count the number of clients or properties of a certain type in the property shelves
|
|
*/
|
|
void CPropertyDispatcher::displayCounts( TPropIndex propindex )
|
|
{
|
|
sint prio = 0;
|
|
sint ofst = 0;
|
|
sint matching = 0;
|
|
sint enabled_matching = 0;
|
|
sint discrete_matching = 0;
|
|
sint self_matching = 0; // slot 0
|
|
|
|
while ( prio < NB_PRIORITIES )
|
|
{
|
|
for ( ofst = 0; ofst != (sint)_PropShelves[prio].size(); ++ofst )
|
|
{
|
|
bool propok = ( (propindex == 0xFF) || (propindex == _PropShelves[prio][ofst].PropIndex) );
|
|
if ( propok )
|
|
{
|
|
++matching;
|
|
|
|
if ( _PropShelves[prio][ofst].Enabled)
|
|
{
|
|
++enabled_matching;
|
|
}
|
|
if ( _PropShelves[prio][ofst].PropIndex > LAST_CONTINUOUS_PROPERTY )
|
|
{
|
|
++discrete_matching;
|
|
}
|
|
if ( _PropShelves[prio][ofst].CeId == 0 )
|
|
{
|
|
++self_matching;
|
|
}
|
|
}
|
|
}
|
|
++prio;
|
|
}
|
|
if ( propindex == 0xFF )
|
|
nlinfo( "FEPRIO: Searching for all property indexes" );
|
|
else
|
|
// warning: mixing property/propindex (TEMP)
|
|
nlinfo( "FEPRIO: Searching for propindex %hu (%s)", (uint16)propindex, getPropText(propindex) );
|
|
|
|
nlinfo( "FEPRIO: Found %d matching properties, including %d enabled, %d discrete, %d self-vision", matching, enabled_matching, discrete_matching, self_matching );
|
|
}
|
|
|
|
|
|
|
|
NLMISC_COMMAND( displayPropShelves, "Display the shelves of the property dispatcher", "[<clientid>|0] [<hideDisabled>0/1] [<propText>1/0] [<checkIntegrity>0/1]" )
|
|
{
|
|
// Parse arguments
|
|
TClientId clientid = 0;
|
|
bool hidedisabled = false;
|
|
bool check = false;
|
|
bool proptext = true;
|
|
if ( args.size() > 0 )
|
|
{
|
|
clientid = atoi(args[0].c_str());
|
|
if ( args.size() > 1 )
|
|
{
|
|
hidedisabled = (atoi(args[1].c_str()) != 0);
|
|
if ( args.size() > 2 )
|
|
{
|
|
check = (atoi(args[2].c_str()) != 0);
|
|
if ( args.size() > 3 )
|
|
{
|
|
proptext = (atoi(args[3].c_str()) != 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Display
|
|
THostMap& clientmap = CFrontEndService::instance()->instance()->receiveSub()->clientMap();
|
|
THostMap::iterator icm;
|
|
for ( icm=clientmap.begin(); icm!=clientmap.end(); ++icm )
|
|
{
|
|
if ( (clientid == 0) || (clientid == GETCLIENTA(icm)->clientId()) )
|
|
{
|
|
GETCLIENTA(icm)->PropDispatcher.printShelves( "command", check, proptext, hidedisabled, &log );
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
NLMISC_COMMAND( displayPropShelfSizes, "Display the sizes of the shelves of the property dispatcher", "[<clientid>|0]" )
|
|
{
|
|
// Parse arguments
|
|
TClientId clientid = 0;
|
|
if ( args.size() > 0 )
|
|
{
|
|
clientid = atoi(args[0].c_str());
|
|
}
|
|
|
|
// Display
|
|
THostMap& clientmap = CFrontEndService::instance()->instance()->receiveSub()->clientMap();
|
|
THostMap::iterator icm;
|
|
for ( icm=clientmap.begin(); icm!=clientmap.end(); ++icm )
|
|
{
|
|
if ( (clientid == 0) || (clientid == GETCLIENTA(icm)->clientId()) )
|
|
{
|
|
GETCLIENTA(icm)->PropDispatcher.printShelfSizes(&log);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
NLMISC_COMMAND( countClientsOrPropertiesInShelves, "Count the number of clients or properties of a certain type in the property shelves", "[<clientid|0> [<propindex>]]" )
|
|
{
|
|
// Parse arguments
|
|
TClientId clientid = 0;
|
|
TPropIndex propindex = 0xFF;
|
|
if ( args.size() > 0 )
|
|
{
|
|
clientid = atoi(args[0].c_str());
|
|
if ( args.size() > 1 )
|
|
{
|
|
propindex = atoi(args[1].c_str());
|
|
}
|
|
}
|
|
|
|
if ( clientid == 0 )
|
|
log.displayNL( "FEPRIO: Searching for all clients" );
|
|
else
|
|
log.displayNL( "FEPRIO: Searching for client %hu", clientid );
|
|
|
|
// Count
|
|
THostMap& clientmap = CFrontEndService::instance()->instance()->receiveSub()->clientMap();
|
|
THostMap::iterator icm;
|
|
for ( icm=clientmap.begin(); icm!=clientmap.end(); ++icm )
|
|
{
|
|
if ( (clientid == 0) || (clientid == GETCLIENTA(icm)->clientId()) )
|
|
{
|
|
GETCLIENTA(icm)->PropDispatcher.displayCounts( propindex, &log );
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|