MemoryViewer.cpp
Go to the documentation of this file.
1 #include "MemoryViewer.h"
2 
3 #include <QApplication>
4 #include <QBoxLayout>
5 #include <QCheckBox>
6 #include <QClipboard>
7 #include <QDialog>
8 #include <QGroupBox>
9 #include <QLabel>
10 #include <QLayout>
11 #include <QMenu>
12 #include <QSettings>
13 #include <QThread>
14 #include <QTimer>
15 
16 #include <Ice/Exception.h>
17 
18 #include <SimoxUtility/algorithm/get_map_keys_values.h>
19 #include <SimoxUtility/algorithm/string/string_tools.h>
20 
25 
27 
28 #include <RobotAPI/interface/armem/actions.h>
29 #include <RobotAPI/interface/armem/memory.h>
30 #include <RobotAPI/interface/armem/mns/MemoryNameSystemInterface.h>
42 
43 namespace armarx::armem::gui
44 {
45  MemoryViewer::MemoryViewer(QBoxLayout* updateWidgetLayout,
46  QGroupBox* memoryGroupBox,
47  QLayout* memoryGroupBoxParentLayout,
48  QGroupBox* instanceGroupBox,
49  QLayout* instanceGroupBoxParentLayout,
50  QBoxLayout* diskControlWidgetLayout,
51  QLabel* statusLabel)
52  {
53  Logging::setTag("MemoryViewer");
54 
55  this->statusLabel = statusLabel;
56  this->statusLabel->clear();
57 
58  statusLabel->setContextMenuPolicy(Qt::CustomContextMenu);
59  connect(statusLabel,
60  &QLabel::customContextMenuRequested,
61  [statusLabel](const QPoint& pos)
62  {
63  QMenu menu(statusLabel);
64  menu.addAction("Copy to clipboard",
65  [statusLabel]()
66  { QApplication::clipboard()->setText(statusLabel->text()); });
67  menu.addAction("Clear status", [statusLabel]() { statusLabel->clear(); });
68  menu.exec(statusLabel->mapToGlobal(pos));
69  });
70 
71 
72  // Update timer
73  this->updateWidgetLayout = updateWidgetLayout;
75  updateWidgetLayout->insertWidget(0, updateWidget);
76 
77  periodicUpdateTimer = new QTimer(this);
78  periodicUpdateTimer->setInterval(1000 / 60); // Keep this stable.
79 
80  // Memory View
81  auto retrieveEntityInfo = [this](const MemoryID& entityID) -> PredictionWidget::EntityInfo
82  {
83  client::Reader reader = memoryReaders.at(entityID.memoryName);
84  if (!reader.predictionPrx)
85  {
86  std::stringstream sstream;
87  sstream << "Predictions are not available for memory '" << entityID.memoryName
88  << "'.";
89  this->statusLabel->setText(QString::fromStdString(sstream.str()));
90  return {};
91  }
92 
93  std::map<MemoryID, std::vector<PredictionEngine>> predictionEngines;
94  client::QueryResult queryResult;
95  try
96  {
97  predictionEngines = reader.getAvailablePredictionEngines();
98  queryResult = reader.queryMemoryIDs({entityID}, armem::query::DataMode::NoData);
99  }
100  catch (const Ice::LocalException& e)
101  {
102  std::stringstream sstream;
103  sstream << "Could not get prediction engines and type from memory: " << e.what();
104  this->statusLabel->setText(QString::fromStdString(sstream.str()));
105  return {nullptr, {}};
106  }
107 
108  aron::type::ObjectPtr entityType;
109  if (queryResult.success)
110  {
111  auto* providerSegment = queryResult.memory.findProviderSegment(entityID);
112  if (providerSegment != nullptr)
113  {
114  entityType = providerSegment->aronType();
115  }
116  }
118  .type = entityType,
119  .engines = armem::accumulateEntriesContainingID(predictionEngines, entityID)};
120  };
121  memoryGroup = new armem::gui::MemoryGroupBox(std::move(retrieveEntityInfo));
122 
123  armarx::gui::replaceWidget(memoryGroupBox, memoryGroup, memoryGroupBoxParentLayout);
124  ARMARX_CHECK_NULL(memoryGroupBox);
125 
126  // Instance View
128  armarx::gui::replaceWidget(instanceGroupBox, instanceGroup, instanceGroupBoxParentLayout);
129  this->instanceGroup->setStatusLabel(statusLabel);
130  ARMARX_CHECK_NULL(instanceGroupBox);
131 
132  // Disk Control
133  if (diskControlWidgetLayout)
134  {
135  this->diskControlLayout = diskControlWidgetLayout;
137  diskControlWidgetLayout->addWidget(diskControl);
138  }
139 
140  // Connections
141  connect(diskControl,
143  this,
145  connect(diskControl,
147  this,
149 
150  connect(this, &This::connected, this, &This::startQueries);
151  connect(this, &This::connected, this, &This::startPeriodicUpdateTimer);
152  connect(updateWidget, &armem::gui::PeriodicUpdateWidget::update, this, &This::startQueries);
153  connect(
154  updateWidget, &armem::gui::PeriodicUpdateWidget::collapseAll, this, &This::collapseAll);
155 
156  connect(periodicUpdateTimer, &QTimer::timeout, this, &This::updateListOfActiveMemories);
157  connect(periodicUpdateTimer, &QTimer::timeout, this, &This::processQueryResults);
158 
159  connect(memoryGroup->queryWidget(),
161  this,
163  connect(memoryGroup->queryWidget(),
165  this,
167  connect(memoryGroup->queryWidget(),
169  this,
171 
172 
173  connect(memoryGroup->predictionWidget(),
175  this,
177  connect(
179 
180  connect(this, &This::memoryDataChanged, this, &This::updateMemoryTree);
181  connect(memoryGroup->tree(),
183  this,
185 
186  connect(memoryGroup->tree(),
188  this,
190  connect(memoryGroup->tree(),
192  this,
194  connect(instanceGroup,
196  this,
198  connect(instanceGroup->view,
200  this,
202  connect(instanceGroup->view,
204  this,
206  }
207 
208  void
209  MemoryViewer::setLogTag(const std::string& _tag) // Leading _ silences a warning
210  {
211  Logging::setTag(_tag);
212  }
213 
214  void
216  {
217  if (mnsName.size() > 0)
218  {
219  component.usingProxy(mnsName);
220  }
221  if (debugObserverName.size() > 0)
222  {
223  component.usingProxy(debugObserverName);
224  }
225 
226  is_initialized = true;
227  emit initialized();
228  }
229 
230  void
231  MemoryViewer::onConnect(ManagedIceObject& component)
232  {
233  if (not mnsName.empty())
234  {
235  armem::mns::MemoryNameSystemInterfacePrx mnsProxy;
236  component.getProxy(mnsProxy, mnsName);
237  mns = client::MemoryNameSystem(mnsProxy);
238 
239  const bool update = true;
242  }
243  // DebugObserver is optional (check for null on every call)
244  if (not debugObserverName.empty())
245  {
246  component.getProxy(debugObserver, debugObserverName, false, "", false);
247  }
248 
250 
251  is_connected = true;
252  emit connected();
253  }
254 
255  void
256  MemoryViewer::onDisconnect(ManagedIceObject&)
257  {
258  periodicUpdateTimer->stop();
260 
261  is_connected = false;
262 
263  emit disconnected();
264  }
265 
266  void
267  MemoryViewer::collapseAll()
268  {
269  memoryGroup->tree()->collapseAll();
270  }
271 
272  void
273  MemoryViewer::startPeriodicUpdateTimer()
274  {
275  periodicUpdateTimer->start();
276  }
277 
278  const armem::wm::Memory*
279  MemoryViewer::getSingleMemoryData(const std::string& memoryName)
280  {
281  auto it = memoryData.find(memoryName);
282  if (it == memoryData.end())
283  {
284  std::stringstream ss;
285  ss << "Memory name '" << memoryName << "' is unknown. Known are: "
286  << simox::alg::join(simox::alg::get_keys(memoryData), ", ");
287  statusLabel->setText(QString::fromStdString(ss.str()));
288  return nullptr;
289  }
290  /*else if (not it->second.has_value())
291  {
292  return nullptr;
293  }*/
294  else
295  {
296  //return &it->second.value();
297  return &it->second;
298  }
299  }
300 
301  void
303  {
304  TIMING_START(MemoryStore);
305 
306  auto enabledMemories = memoryGroup->queryWidget()->getEnabledMemories();
307  for (auto& [name, reader] : memoryReaders)
308  {
309  // skip if memory should not be queried
310  if (std::find(enabledMemories.begin(), enabledMemories.end(), name) ==
311  enabledMemories.end())
312  {
313  continue;
314  }
315 
316  // Query memory
317  auto q_res = reader.query(memoryGroup->queryInput());
318  if (q_res.success)
319  {
320  server::dto::DirectlyStoreInput input;
321  input.memory = q_res.toIce().memory;
322  reader.directlyStore(input);
323  }
324  else
325  {
326  std::string s = "Query of memory " + name + " was unsuccessful.";
327  statusLabel->setText(QString::fromStdString(s));
328  }
329  }
330 
331  TIMING_END_STREAM(MemoryStore, ARMARX_VERBOSE);
332  }
333 
334  void
336  {
337 
338  TIMING_START(MemoryStartRecording);
339 
340  auto enabledMemories = memoryGroup->queryWidget()->getEnabledMemories();
341  for (auto& [name, reader] : memoryReaders)
342  {
343  // skip if memory should not be queried
344  if (std::find(enabledMemories.begin(), enabledMemories.end(), name) ==
345  enabledMemories.end())
346  {
347  continue;
348  }
349  reader.startRecording();
350  }
351 
352  TIMING_END_STREAM(MemoryStartRecording, ARMARX_VERBOSE);
353  }
354 
355  void
357  {
358 
359  TIMING_START(MemoryStopRecording);
360 
361  auto enabledMemories = memoryGroup->queryWidget()->getEnabledMemories();
362  for (auto& [name, reader] : memoryReaders)
363  {
364  // skip if memory should not be queried
365  if (std::find(enabledMemories.begin(), enabledMemories.end(), name) ==
366  enabledMemories.end())
367  {
368  continue;
369  }
370  reader.stopRecording();
371  }
372 
373  TIMING_END_STREAM(MemoryStopRecording, ARMARX_VERBOSE);
374  }
375 
376  void
378  {
379 
381  auto now = armem::Time::Now();
382 
383  const std::string memoryIDStr = memoryGroup->commitWidget()->getMemoryID();
384  const std::string aronJSONStr = memoryGroup->commitWidget()->getAronJSON();
385 
386  ARMARX_INFO << "Committing to " << memoryIDStr << " the data: " << aronJSONStr;
387 
388  MemoryID memId(memoryIDStr);
389 
390  if (!memId.hasEntityName())
391  {
392  ARMARX_WARNING << "The entered MemoryID '" << memoryIDStr
393  << "' does not contain an entity.";
394  }
395  else
396  {
397 
398  nlohmann::json json = nlohmann::json::parse(aronJSONStr);
399 
400  // ToDo: multiple objects
401  auto aron =
403  json);
404 
405  if (const auto& it = memoryWriters.find(memId.memoryName); it == memoryWriters.end())
406  {
407  ARMARX_WARNING << "No memory with name '" << memId.memoryName
408  << "' available for commit.";
409  }
410  else
411  {
412  armem::Commit comm;
413  auto& entityUpdate = comm.add();
414  entityUpdate.entityID = memId;
415  entityUpdate.confidence = 1.0;
416  entityUpdate.instancesData = {aron};
417  entityUpdate.referencedTime = now;
418  it->second.commit(comm);
419  }
420  }
421 
423  }
424 
425  void
426  MemoryViewer::storeOnDisk(QString directory)
427  {
428  TIMING_START(MemoryExport)
429 
430  std::string status;
431  std::vector<wm::Memory> memoryDataVec = simox::alg::get_values(memoryData);
432  diskControl->storeOnDisk(directory, memoryDataVec, &status);
433 
434  statusLabel->setText(QString::fromStdString(status));
435  TIMING_END_STREAM(MemoryExport, ARMARX_VERBOSE)
436  }
437 
438  void
439  MemoryViewer::loadFromDisk(QString directory)
440  {
441 
442  QThread* thread = new QThread;
443  QObject* worker = new QObject;
444 
445  worker->moveToThread(thread);
446 
447  connect(thread,
448  &QThread::started,
449  worker,
450  [this, thread, worker, directory]()
451  {
452  ARMARX_IMPORTANT << "Loading Snapshots from Disk";
453 
455  h.loadFromDisk(directory.toStdString());
456 
457  QTimer::singleShot(0, this, [this, thread, worker]()
458  {
459  ARMARX_INFO << "After other class";
460  emit memoryDataChanged();
461 
462  thread->quit();
463  thread->wait();
464 
465  worker->deleteLater();
466  thread->deleteLater();
467  });
468  });
469 
470  thread->start();
471  }
472 
473  void
474  MemoryViewer::startQueries()
475  {
476  startDueQueries();
477  }
478 
479  void
480  MemoryViewer::processQueryResults()
481  {
482  const std::map<std::string, client::QueryResult> results = collectQueryResults();
483 
484  if (results.size() > 0)
485  {
486  // this means we have actual query results
487  int errorCount = 0;
488  applyQueryResults(results, &errorCount);
489  emit memoryDataChanged();
490  updateStatusLabel(errorCount);
491  }
492  }
493 
494  void
495  MemoryViewer::updateStatusLabel(int errorCount)
496  {
497  // Code to output status label information
498  if (statusLabel and errorCount > 0)
499  {
500  auto now = std::chrono::system_clock::now();
501  auto in_time_t = std::chrono::system_clock::to_time_t(now);
502 
503  std::stringstream ss;
504  ss << "Last update: " << std::put_time(std::localtime(&in_time_t), "%Y-%m-%d %X");
505  ss << "\nThe query produced " << errorCount << " errors! Please check log.";
506 
507  statusLabel->setText(QString::fromStdString(ss.str()));
508  }
509  }
510 
511  void
512  MemoryViewer::startDueQueries()
513  {
514 
515  armem::client::QueryInput input = memoryGroup->queryInput();
516  int recursionDepth = memoryGroup->queryWidget()->queryLinkRecursionDepth();
517 
518  // Can't use a structured binding here because you can't capture those in a lambda
519  // according to the C++ standard.
520  auto enabledMemories = memoryGroup->queryWidget()->getEnabledMemories();
521  for (const auto& pair : memoryReaders)
522  {
523  // skip if memory should not be queried
524  if (std::find(enabledMemories.begin(), enabledMemories.end(), pair.first) ==
525  enabledMemories.end())
526  {
527  continue;
528  }
529 
530  const auto& name = pair.first;
531  const auto& reader = pair.second;
532 
533  // skip if query already running
534  if (runningQueries.count(name) != 0)
535  {
536  continue;
537  }
538 
539  // You could pass the query function itself to async here,
540  // but that caused severe template headaches when I tried it.
541  runningQueries[name] = std::async(
542  std::launch::async,
543  [reader, input, recursionDepth, this]()
544  {
545  // Can't resolve MemoryLinks without data
546  return recursionDepth == 0 || input.dataMode == armem::query::DataMode::NoData
547  ? reader.query(input.toIce())
548  : reader.query(input.toIce(), mns, recursionDepth);
549  });
550  }
551  }
552 
553  std::map<std::string, client::QueryResult>
554  MemoryViewer::collectQueryResults()
555  {
556 
557  TIMING_START(tCollectQueryResults)
558 
559  std::map<std::string, client::QueryResult> results;
560  for (auto it = runningQueries.begin(); it != runningQueries.end();)
561  {
562  const std::string& name = it->first;
563  std::future<armem::query::data::Result>* queryPromise = &it->second;
564 
565  if (queryPromise->wait_for(std::chrono::seconds(0)) == std::future_status::ready)
566  {
567  if (auto jt = memoryReaders.find(name); jt != memoryReaders.end())
568  {
569  try
570  {
571  results[name] = client::QueryResult::fromIce(queryPromise->get());
572  }
573  catch (const Ice::ConnectionRefusedException&)
574  {
575  // Server is gone (MNS did not know about it yet) => Skip result.
576  }
577  }
578  // else: Server is gone (MNS knew about it) => Skip result.
579 
580  // Promise is completed => Clean up in any case.
581  it = runningQueries.erase(it);
582  }
583  else
584  {
585  ++it; // Uncompleted => Keep.
586  }
587  }
588 
589  TIMING_END_STREAM(tCollectQueryResults, ARMARX_VERBOSE)
590  if (debugObserver)
591  {
592  debugObserver->begin_setDebugChannel(
594  {
595  {"t Collect Query Results [ms]",
596  new Variant(tCollectQueryResults.toMilliSecondsDouble())},
597  {"# Collected Query Results", new Variant(static_cast<int>(results.size()))},
598  });
599  }
600 
601  return results;
602  }
603 
604  void
605  MemoryViewer::applyQueryResults(const std::map<std::string, client::QueryResult>& results,
606  int* outErrorCount)
607  {
608  TIMING_START(tProcessQueryResults)
609  for (const auto& [name, result] : results)
610  {
611  if (result.success)
612  {
613  memoryData[name] = std::move(result.memory);
614  }
615  else
616  {
617  ARMARX_WARNING << "Querying memory server '" << name << "' produced an error: \n"
618  << result.errorMessage;
619  if (outErrorCount)
620  {
621  outErrorCount++;
622  }
623  }
624  }
625 
626  // Perhaps remove entries
627  auto enabledMemories = memoryGroup->queryWidget()->getEnabledMemories();
628  for (auto it = memoryData.begin(); it != memoryData.end();)
629  {
630  // Drop all entries in memoryData which are not in memoryReaders anymore.
631  if (memoryReaders.count(it->first) == 0)
632  {
634  {
635  it = memoryData.erase(it);
636  }
637  else
638  {
639  ++it;
640  }
641  continue;
642  }
643 
644  // Drop all entries that are not enabled by user (which means that there is no query result)
645  if (std::find(enabledMemories.begin(), enabledMemories.end(), it->first) ==
646  enabledMemories.end())
647  {
649  {
650  it = memoryData.erase(it);
651  }
652  else
653  {
654  ++it;
655  }
656  continue;
657  }
658 
659  // Memory found
660  ++it;
661  }
662 
663  TIMING_END_STREAM(tProcessQueryResults, ARMARX_VERBOSE)
664  if (debugObserver)
665  {
666  debugObserver->begin_setDebugChannel(
668  {
669  {"t Process Query Results [ms]",
670  new Variant(tProcessQueryResults.toMilliSecondsDouble())},
671  {"# Processed Query Results", new Variant(static_cast<int>(results.size()))},
672  });
673  }
674  }
675 
676  void
678  {
679  const armem::wm::Memory* data = getSingleMemoryData(selectedID.memoryName);
680  if (data)
681  {
682  if (not selectedID.hasEntityName())
683  {
684  return;
685  }
686  armem::MemoryID id = selectedID;
687  const armem::wm::EntitySnapshot* snapshot = nullptr;
688  if (not id.hasTimestamp())
689  {
690  const armem::wm::Entity& entity = data->getEntity(id);
691  if (entity.empty())
692  {
693  return;
694  }
695  snapshot = &entity.getLatestSnapshot();
696  id.timestamp = snapshot->time();
697  }
698  if (not id.hasInstanceIndex())
699  {
700  if (not snapshot)
701  {
702  try
703  {
704  snapshot = &data->getSnapshot(id);
705  }
706  catch (const armem::error::ArMemError& e)
707  {
708  if (statusLabel)
709  {
710  statusLabel->setText(e.what());
711  }
712  }
713  }
714  if (snapshot && snapshot->size() > 0)
715  {
716  id.instanceIndex = 0;
717  }
718  }
719  if (id.hasInstanceIndex())
720  {
721  instanceGroup->view->update(id, *data);
722  }
723  }
724  }
725 
726  void
728  {
729  // ARMARX_IMPORTANT << "Resolving memory ID: " << id;
730 
731  auto handleError = [this](const std::string& msg)
732  {
733  statusLabel->setText(QString::fromStdString(msg));
734  ARMARX_WARNING << msg;
735  };
736 
737  if (id.memoryName.empty())
738  {
739  handleError("Memory name is empty.");
740  }
741 
742  aron::type::ObjectPtr segmentType;
743  std::optional<wm::EntityInstance> instance;
744  try
745  {
746  if (const wm::Memory* data = getSingleMemoryData(id.memoryName))
747  {
748  segmentType = data->getProviderSegment(id).aronType();
749 
750  if (id.hasInstanceIndex())
751  {
752  instance = data->getInstance(id);
753  }
754  else if (id.hasTimestamp())
755  {
756  instance = data->getSnapshot(id).getInstance(0);
757  }
758  else
759  {
760  instance = data->getEntity(id).getLatestSnapshot().getInstance(0);
761  }
762  }
763  }
764  catch (const armem::error::ArMemError&)
765  {
766  // May be handled by remote lookup
767  }
768 
769  if (not instance)
770  {
771  try
772  {
773  // Resolve remotely (may still fail, returns an optional).
774  instance = mns.resolveEntityInstance(id);
775  }
776  catch (const armem::error::ArMemError& e)
777  {
778  ARMARX_WARNING << e.what();
779  statusLabel->setText(e.what());
780  }
781  }
782 
783  if (instance)
784  {
785  auto* view = new InstanceView();
787  view->update(*instance, segmentType);
788  //instanceGroup->view->addInstanceView(*instance, segmentType);
789  }
790  else
791  {
792  // ToDo: Propagate error back to highlight selected entry in red
793  }
794  }
795 
796  void
797  MemoryViewer::updateListOfActiveMemories()
798  {
799  if (is_connected and mns) // mns must be connected and mns must be available
800  {
801  try
802  {
805 
806  std::vector<std::string> activeMemoryNames;
807 
808  // add all active memories to update list
810  memoryReaders.end(),
811  std::back_inserter(activeMemoryNames),
812  [](const auto& p) { return p.first; });
813 
814  TIMING_START(GuiUpdateAvailableMemories);
815  memoryGroup->queryWidget()->update(activeMemoryNames);
816  TIMING_END_STREAM(GuiUpdateAvailableMemories, ARMARX_VERBOSE);
817  }
818  catch (...)
819  {
820  // MNS was killed/stopped
821  // ignore?!
822  }
823  }
824  else
825  {
827  << deactivateSpam()
828  << "MNS not ready yet. Skip update of available memories in query widget.";
829  }
830  }
831 
832  void
833  MemoryViewer::updateMemoryTree()
834  {
835  //TODO: currently called automatically, even without enabling auto update
836  std::map<std::string, const armem::wm::Memory*> memoriesToUpdate;
837 
838  auto checkboxStates = memoryGroup->queryWidget()->getAvailableMemoryStates();
839  for (auto& [name, data] : memoryData)
840  {
841  if (checkboxStates[name] == QueryWidget::ActiveMemoryState::FoundAndChecked)
842  {
843  ARMARX_INFO << "updating memory tree for " << name;
844  memoriesToUpdate[name] = &data;
845  }
846  }
847 
848  TIMING_START(GuiUpdateMemoryTree)
849  memoryGroup->tree()->update(memoriesToUpdate);
850  TIMING_END_STREAM(GuiUpdateMemoryTree, ARMARX_VERBOSE)
851 
852  if (debugObserver)
853  {
854  try
855  {
856  debugObserver->setDebugDatafield(
858  "GUI Update [ms]",
859  new Variant(GuiUpdateMemoryTree.toMilliSecondsDouble()));
860  }
861  catch (const Ice::Exception&)
862  {
863  // Ignore ...
864  }
865  }
866  }
867 
868  void
870  QWidget* parent,
871  const QPoint& pos,
872  QMenu* menu)
873  {
874  // Called if we have to stop because of an error.
875  auto showMenu = [menu, pos]()
876  {
877  if (menu)
878  menu->exec(pos);
879  };
880 
881  if (memoryID == MemoryID())
882  {
883  // Empty MemoryID, don't try to generate actions.
884  showMenu();
885  return;
886  }
887 
888  mns::dto::MemoryServerInterfaces prx;
889  try
890  {
891  prx = mns.resolveServer(memoryID);
892  }
893  catch (const error::CouldNotResolveMemoryServer& e)
894  {
895  statusLabel->setText(
896  QString::fromStdString(e.makeMsg(memoryID, "Could not resolve memory server.")));
897  showMenu();
898  return;
899  }
900 
901  if (!prx.actions)
902  {
903  std::stringstream ss;
904  ss << "Memory server " << memoryID << " does not support actions or is offline.";
905  statusLabel->setText(QString::fromStdString(ss.str()));
906  showMenu();
907  return;
908  }
909 
910  actions::GetActionsOutputSeq result;
911  try
912  {
913  result = prx.actions->getActions({{armarx::toIce<data::MemoryID>(memoryID)}});
914  }
915  catch (const Ice::LocalException& e)
916  {
917  std::stringstream ss;
918  ss << "Could not get actions for " << memoryID << ".";
919  statusLabel->setText(QString::fromStdString(ss.str()));
920  showMenu();
921  return;
922  }
923 
924  if (result.size() == 0)
925  {
926  showMenu();
927  return;
928  }
929  auto builder = ActionsMenuBuilder(
930  memoryID,
931  parent,
932  [this, prx](const MemoryID& memoryID, const actions::ActionPath& path)
933  {
934  actions::data::ExecuteActionOutputSeq result;
935  try
936  {
937  result = prx.actions->executeActions(
938  {{armarx::toIce<armem::data::MemoryID>(memoryID), path}});
939  }
940  catch (const Ice::LocalException& e)
941  {
942  std::stringstream ss;
943  ss << "Failed to execute action: " << e.what();
944  statusLabel->setText(QString::fromStdString(ss.str()));
945  }
946 
947  for (const auto& [success, errorMessage] : result)
948  {
949  if (not success)
950  {
951  std::stringstream ss;
952  ss << "Failed to execute action: " << errorMessage;
953  statusLabel->setText(QString::fromStdString(ss.str()));
954  ARMARX_WARNING << ss.str();
955  }
956  }
957  });
958 
959  QMenu* actionsMenu = builder.buildActionsMenu(result[0]);
960  if (menu == nullptr)
961  {
962  actionsMenu->exec(pos);
963  }
964  else
965  {
966  menu->addMenu(actionsMenu);
967  menu->exec(pos);
968  }
969  }
970 
971  void
973  const aron::type::ObjectPtr& entityType,
975  const std::string& engineID)
976  {
977 
978  std::stringstream errorStream;
979  auto showError = [this, &errorStream]()
980  { statusLabel->setText(QString::fromStdString(errorStream.str())); };
981 
982  if (!entityID.hasEntityName() || entityID.hasGap())
983  {
984  errorStream << "Could not convert " << entityID << " to valid entity ID.";
985  showError();
986  return;
987  }
988  if (memoryReaders.find(entityID.memoryName) == memoryReaders.end())
989  {
990  errorStream << "Not connected to memory '" << entityID.memoryName
991  << "', cannot make prediction.";
992  showError();
993  return;
994  }
995  client::Reader reader = memoryReaders.at(entityID.memoryName);
996  if (!reader.predictionPrx)
997  {
998  errorStream << "Predictions are not available for memory '" << entityID.memoryName
999  << "'.";
1000  showError();
1001  return;
1002  }
1003  PredictionRequest request;
1004  request.snapshotID = entityID.withTimestamp(timestamp);
1005  request.predictionSettings.predictionEngineID = engineID;
1006  PredictionResult result;
1007  try
1008  {
1009  result = reader.predict({request}).at(0);
1010  }
1011  catch (const Ice::LocalException& e)
1012  {
1013  errorStream << "Could not make prediction request: " << e.what();
1014  showError();
1015  return;
1016  }
1017 
1018  if (!result.success)
1019  {
1020  errorStream << "Prediction failed: " << result.errorMessage;
1021  showError();
1022  return;
1023  }
1024 
1025  auto* view = new AronDataView();
1026  instanceGroup->view->addDataView(view);
1027  view->update(result.prediction, entityType);
1028  }
1029 
1030  const static std::string CONFIG_KEY_MEMORY = "MemoryViewer.MemoryNameSystem";
1031  const static std::string CONFIG_KEY_DEBUG_OBSERVER = "MemoryViewer.DebugObserverName";
1032 
1033  void
1034  MemoryViewer::loadSettings(QSettings* settings)
1035  {
1036  mnsName = settings->value(QString::fromStdString(CONFIG_KEY_MEMORY), "MemoryNameSystem")
1037  .toString()
1038  .toStdString();
1040  settings->value(QString::fromStdString(CONFIG_KEY_DEBUG_OBSERVER), "DebugObserver")
1041  .toString()
1042  .toStdString();
1043  }
1044 
1045  void
1046  MemoryViewer::saveSettings(QSettings* settings)
1047  {
1048  settings->setValue(QString::fromStdString(CONFIG_KEY_MEMORY),
1049  QString::fromStdString(mnsName));
1050  settings->setValue(QString::fromStdString(CONFIG_KEY_DEBUG_OBSERVER),
1051  QString::fromStdString(debugObserverName));
1052  }
1053 
1054  void
1056  {
1057  dialog->addProxyFinder<armarx::armem::mns::MemoryNameSystemInterfacePrx>(
1058  {CONFIG_KEY_MEMORY, "MemoryNameSystem", "MemoryNameSystem"});
1060  {CONFIG_KEY_DEBUG_OBSERVER, "Debug Observer", "DebugObserver"});
1061  }
1062 
1063  void
1065  {
1066  mnsName = dialog->getProxyName(CONFIG_KEY_MEMORY);
1067  if (mnsName.empty())
1068  {
1069  mnsName = "MemoryNameSystem";
1070  }
1071  debugObserverName = dialog->getProxyName(CONFIG_KEY_DEBUG_OBSERVER);
1072  }
1073 
1074 } // namespace armarx::armem::gui
armarx::armem::detail::SuccessHeader::success
bool success
Definition: SuccessHeader.h:19
armarx::armem::client::MemoryNameSystem::resolveServer
mns::dto::MemoryServerInterfaces resolveServer(const MemoryID &memoryID)
Resolve the given memory server for the given memory ID.
Definition: MemoryNameSystem.cpp:116
armarx::armem::gui::disk::ControlWidget::storeOnDisk
void storeOnDisk(QString directory, const std::vector< wm::Memory > memoryData, std::string *outStatus=nullptr)
Definition: ControlWidget.cpp:82
armarx::armem::gui::disk::ControlWidget
Definition: ControlWidget.h:19
armarx::armem::base::detail::MemoryContainerBase::empty
bool empty() const
Definition: MemoryContainerBase.h:41
armarx::armem::client::Reader
Reads data from a memory server.
Definition: Reader.h:24
ARMARX_VERBOSE
#define ARMARX_VERBOSE
Definition: Logging.h:187
TIMING_START
#define TIMING_START(name)
Definition: TimeUtil.h:289
armarx::armem::gui::PeriodicUpdateWidget::collapseAll
void collapseAll()
armarx::armem::gui::MemoryViewer::updateWidget
armem::gui::PeriodicUpdateWidget * updateWidget
Definition: MemoryViewer.h:152
armarx::armem::PredictionRequest
Definition: Prediction.h:48
armarx::armem::gui::instance::InstanceView::update
void update(const MemoryID &id, const wm::Memory &memory)
Definition: InstanceView.cpp:62
armarx::armem::client::QueryResult::memory
wm::Memory memory
The slice of the memory that matched the query.
Definition: Query.h:58
armarx::armem::base::detail::GetFindProviderSegmentMixin::findProviderSegment
auto * findProviderSegment(const MemoryID &providerSegmentID)
Retrieve a provider segment.
Definition: lookup_mixins.h:474
armarx::armem::gui::PredictionWidget::EntityInfo::type
aron::type::ObjectPtr type
Definition: PredictionWidget.h:51
armarx::gui::LifecycleClient::onDisconnect
virtual void onDisconnect()
Definition: lifecycle.cpp:92
ActionsMenuBuilder.h
ARMARX_IMPORTANT
#define ARMARX_IMPORTANT
Definition: Logging.h:190
armarx::armem::Commit
A bundle of updates to be sent to the memory.
Definition: Commit.h:89
armarx::ProxyType::component
@ component
armarx::armem::gui::MemoryViewer::updateInstanceTree
void updateInstanceTree(const armem::MemoryID &selectedID)
Definition: MemoryViewer.cpp:677
armarx::armem::gui::instance::DataView::memoryIdResolutionRequested
void memoryIdResolutionRequested(const MemoryID &id)
armarx::armem::gui::MemoryViewer::is_connected
std::atomic_bool is_connected
Definition: MemoryViewer.h:172
armarx::armem::gui::MemoryViewer::debugObserver
DebugObserverInterfacePrx debugObserver
Definition: MemoryViewer.h:165
armarx::armem::accumulateEntriesContainingID
std::vector< ValueT > accumulateEntriesContainingID(const std::map< MemoryID, ValueT > &idMap, const MemoryID &id)
Return all values of keys containing the given ID.
Definition: container_maps.h:261
armarx::armem::base::detail::GetLatestSnapshotMixin::getLatestSnapshot
auto & getLatestSnapshot(int snapshotIndex=0)
Retrieve the latest entity snapshot.
Definition: lookup_mixins.h:199
armarx::armem::gui::MemoryViewer::startLTMRecording
void startLTMRecording()
Definition: MemoryViewer.cpp:335
armarx::core::time::DateTime::Now
static DateTime Now()
Definition: DateTime.cpp:51
armarx::armem::gui::QueryWidget::storeInLTM
void storeInLTM()
armarx::armem::gui::MemoryViewer::readConfigDialog
void readConfigDialog(SimpleConfigDialog *dialog)
Definition: MemoryViewer.cpp:1064
armarx::armem::gui::MemoryViewer::connected
void connected()
armarx::armem::gui::InstanceGroupBox
instance::GroupBox InstanceGroupBox
Definition: GroupBox.h:46
MemoryHandler.h
armarx::armem::gui::MemoryViewer::diskControlLayout
QLayout * diskControlLayout
Definition: MemoryViewer.h:154
armarx::armem::PredictionRequest::predictionSettings
PredictionSettings predictionSettings
Definition: Prediction.h:51
armarx::armem::gui::memory::GroupBox::queryInput
armem::client::QueryInput queryInput() const
Definition: GroupBox.cpp:113
armarx::aron::data::converter::AronNlohmannJSONConverter::ConvertFromNlohmannJSONObject
static data::DictPtr ConvertFromNlohmannJSONObject(const nlohmann::json &, const armarx::aron::Path &p={})
Definition: NLohmannJSONConverter.cpp:25
armarx::armem::gui::QueryWidget::stopRecording
void stopRecording()
armarx::armem::client::Reader::predictionPrx
server::PredictingMemoryInterfacePrx predictionPrx
Definition: Reader.h:228
armarx::armem::gui::MemoryViewer::commit
void commit()
Definition: MemoryViewer.cpp:377
armarx::armem::gui::PeriodicUpdateWidget
Definition: PeriodicUpdateWidget.h:14
armarx::armem::error::ArMemError
Base class for all exceptions thrown by the armem library.
Definition: ArMemError.h:18
armarx::armem::gui::disk::ControlWidget::requestedStoreOnDisk
void requestedStoreOnDisk(QString directory)
armarx::armem::client::MemoryNameSystem::resolveEntityInstance
std::optional< wm::EntityInstance > resolveEntityInstance(const MemoryID &id)
Resolve a memory ID to an EntityInstance.
Definition: MemoryNameSystem.cpp:459
armarx::armem::gui::ActionsMenuBuilder
Definition: ActionsMenuBuilder.h:11
ltm.h
armarx::armem::gui::MemoryViewer::resolveMemoryID
void resolveMemoryID(const MemoryID &id)
Definition: MemoryViewer.cpp:727
armarx::armem::client::QueryResult
Result of a QueryInput.
Definition: Query.h:50
armarx::armem::gui::MemoryViewer::runningQueries
std::map< std::string, std::future< armem::query::data::Result > > runningQueries
Definition: MemoryViewer.h:145
armarx::armem::gui::MemoryHandler
Definition: MemoryHandler.h:9
armarx::armem::gui::PeriodicUpdateWidget::update
void update()
armarx::armem::PredictionResult
Definition: Prediction.h:57
armarx::armem::gui::ActionsMenuBuilder::buildActionsMenu
QMenu * buildActionsMenu(actions::data::GetActionsOutput &actionsOutput)
Definition: ActionsMenuBuilder.cpp:16
SimpleConfigDialog.h
armarx::armem::gui::MemoryViewer::instanceTreeUpdated
void instanceTreeUpdated()
armarx::armem::gui::instance::DataView::actionsMenuRequested
void actionsMenuRequested(const MemoryID &memoryID, QWidget *parent, const QPoint &pos, QMenu *menu)
armarx::gui::replaceWidget
void replaceWidget(WidgetT *&old, QWidget *neu, QLayout *parentLayout)
Definition: gui_utils.h:34
MemoryViewer.h
armarx::armem::gui::MemoryViewer::writeConfigDialog
void writeConfigDialog(SimpleConfigDialog *dialog)
Definition: MemoryViewer.cpp:1055
armarx::gui::LifecycleClient::onInit
virtual void onInit()
Definition: lifecycle.cpp:82
armarx::armem::gui::MemoryViewer::storeOnDisk
void storeOnDisk(QString directory)
Definition: MemoryViewer.cpp:426
TIMING_END_STREAM
#define TIMING_END_STREAM(name, os)
Definition: TimeUtil.h:310
NLohmannJSONConverter.h
armarx::armem::gui::instance::GroupBox::setStatusLabel
void setStatusLabel(QLabel *statusLabel)
Definition: GroupBox.cpp:37
armarx::armem::gui::MemoryViewer::mnsName
std::string mnsName
Definition: MemoryViewer.h:137
armarx::armem::gui::InstanceView
instance::InstanceView InstanceView
Definition: InstanceView.h:56
armarx::armem::client::Reader::queryMemoryIDs
QueryResult queryMemoryIDs(const std::vector< MemoryID > &ids, armem::query::DataMode dataMode=armem::query::DataMode::WithData) const
Query a specific set of memory IDs.
Definition: Reader.cpp:324
armarx::armem::client::Reader::predict
std::vector< PredictionResult > predict(const std::vector< PredictionRequest > &requests) const
Get a prediction for the state of multiple entity instances in the future.
Definition: Reader.cpp:519
armarx::status
status
Definition: FiniteStateMachine.h:244
armarx::armem::server::wm::Memory
Definition: memory_definitions.h:122
armarx::armem::gui::memory::TreeWidget::updated
void updated()
Tree contents have changed.
armarx::armem::gui::MemoryHandler::loadFromDisk
void loadFromDisk(const std::string &directory)
Definition: MemoryHandler.cpp:24
armarx::armem::error::CouldNotResolveMemoryServer::makeMsg
static std::string makeMsg(const MemoryID &memoryID, const std::string &errorMessage="")
Definition: mns.cpp:36
armarx::armem::MemoryID
A memory ID.
Definition: MemoryID.h:47
armarx::armem::gui::memory::GroupBox::queryWidget
QueryWidget * queryWidget() const
Definition: GroupBox.cpp:77
ManagedIceObject.h
armarx::armem::PredictionResult::prediction
aron::data::DictPtr prediction
Definition: Prediction.h:63
armarx::armem::client::MemoryNameSystem::getAllReaders
std::map< std::string, Reader > getAllReaders(bool update=true)
Get Readers for all registered servers.
Definition: MemoryNameSystem.cpp:396
armarx::armem::gui::instance::DataView::addDataView
void addDataView(DataView *dataView)
Definition: DataView.cpp:79
data
uint8_t data[1]
Definition: EtherCATFrame.h:68
armarx::armem::gui::memory::GroupBox::predictionWidget
PredictionWidget * predictionWidget() const
Definition: GroupBox.cpp:95
armarx::aron::input
ReaderT::InputType & input
Definition: rw.h:12
TreeTypedJSONConverter.h
armarx::armem::gui::MemoryGroupBox
memory::GroupBox MemoryGroupBox
Definition: GroupBox.h:59
armarx::armem::wm::Memory
Client-side working memory.
Definition: memory_definitions.h:133
wm.h
armarx::armem::gui::MemoryViewer::setLogTag
void setLogTag(const std::string &tag)
Definition: MemoryViewer.cpp:209
timestamp
std::string timestamp()
Definition: CartographerAdapter.cpp:85
armarx::armem::client::Reader::getAvailablePredictionEngines
std::map< MemoryID, std::vector< PredictionEngine > > getAvailablePredictionEngines() const
Get the list of prediction engines supported by the memory.
Definition: Reader.cpp:563
armarx::armem::gui::MemoryViewer::statusLabel
QLabel * statusLabel
Definition: MemoryViewer.h:161
AronDataView.h
armarx::armem::gui::MemoryViewer::instanceGroup
armem::gui::InstanceGroupBox * instanceGroup
Definition: MemoryViewer.h:159
armarx::armem::gui::MemoryViewer::mns
armem::client::MemoryNameSystem mns
Definition: MemoryViewer.h:138
armarx::armem::gui::MemoryViewer::saveSettings
void saveSettings(QSettings *settings)
Definition: MemoryViewer.cpp:1046
armarx::armem::gui::AronDataView
instance::AronDataView AronDataView
Definition: AronDataView.h:40
armarx::armem::gui::PredictionWidget::EntityInfo
Definition: PredictionWidget.h:49
armarx::control::hardware_config::tagName
std::string tagName(ConfigTag tag)
Definition: Config.cpp:301
armarx::armem::wm::EntitySnapshot
Client-side working memory entity snapshot.
Definition: memory_definitions.h:80
armarx::armem::MemoryID::hasGap
bool hasGap() const
Indicate whether this ID has a gap such as in 'Memory//MyProvider' (no core segment name).
Definition: MemoryID.cpp:163
armarx::armem::gui::memory::TreeWidget::actionsMenuRequested
void actionsMenuRequested(const MemoryID &memoryID, QWidget *parent, const QPoint &pos, QMenu *menu)
armarx::armem::gui::QueryWidget::update
void update(const std::vector< std::string > &memoryNames)
Definition: QueryWidget.cpp:150
armarx::armem::gui::MemoryViewer::memoryData
std::map< std::string, armem::wm::Memory > memoryData
Definition: MemoryViewer.h:143
armarx::armem::gui::MemoryViewer::makePrediction
void makePrediction(const MemoryID &entityID, const aron::type::ObjectPtr &entityType, const armarx::DateTime &timestamp, const std::string &engineID)
Definition: MemoryViewer.cpp:972
armarx::armem::gui::PredictionWidget::makePrediction
void makePrediction(const MemoryID &entityID, const aron::type::ObjectPtr &entityType, const armarx::DateTime &timestamp, const std::string &engineID)
armarx::armem::server::ltm::util::mongodb::detail::update
bool update(mongocxx::collection &coll, const nlohmann::json &query, const nlohmann::json &update)
Definition: mongodb.cpp:68
armarx::armem::gui::MemoryViewer::showActionsMenu
void showActionsMenu(const MemoryID &memoryID, QWidget *parent, const QPoint &pos, QMenu *menu)
Definition: MemoryViewer.cpp:869
armarx::SimpleConfigDialog::addProxyFinder
void addProxyFinder(const std::vector< EntryData > &entryData)
Definition: SimpleConfigDialog.h:103
QueryWidget.h
armarx::armem::MemoryID::hasEntityName
bool hasEntityName() const
Definition: MemoryID.h:121
armarx::armem::MemoryID::memoryName
std::string memoryName
Definition: MemoryID.h:50
armarx::transform
auto transform(const Container< InputT, Alloc > &in, OutputT(*func)(InputT const &)) -> Container< OutputT, typename std::allocator_traits< Alloc >::template rebind_alloc< OutputT >>
Convenience function (with less typing) to transform a container of type InputT into the same contain...
Definition: algorithm.h:351
armarx::armem::gui::CommitWidget::getAronJSON
std::string getAronJSON() const
Definition: CommitWidget.cpp:56
armarx::armem::gui::CommitWidget::commit
void commit()
armarx::core::time::DateTime
Represents a point in time.
Definition: DateTime.h:24
armarx::armem::gui::MemoryViewer::debugObserverName
std::string debugObserverName
Definition: MemoryViewer.h:164
armarx::armem::gui::MemoryViewer::disconnected
void disconnected()
armarx::armem::gui::QueryWidget::getAvailableMemoryStates
std::map< std::string, ActiveMemoryState > getAvailableMemoryStates() const
Definition: QueryWidget.cpp:222
armarx::armem::gui::QueryWidget::startRecording
void startRecording()
armarx::gui::LifecycleClient::onConnect
virtual void onConnect()
Definition: lifecycle.cpp:87
armarx::ManagedIceObject
The ManagedIceObject is the base class for all ArmarX objects.
Definition: ManagedIceObject.h:162
armarx::armem::base::EntitySnapshotBase::time
Time & time()
Definition: EntitySnapshotBase.h:59
armarx::armem::Commit::add
EntityUpdate & add()
Definition: Commit.cpp:80
armarx::armem::gui::MemoryViewer::memoryGroup
armem::gui::MemoryGroupBox * memoryGroup
Definition: MemoryViewer.h:157
armarx::armem::gui::MemoryViewer::loadFromDisk
void loadFromDisk(QString directory)
Definition: MemoryViewer.cpp:439
armarx::armem::gui::QueryWidget::dropRemovedMemories
bool dropRemovedMemories() const
Definition: QueryWidget.cpp:210
armarx::armem::PredictionResult::errorMessage
std::string errorMessage
Definition: Prediction.h:60
armarx::armem::gui::MemoryViewer::periodicUpdateTimer
QTimer * periodicUpdateTimer
Periodically triggers query result collection and updates the available memories.
Definition: MemoryViewer.h:148
TimeUtil.h
ARMARX_INFO
#define ARMARX_INFO
Definition: Logging.h:181
armarx::armem::gui::disk::ControlWidget::requestedLoadFromDisk
void requestedLoadFromDisk(QString directory)
armarx::armem::gui::MemoryViewer::queryAndStoreInLTM
void queryAndStoreInLTM()
Definition: MemoryViewer.cpp:302
armarx::armem::gui::QueryWidget::getEnabledMemories
std::vector< std::string > getEnabledMemories() const
Definition: QueryWidget.cpp:250
armarx::armem::gui::QueryWidget::ActiveMemoryState::FoundAndChecked
@ FoundAndChecked
armarx::armem::gui::instance::GroupBox::viewUpdated
void viewUpdated()
magic_enum::detail::find
constexpr std::size_t find(string_view str, char_type c) noexcept
Definition: magic_enum.hpp:309
armarx::armem::laser_scans::constants::memoryName
const std::string memoryName
Definition: constants.h:28
armarx::armem::gui::MemoryViewer::MemoryViewer
MemoryViewer(QBoxLayout *updateWidgetLayout, QGroupBox *memoryGroupBox, QLayout *memoryGroupBoxParentLayout, QGroupBox *instanceGroupBox, QLayout *instanceGroupBoxParentLayout, QBoxLayout *diskControlWidgetLayout, QLabel *statusLabel)
Definition: MemoryViewer.cpp:45
armarx::armem::gui
Definition: ActionsMenuBuilder.cpp:5
armarx::armem::index::memoryID
const MemoryID memoryID
Definition: memory_ids.cpp:28
IceInternal::ProxyHandle<::IceProxy::armarx::DebugObserverInterface >
armarx::armem::query::DataMode::NoData
@ NoData
Just get the structure, but no ARON data.
armarx::Logging::tag
LogTag tag
Definition: Logging.h:278
armarx::armem::gui::MemoryViewer::diskControl
armem::gui::disk::ControlWidget * diskControl
Definition: MemoryViewer.h:155
armarx::armem::gui::instance::GroupBox::view
InstanceView * view
Definition: GroupBox.h:38
ARMARX_CHECK_NULL
#define ARMARX_CHECK_NULL(ptr)
Definition: ExpressionException.h:212
armarx::armem::MemoryID::withTimestamp
MemoryID withTimestamp(Time time) const
Definition: MemoryID.cpp:433
armarx::armem::gui::MemoryViewer::memoryReaders
std::map< std::string, armem::client::Reader > memoryReaders
Definition: MemoryViewer.h:140
armarx::armem::error::CouldNotResolveMemoryServer
Indicates that a query to the Memory Name System failed.
Definition: mns.h:24
armarx::Logging::deactivateSpam
SpamFilterDataPtr deactivateSpam(float deactivationDurationSec=10.0f, const std::string &identifier="", bool deactivate=true) const
disables the logging for the current line for the given amount of seconds.
Definition: Logging.cpp:99
armarx::armem::gui::memory::TreeWidget::selectedItemChanged
void selectedItemChanged(const MemoryID &id)
The selected item or its contents have changed.
ice_conversions_templates.h
armarx::armem::wm::Entity
Client-side working memory entity.
Definition: memory_definitions.h:93
armarx::aron::type::ObjectPtr
std::shared_ptr< Object > ObjectPtr
Definition: Object.h:36
armarx::Logging::setTag
void setTag(const LogTag &tag)
Definition: Logging.cpp:54
armarx::armem::gui::MemoryViewer::loadSettings
void loadSettings(QSettings *settings)
Definition: MemoryViewer.cpp:1034
armarx::armem::PredictionResult::success
bool success
Definition: Prediction.h:59
armarx::armem::gui::MemoryViewer::memoryWriters
std::map< std::string, armem::client::Writer > memoryWriters
Definition: MemoryViewer.h:141
ARMARX_WARNING
#define ARMARX_WARNING
Definition: Logging.h:193
armarx::armem::gui::MemoryViewer::initialized
void initialized()
armarx::armem::gui::MemoryViewer::is_initialized
std::atomic_bool is_initialized
Definition: MemoryViewer.h:171
armarx::armem::gui::QueryWidget::queryLinkRecursionDepth
int queryLinkRecursionDepth() const
Definition: QueryWidget.cpp:271
armarx::armem::gui::PeriodicUpdateWidget::stopTimer
void stopTimer()
Definition: PeriodicUpdateWidget.cpp:112
armarx::armem::client::QueryResult::fromIce
static QueryResult fromIce(const armem::query::data::Result &ice)
Definition: Query.cpp:26
armarx::armem::gui::MemoryViewer::memoryTreeUpdated
void memoryTreeUpdated()
armarx::armem::gui::QueryWidget::dropDisabledMemories
bool dropDisabledMemories() const
Definition: QueryWidget.cpp:216
armarx::armem::gui::CommitWidget::getMemoryID
std::string getMemoryID() const
Definition: CommitWidget.cpp:62
armarx::armem::EntityUpdate::entityID
MemoryID entityID
The entity's ID.
Definition: Commit.h:28
armarx::armem::gui::MemoryViewer::memoryDataChanged
void memoryDataChanged()
Variant.h
armarx::armem::gui::MemoryViewer::updateWidgetLayout
QLayout * updateWidgetLayout
Definition: MemoryViewer.h:151
armarx::armem::gui::MemoryViewer::stopLTMRecording
void stopLTMRecording()
Definition: MemoryViewer.cpp:356
armarx::ctrlutil::s
double s(double t, double s0, double v0, double a0, double j)
Definition: CtrlUtil.h:33
armarx::SimpleConfigDialog::getProxyName
std::string getProxyName(const std::string &entryName) const
Definition: SimpleConfigDialog.cpp:47
armarx::armem::PredictionRequest::snapshotID
armem::MemoryID snapshotID
Definition: Prediction.h:50
armarx::armem::gui::memory::GroupBox::tree
TreeWidget * tree() const
Definition: GroupBox.cpp:107
gui_utils.h
armarx::armem::gui::memory::TreeWidget::update
void update(const armem::wm::Memory &memory)
Definition: TreeWidget.cpp:154
armarx::armem::client::MemoryNameSystem::getAllWriters
std::map< std::string, Writer > getAllWriters(bool update=true)
Get Writers for all registered servers.
Definition: MemoryNameSystem.cpp:443
armarx::status::success
@ success
container_maps.h
ice_conversions.h
armarx::armem::PredictionSettings::predictionEngineID
std::string predictionEngineID
Definition: Prediction.h:42
armarx::armem::gui::PeriodicUpdateWidget::startTimerIfEnabled
void startTimerIfEnabled()
Definition: PeriodicUpdateWidget.cpp:94
armarx::armem::gui::memory::GroupBox::commitWidget
CommitWidget * commitWidget() const
Definition: GroupBox.cpp:101
armarx::SimpleConfigDialog
A config-dialog containing one (or multiple) proxy finders.
Definition: SimpleConfigDialog.h:84
armarx::human::MemoryID
const armem::MemoryID MemoryID
Definition: memory_ids.cpp:28