//------------------------------------------------------------------------------
// entityStateManager() -- (Output support)
// -- Update the entity object for this NIB(Player)
//------------------------------------------------------------------------------
bool Nib::entityStateManager(const double curExecTime)
{
bool ok = true;
if (getPlayer()->isMode(simulation::Player::ACTIVE) && isPlayerStateUpdateRequired(curExecTime)) {
// Need to update this entity object ...
NetIO* netIO = static_cast<NetIO*>(getNetIO());
RTI::RTIambassador* rtiAmb = netIO->getRTIambassador();
// ---
// First, make sure this entity has been registered
// ---
if (!isRegistered()) {
try {
RTI::ObjectClassHandle theClassHandle = netIO->getObjectClassHandle( getClassIndex() );
makeObjectName();
setObjectHandle( rtiAmb->registerObjectInstance( theClassHandle, getObjectName() ) );
netIO->addNibToObjectTables(this, simulation::NetIO::OUTPUT_NIB);
std::cout << "rprfom::Nib::updateEntity(): Register entity: " << getObjectName() << " handle = " << getObjectHandle() << std::endl;
}
catch (RTI::Exception& e) {
std::cerr << &e << std::endl;
ok = false;
}
}
// ---
// Next, update the entity's attribute values ...
// ---
if ( ok && isRegistered()) {
try {
// Create the attribute-value pair set
RTI::AttributeHandleValuePairSet* attrs = nullptr;
attrs = RTI::AttributeSetFactory::create( NetIO::NUM_OBJECT_ATTRIBUTES );
// Load the set with updated attribute values
updateBasicEntity(attrs,curExecTime);
updatePhysicalEntity(attrs,curExecTime);
updatePlatform(attrs,curExecTime);
// Send attributes to the RTI
//std::cout << "RprFom::Nib::updateEntity(): Update entity: " << getObjectName() << " handle = " << getObjectHandle() << std::endl;
ok = netIO->updateAttributeValues(getObjectHandle(), attrs);
delete attrs;
}
catch (RTI::Exception& e) {
std::cerr << &e << std::endl;
ok = false;
}
}
} // end -- if active player needs an update
return ok;
}
void EventDispatcher::dispatchEventToListeners(EventListenerVector* listeners, std::function<bool(EventListener*)> onEvent)
{
bool shouldStopPropagation = false;
auto fixedPriorityListeners = listeners->getFixedPriorityListeners();
auto sceneGraphPriorityListeners = listeners->getSceneGraphPriorityListeners();
ssize_t i = 0;
// priority < 0
if (fixedPriorityListeners)
{
bool isEmpty = fixedPriorityListeners->empty();
for (; !isEmpty && i < listeners->getGt0Index(); ++i)
{
auto l = fixedPriorityListeners->at(i);
if (!l->isPaused() && l->isRegistered() && onEvent(l))
{
shouldStopPropagation = true;
break;
}
}
}
if (sceneGraphPriorityListeners)
{
if (!shouldStopPropagation)
{
// priority == 0, scene graph priority
for (auto& l : *sceneGraphPriorityListeners)
{
if (!l->isPaused() && l->isRegistered() && onEvent(l))
{
shouldStopPropagation = true;
break;
}
}
}
}
if (fixedPriorityListeners)
{
if (!shouldStopPropagation)
{
// priority > 0
ssize_t size = fixedPriorityListeners->size();
for (; i < size; ++i)
{
auto l = fixedPriorityListeners->at(i);
if (!l->isPaused() && l->isRegistered() && onEvent(l))
{
shouldStopPropagation = true;
break;
}
}
}
}
}
//=============================================================================
// METHOD: SPELLvariableMonitor::retrieveLocalVariables()
//=============================================================================
void SPELLvariableMonitor::retrieveLocalVariables(std::vector<SPELLvarInfo>& vars)
{
DEBUG("[VM] Retrieve Locals");
/*
* Bottom stack frame is discarded,
* as globals and locals are the same dictionary
*/
if (m_frame->f_back == NULL) return;
/*
* Get the names defined in the current code, including arguments
*/
std::vector<std::string> varNames = retrieveNames();
/*
* Iterate over the locals dictionary, retrieving the names contained in
* varNames
*/
PyFrame_FastToLocals(m_frame);
PyObject* dict = m_frame->f_locals;
DEBUG("[VM] Frame: " + PYCREPR(m_frame));
for( unsigned int index = 0; index< varNames.size(); index++)
{
std::string varName = varNames[index];
PyObject* pyVarName = SSTRPY(varName);
if (PyDict_Contains( dict, pyVarName ))
{
PyObject* object = PyDict_GetItem( dict, pyVarName );
if (!SPELLpythonHelper::instance().isInstance(object, "Database", "spell.lib.adapter.databases.database"))
{
if (PyCallable_Check(object)) continue;
if (PyClass_Check(object)) continue;
if (PyModule_Check(object)) continue;
if (PyInstance_Check(object)) continue;
}
DEBUG("[VM] Processing " + varName);
std::string type = PYSSTR( PyObject_Type(object) );
DEBUG("[VM] Type : " + type);
std::string value = PYREPR( object );
DEBUG("[VM] Value : " + value);
DEBUG("[VM] Global : " + BSTR(false));
DEBUG("[VM] Registered: " + BSTR(isRegistered(varName)));
// Mark empty values (empty strings) as "<empty>"
if (value == "") value = EMPTY_STRING;
vars.push_back( SPELLvarInfo(varName, type, value, false, isRegistered(varName)) );
}
}
PyFrame_LocalsToFast(m_frame,0);
}
IZ_BOOL AnimationStateMachine::removeBehaviour(
AnimationStateMachineNode* from,
AnimationStateMachineNode* to)
{
IZ_BOOL result = IZ_FALSE;
if (from && to) {
IZ_ASSERT(isRegistered(from) && isRegistered(to));
result = from->removeBehaviour(to);
}
return result;
}
void CityRegionImplementation::notifyLoadFromDatabase() {
ManagedObjectImplementation::notifyLoadFromDatabase();
if (cityRank == CityManager::CLIENT)
return;
if (cityRank < CityManager::TOWNSHIP) {
citySpecialization = "";
}
Zone* zone = getZone();
if (zone == NULL)
return;
zone->addCityRegionToUpdate(_this.get());
if (isRegistered())
zone->getPlanetManager()->addRegion(_this.get());
//Add taxes if they dont exist.
if (taxes.size() <= 0) {
info("Adding taxes for existing city that had no taxes.", true);
taxes.add(0);
taxes.add(0);
taxes.add(0);
taxes.add(0);
taxes.add(0);
}
}
AnimationStateMachineBehaviour* AnimationStateMachine::getBehaviour(
AnimationStateMachineNode* from,
AnimationStateMachineNode* to)
{
AnimationStateMachineBehaviour* ret = nullptr;
if (from && to) {
IZ_ASSERT(isRegistered(from) && isRegistered(to));
ret = from->getBehaviour(to);
}
IZ_ASSERT(ret);
return ret;
}
bool BaseChannel::registerObject(DBusError *error)
{
if (isRegistered()) {
return true;
}
QString name = uniqueName();
QString busName = mPriv->connection->busName();
//QString busName = QString(QLatin1String("%1.%2"))
// .arg(mPriv->connection->busName(),name);
QString objectPath = QString(QLatin1String("%1/%2"))
.arg(mPriv->connection->objectPath(), name);
debug() << "Registering channel: busName: " << busName << " objectName: " << objectPath;
DBusError _error;
debug() << "Channel: registering interfaces at " << dbusObject();
foreach(const AbstractChannelInterfacePtr & iface, mPriv->interfaces) {
if (!iface->registerInterface(dbusObject())) {
// lets not fail if an optional interface fails registering, lets warn only
warning() << "Unable to register interface" << iface->interfaceName();
}
}
bool ret = registerObject(busName, objectPath, &_error);
if (!ret && error) {
error->set(_error.name(), _error.message());
}
return ret;
}
void Client::updateCounts(bool aRemove)
{
// We always remove the count and then add the correct one if requested...
if (m_countType != COUNT_UNCOUNTED)
{
--counts[m_countType];
m_countType = COUNT_UNCOUNTED;
}
if (!aRemove)
{
if (isOp())
{
m_countType = COUNT_OP;
}
else if (isRegistered())
{
m_countType = COUNT_REGISTERED;
}
else
{
m_countType = COUNT_NORMAL;
}
++counts[m_countType];
}
}
bool TOOL_MANAGER::runTool( TOOL_BASE* aTool )
{
wxASSERT( aTool != NULL );
if( !isRegistered( aTool ) )
{
wxASSERT_MSG( false, wxT( "You cannot run unregistered tools" ) );
return false;
}
TOOL_ID id = aTool->GetId();
if( aTool->GetType() == INTERACTIVE )
static_cast<TOOL_INTERACTIVE*>( aTool )->resetTransitions();
// If the tool is already active, bring it to the top of the active tools stack
if( isActive( aTool ) )
{
m_activeTools.erase( std::find( m_activeTools.begin(), m_activeTools.end(), id ) );
m_activeTools.push_front( id );
return false;
}
setActiveState( m_toolIdIndex[id] );
aTool->Reset( TOOL_INTERACTIVE::RUN );
// Add the tool on the front of the processing queue (it gets events first)
m_activeTools.push_front( id );
return true;
}
//____________________________________________________________________________________
void MdiWindowShadowFactory::unregisterWidget( QWidget* widget )
{
if( !isRegistered( widget ) ) return;
widget->removeEventFilter( this );
_registeredWidgets.remove( widget );
removeShadow( widget );
}
bool SpriteComponent::setStaticSprite(hgeSprite* _staticSprite)
{
// Do nothing if we are already using the supplied static mesh
if (_staticSprite == m_pStaticSprite)
{
//TODO set up a log
printf("Sprite already set up for static sprite component.\n");
return false;
}
// Don't allow changing static meshes if "static" and registered
AActor* Owner = getOwner();
if (Owner != NULL && isRegistered())
{
printf("mesh changed failed because it is a static mesh or because it is already registered.\n");
return false;
}
m_pStaticSprite = _staticSprite;
// TODO: add streaming?
// Since we have new mesh, we need to update bounds
//UpdateBounds();
return true;
}
bool TOOL_MANAGER::isActive( TOOL_BASE* aTool )
{
if( !isRegistered( aTool ) )
return false;
// Just check if the tool is on the active tools stack
return std::find( m_activeTools.begin(), m_activeTools.end(), aTool->GetId() ) != m_activeTools.end();
}
DataBaseFactory *DataBaseRegistry::getFactoryById(const QString &id) {
if(isRegistered(id)) {
return factories[id];
}
else {
return NULL;
}
}
IZ_BOOL AnimationStateMachine::removeNode(AnimationStateMachineNode* node)
{
if (isRegistered(node)) {
node->getListItem()->Leave();
return IZ_TRUE;
}
return IZ_FALSE;
}
void Model::processEvent(const Event& event) {
std::string target = event.getTarget();
if (!isRegistered(agents_, target)) {
LOG(FATAL) << "Attempted to process event [" << LoggingUtils::toString(event)
<< "] for non-registered Agent, " << target;
}
dirtyAgents_.insert(target);
agents_[target].processEvent(event);
}
bool DataBaseRegistry::registerDataBase(DataBaseFactory *f, const QString &id) {
if(!isRegistered(id)) {
factories[id] = f;
return true;
}
else {
return false;
}
}
void QDeclarativeBluetoothService::setServicePort(qint32 port)
{
if(d->m_port != port){
d->m_port = port;
if(isRegistered())
setRegistered(true);
emit detailsChanged();
}
}
const void* IDManager::getObjectFromColor(tgt::col4 col) {
if (col.a == 0)
return 0;
if (isRegistered(col))
return colorToID_[col];
else
return 0;
}
col4 IDManager::getColorFromObject(const void* obj) {
if (obj == 0)
return col4(0,0,0,0);
if (isRegistered(obj))
return IDToColor_[obj];
else
return col4(0,0,0,0);
}
void AbstractDBusInterface::updateValue(VariantType *property)
{
if(mConnection == nullptr)
{
return;
}
if(isRegistered())
signaller->fireSignal(mConnection, mObjectPath, mInterfaceName, "PropertiesChanged", property);
}
void SceneComponent::onUnregister()
{
if (isRegistered())
{
if (mParent != nullptr)
{
mParent->detachComponent(this);
}
Component::onUnregister();
}
}
bool
MembershipBookkeeping::BYESource(uint32 ssrc)
{
bool found = false;
// If the source identified by ssrc is in the table, mark it
// as leaving the session. If it was not, do nothing.
if ( isRegistered(ssrc) ) {
found = true;
decreaseMembersCount(); // TODO really decrease right now?
}
return found;
}
/**
Get object state.
@return current object state
*/
state_t getState() const
{
if(isMapped())
return STATE_CUDA_MAPPED;
if(isBound())
return STATE_GRAPHICS_BOUND;
if(isRegistered())
return STATE_INACTIVE;
return STATE_UNUSED;
}
void
ExeTraceInfo::removeTrace(void * exeTrace)
{
ExeTrace *t = (ExeTrace*) exeTrace;
if (!t)
return;
if (!isRegistered(t))
return;
exeTraces_.remove(t);
free(t->describes_);
free(t);
};
void RegisterPostMortemAction::readSettings(const QSettings *)
{
Q_UNUSED(debuggerRegistryValueNameC); // avoid warning from MinGW
bool registered = false;
HKEY handle = 0;
QString errorMessage;
if (openRegistryKey(HKEY_LOCAL_MACHINE, debuggerRegistryKeyC, false, &handle, &errorMessage))
registered = isRegistered(handle, debuggerCall(), &errorMessage);
if (handle)
RegCloseKey(handle);
setValue(registered, false);
}
TEST_F(PerformanceObserverTest, Observe) {
V8TestingScope scope;
initialize(scope.getScriptState());
NonThrowableExceptionState exceptionState;
PerformanceObserverInit options;
Vector<String> entryTypeVec;
entryTypeVec.append("mark");
options.setEntryTypes(entryTypeVec);
m_observer->observe(options, exceptionState);
EXPECT_TRUE(isRegistered());
}
void LinkLocalServiceBrowser::stop() {
assert(isRunning());
if (isRegistered()) {
unregisterService();
}
for (ResolveQueryMap::const_iterator i = resolveQueries.begin(); i != resolveQueries.end(); ++i) {
i->second->stop();
}
resolveQueries.clear();
services.clear();
browseQuery->stopBrowsing();
browseQuery.reset();
onStopped(haveError);
}
bool Model::validateConnections(const Agents& agents) {
for(Agents::const_iterator agentIter = agents.begin();
agentIter != agents.end(); ++agentIter) {
std::vector<std::string> connections = agentIter->second.getConnections();
for(int connectionsIdx = 0; connectionsIdx < connections.size(); connectionsIdx++) {
if (!isRegistered(agents, connections[connectionsIdx])) {
LOG(ERROR) << "Agent connection list contained unregistered agent, "
<< connections[connectionsIdx];
return false;
}
}
}
return true;
}
void InfluenceMap::recalculateInfluences(vector<T*> list){
vector<T*>::iterator begin= list.begin(), end= list.end();
for(;begin!=end;begin++)
{
int mask =isRegistered((*begin)->p);
if(mask==0)continue;
int range=(*begin)->getInfluenceRange();
int x = (int)(*begin)->getX()/tileW;
int y = (int)(*begin)->getY()/tileH;
for(int i=max(x-range,0);i<min(x+range,w);i++)
for(int j=max(y-range,0);j<min(y+range,h);j++)
grid[i][j]|=mask;
}
}
TEST_F(PerformanceObserverTest, Disconnect) {
V8TestingScope scope;
initialize(scope.getScriptState());
Persistent<PerformanceEntry> entry = PerformanceMark::create("m", 1234);
EXPECT_EQ(0, numPerformanceEntries());
m_observer->enqueuePerformanceEntry(*entry);
EXPECT_EQ(1, numPerformanceEntries());
m_observer->disconnect();
EXPECT_FALSE(isRegistered());
EXPECT_EQ(0, numPerformanceEntries());
}
