dmz::Mask
dmz::ArchivePluginObject::_filter_state (
const Handle AttrHandle,
const Mask &Value,
const UInt32 Mode) {
Mask result (Value);
if (_currentFilterList) {
FilterStruct *filter = _currentFilterList->list;
while (filter) {
if (filter->mode & Mode) {
Mask *filterMask (filter->stateTable.lookup (AttrHandle));
if (filterMask) { result.unset (*filterMask); }
}
filter = filter->next;
}
}
return result;
}
Status Resolver::resolveRelativePathsStartingAddresses(
const vector<Address>& relativePathAddresses,
Mask& mask,
vector<BrowsePath>& results,
vector<Status>& statuses)
{
// declare the return status
Status ret(statuscodes::Good);
// declare the number of relative paths
size_t noOfRelativePaths = relativePathAddresses.size();
// resize the output parameters
results.resize(noOfRelativePaths);
statuses.resize(noOfRelativePaths);
// fill a vector containing all starting addresses
vector<Address> startingAddresses;
for (size_t i = 0; i < noOfRelativePaths && ret.isGood(); i++)
{
if (mask.isSet(i))
startingAddresses.push_back(*(relativePathAddresses[i].getStartingAddress()));
}
// resolve them (recursively!)
vector<ExpandedNodeId> startingAddressesResults;
vector<Status> startingAddressesStatuses;
ret = resolve(startingAddresses, startingAddressesResults, startingAddressesStatuses);
// update the results
for (size_t i = 0, j = 0; i < noOfRelativePaths && ret.isGood(); i++)
{
if (mask.isSet(i))
{
// update the results
results[i].startingExpandedNodeId = startingAddressesResults[j];
results[i].relativePath = relativePathAddresses[i].getRelativePath();
// update the statuses
statuses[i] = startingAddressesStatuses[j];
// update the mask (only resolved starting addresses should be processed further!)
if (statuses[i].isNotGood())
mask.unset(i);
// increment the index of the startingAddressesResults
j++;
}
}
return ret;
}
// TimeSlice Interface
void
dmz::EntityPluginDeadTimer::update_time_slice (const Float64 TimeDelta) {
ObjectModule *objMod (get_object_module ());
if (objMod && _hil) {
Mask state;
objMod->lookup_state (_hil, _defaultHandle, state);
state.unset (_deadState);
objMod->store_state (_hil, _defaultHandle, state);
}
}
/*!
\brief Gets state names.
\param[in] State Mask containing states to be named.
\param[out] name String to store found state names.
\return Returns dmz::True if all the states stored in \a State have names.
\note This function will find the names for as many states as possible. If the \a State
mask contains more than one state, the names are separated by the "|" character
(a.k.a. bitwise or operator).
*/
dmz::Boolean
dmz::Definitions::lookup_state_name (const Mask &State, String &name) const {
Boolean result (False);
Mask maskCopy (State);
if (_state.defs) {
name.flush ();
HashTableStringIterator it;
Mask *ptr = _state.defs->maskTable.get_first (it);
while (ptr) {
if (State & *ptr) {
if (!name) { name = it.get_hash_key (); }
else { name << " | " << it.get_hash_key (); }
maskCopy.unset (*ptr);
}
ptr = _state.defs->maskTable.get_next (it);
}
if (!maskCopy) { result = True; }
else if (_state.log) {
_state.log->error << "Unidentified state bits in: " << name << endl;
// << ", unknown bits: " << maskCopy << endl;
}
}
return result;
}
// TimeSlice Interface
void
dmz::EntityPluginGroundSimple::update_time_slice (const Float64 TimeDelta) {
ObjectModule *objMod (get_object_module ());
if ((_active > 0) && objMod && _hil && _defaultHandle) {
Vector pos, vel;
Matrix ori;
Mask state;
objMod->lookup_position (_hil, _defaultHandle, pos);
objMod->lookup_velocity (_hil, _defaultHandle, vel);
objMod->lookup_orientation (_hil, _defaultHandle, ori);
objMod->lookup_state (_hil, _defaultHandle, state);
const Vector OldPos (pos);
const Matrix OldOri (ori);
const Vector Up (0.0, 1.0, 0.0);
Vector point (pos), normal (Up);
Boolean airborn (False);
if (_find_point (pos, ori, point, normal)) {
Float64 Diff (pos.get_y () - point.get_y ());
Float64 Drop (EarthGravity64 * TimeDelta * TimeDelta);
if (Diff > Drop) { airborn = True; }
}
if (airborn) { state |= _airBornState; }
else { state.unset (_airBornState); }
if (_eventMod && _wasAirborn && !airborn) {
_eventMod->create_collision_event (_hil, 0);
}
_wasAirborn = airborn;
Float64 heading (0.0);
_move_entity (TimeDelta, airborn, pos, ori, vel, heading);
_validate_move (TimeDelta, airborn, OldPos, pos, ori, vel, heading);
if (_find_point (pos, ori, point, normal)) {
if ((point.get_y () > pos.get_y ()) || (point - pos).is_zero (0.01)) {
pos = point;
Matrix hm (Up, heading);
Matrix nmat (Up, normal);
ori = nmat * hm;
get_orthogonal_component (normal, vel, vel);
}
}
objMod->store_position (_hil, _defaultHandle, pos);
objMod->store_velocity (_hil, _defaultHandle, vel);
objMod->store_orientation (_hil, _defaultHandle, ori);
objMod->store_state (_hil, _defaultHandle, state);
Float64 target (_move.throttle + 0.3);
if (_move.turboModifier > 0.0) { target += 0.3; }
if (airborn) { target = (1.5 * _move.throttle) + 0.3; }
Float64 current (1.0);
objMod->lookup_scalar (_hil, _throttleHandle, current);
if (current > target) {
current -= 0.6 * TimeDelta;
if (current < target) { current = target; }
}
else if (current < target) {
current += 0.4 * TimeDelta;
if (current > target) { current = target; }
}
if (_isDead) { current = 0.0; }
objMod->store_scalar (_hil, _throttleHandle, current);
const Float64 Time (_time.get_frame_time ());
if ((_move.turboModifier > 0.0) && (Time > _move.turboEndTime)) {
_move.turboModifier = 0.0;
_move.turboRefillTime = Time + _move.turboRefillDuration;
}
}
}
void
dmz::InputModuleBasic::release_input_observer (
const Handle Channel,
const Mask EventMask,
InputObserver &obs) {
if (_inEvent) { _que_event (new ReleaseObserverStruct (Channel, EventMask, obs)); }
else {
_inEvent = True;
ChannelStruct *cs (_channelTable.lookup (Channel));
const Handle ObsHandle (obs.get_input_observer_handle ());
ObsStruct *os (_obsTable.lookup (ObsHandle));
if (cs && os) {
Mask *obsMask (os->table.lookup (Channel));
if (obsMask) {
Mask updateMask;
if (EventMask & LocalStateMask) {
if (cs->stateTable.remove (ObsHandle)) { obsMask->unset (LocalStateMask); }
}
if (EventMask & LocalAxisMask) {
if (cs->axisTable.remove (ObsHandle)) {
obsMask->unset (LocalAxisMask);
updateMask |= LocalAxisMask;
}
}
if (EventMask & LocalButtonMask) {
if (cs->buttonTable.remove (ObsHandle)) {
obsMask->unset (LocalButtonMask);
updateMask |= LocalButtonMask;
}
}
if (EventMask & LocalSwitchMask) {
if (cs->switchTable.remove (ObsHandle)) {
obsMask->unset (LocalSwitchMask);
updateMask |= LocalSwitchMask;
}
}
if (EventMask & LocalKeyMask) {
if (cs->keyTable.remove (ObsHandle)) {
obsMask->unset (LocalKeyMask);
updateMask |= LocalKeyMask;
}
}
if (EventMask & LocalMouseMask) {
if (cs->mouseTable.remove (ObsHandle)) {
obsMask->unset (LocalMouseMask);
updateMask |= LocalMouseMask;
}
}
if (EventMask & LocalDataMask) {
if (cs->dataTable.remove (ObsHandle)) {
obsMask->unset (LocalDataMask);
updateMask |= LocalDataMask;
}
}
if (cs->active && updateMask.is_set ()) {
_decrement_active_count (cs->ChannelHandle, updateMask, *os);
}
if (!obsMask->is_set ()) {
cs->activeTable.remove (os->ObsHandle);
if (os->table.remove (Channel)) { delete obsMask; obsMask = 0; }
if (os->table.get_count () == 0) {
if (_obsTable.remove (ObsHandle)) { delete os; os = 0; }
}
}
}
}
_inEvent = False;
_do_qued_events ();
}
}
void Resolver::processBrowsePathsResolutionResultTarget(
const TranslateBrowsePathsToNodeIdsResultTarget& target,
size_t rank,
vector<BrowsePath>& browsePaths,
Mask& mask,
vector<ExpandedNodeId>& results,
vector<Status>& statuses)
{
// check the target status
if (target.status.isBad())
{
logger_->error("Target %d could not be resolved: %s",
rank, target.status.toString().c_str());
statuses[rank] = target.status;
// we're finished with this target (unfortunately, because it failed),
// so unset the mask item
mask.unset(rank);
}
else
{
// check if only one ExpandedNodeId was found
// (if not, we cannot "resolve" the target)
if (target.expandedNodeIds.size() == 0)
{
// no matches, which would be unexpected since the status reported
// by the server was not Bad
statuses[rank] = UnexpectedError(
"Server reported a Good translation result but no"
"results were given");
logger_->error(statuses[rank]);
// we're finished with this target, so unset the mask item
mask.unset(rank);
}
else if (target.expandedNodeIds.size() == 1)
{
// one match was found for the browse path, just as we expected!
// we still need to check if the browse path was fully resolved:
if (target.status.isGood())
{
// update the result and status
results[rank] = target.expandedNodeIds[0];
statuses[rank] = statuses[0];
logger_->debug("Target %d was successfully resolved to:", rank);
logger_->debug(results[rank].toString());
// we're finished with this target, so unset the mask item
mask.unset(rank);
}
else if (target.opcUaStatusCode == OpcUa_UncertainReferenceOutOfServer)
{
logger_->debug("Target %d could not be fully resolved, there is an "
"out-of-server reference", rank);
// declare the remaining path index
uint32_t remainingIndex = target.remainingPathIndexes[0];
uint32_t noOfElements = browsePaths[rank].relativePath.size();
uint32_t maxIndex = noOfElements - 1;
logger_->debug("Remaining index: %d (max index: %d)", remainingIndex, maxIndex);
if (remainingIndex == 0 || remainingIndex >= maxIndex)
{
statuses[rank] = UnexpectedError(
uaf::format(
"Unexpected translation result returned by the server (StatusCode="
"UncertainReferenceOutOfServer, RemainingPathIndex=%d), while "
"the number of BrowsePath elements is %d",
remainingIndex, noOfElements));
logger_->error(statuses[rank]);
// we're finished with this target, so unset the mask item
mask.unset(rank);
}
else
{
// copy the remaining elements to a new vector
vector<RelativePathElement> newElements;
for (uint32_t i = remainingIndex; i < maxIndex; i++)
newElements.push_back(browsePaths[rank].relativePath[i]);
// set the new browse path based on the just created elements
browsePaths[rank] = BrowsePath(target.expandedNodeIds[0], newElements);
logger_->debug("New browse path: %s", browsePaths[rank].toString().c_str());
// we're not finished with this target, so leave the mask item 'set'
}
}
else
{
statuses[rank] = UnexpectedError(
uaf::format(
"Unexpected translation result (status reported by server: %s)",
target.status.toString().c_str()));
logger_->error(statuses[rank]);
// we're finished with this target, so unset the mask item
mask.unset(rank);
}
}
else
{
// we received multiple matches for a single browse path!
// This may be a valid result for a TranslateBrowsePathsToNodeIds service
// invocation, but not in this case since we're trying to resolve an address.
statuses[rank] = MultipleTranslationResultsError();
logger_->error(statuses[rank].toString());
// we're finished with this target, so unset the mask item
mask.unset(rank);
}
}
}
