LogTableModel.cpp
Go to the documentation of this file.
1 /*
2 * This file is part of ArmarX.
3 *
4 * ArmarX is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 as
6 * published by the Free Software Foundation.
7 *
8 * ArmarX is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License
14 * along with this program. If not, see <http://www.gnu.org/licenses/>.
15 *
16 * @package ArmarX::
17 * @author Mirko Waechter ( mirko.waechter at kit dot edu)
18 * @date 2012
19 * @copyright http://www.gnu.org/licenses/gpl-2.0.txt
20 * GNU General Public License
21 */
22 
23 #include "LogTableModel.h"
24 #include "LogTable.h"
25 
26 #include <ArmarXCore/core/logging/LogSender.h>
27 
28 namespace armarx
29 {
30  LogTableModel::LogTableModel(QObject* parent) :
31  QAbstractTableModel(parent)
32  {
33  newEntryCount = 0;
34  maxNewLogLevelType = eUNDEFINED;
35  }
36 
37  int LogTableModel::rowCount(const QModelIndex& parent) const
38  {
39  return logEntries.size();
40  }
41 
42 
43  int LogTableModel::columnCount(const QModelIndex& parent) const
44  {
45  return 8;
46  }
47 
48  QVariant LogTableModel::data(const QModelIndex& index, int role) const
49  {
50  const int& row = index.row();
51  const int& column = index.column();
52 
53  switch (role)
54  {
55  case (int)UserRoles::FullMsgRole:
56  {
57  std::unique_lock lock(logEntriesMutex);
58  if (row >= (signed int)logEntries.size() || row < 0)
59  {
60  return QString("n/A");
61  }
62 
63  const LogMessage& entry = logEntries[row];
64  switch (column)
65  {
66 
67  case 4:
68  {
69  if (role == Qt::ToolTipRole)
70  {
71  return "";
72  }
73 
74  QString whatStr;
75 
76  if (!entry.backtrace.empty())
77  {
78  whatStr = QString::fromStdString(entry.what + "\nBacktrace:\n" + entry.backtrace);
79  }
80  else
81  {
82  whatStr = QString::fromStdString(entry.what);
83  }
84 
85  return whatStr;
86  }
87  default:
88  return "";
89  }
90  }
91  case Qt::DisplayRole:
92  case Qt::ToolTipRole:
93  {
94  std::unique_lock lock(logEntriesMutex);
95 
96  //std::cout << "row " << row << " column:" << column << std::endl;
97  if (row >= (signed int)logEntries.size() || row < 0)
98  {
99  return QString("n/A");
100  }
101 
102  const LogMessage& entry = logEntries[row];
103 
104  switch (column)
105  {
106  case 0:
107  {
108  IceUtil::Time time = IceUtil::Time::microSeconds(entry.time);
109  std::string timeStr = time.toDateTime();
110  timeStr = timeStr.substr(timeStr.find(' '));
111  return QString::fromStdString(timeStr);
112  }
113 
114  case 1:
115  {
116  return QString::fromStdString(entry.who);
117  }
118 
119  case 2:
120  {
121  return QString::fromStdString(entry.tag);
122  }
123 
124  case 3:
125  {
126  if (entry.type != eUNDEFINED)
127  {
128  return QString::fromStdString(LogSender::levelToString((MessageTypeT)entry.type));
129  }
130  else
131  {
132  return QVariant();
133  }
134  }
135 
136  case 4:
137  {
138  if (role == Qt::ToolTipRole)
139  {
140  return "";
141  }
142 
143  QString whatStr;
144 
145  if (!entry.backtrace.empty())
146  {
147  whatStr = QString::fromStdString(entry.what + "\nBacktrace:\n...");
148  }
149  else
150  {
151  whatStr = QString::fromStdString(entry.what);
152  }
153  int lines = 0;
154  int maxLinesToShow = 50;
155  int pos = 0;
156  for (int i = 0; i < whatStr.length(); i++)
157  {
158  auto c = whatStr.at(i);
159  if (c == '\n')
160  {
161  lines++;
162  }
163  if (lines == maxLinesToShow)
164  {
165  break;
166  }
167  pos++;
168  }
169  if (lines >= maxLinesToShow)
170  {
171  whatStr.truncate(pos);
172  return whatStr + "\n...";
173  }
174  return whatStr;
175  }
176 
177  case 5:
178  {
179  if (role == Qt::ToolTipRole)
180  {
181  return QString::fromStdString("Double click to open file in editor: " + entry.file + ":" + QString::number(entry.line).toStdString());
182  }
183  else if (!entry.file.empty())
184  {
185  return QString::fromStdString(entry.file + ":" + QString::number(entry.line).toStdString());
186  }
187  else
188  {
189  return QVariant();
190  }
191  }
192 
193  case 6:
194  {
195  return QString::fromStdString(entry.function);
196  }
197 
198  case 7:
199  {
200  return QString::fromStdString(entry.group);
201  }
202 
203  default:
204  return "";
205  }
206  }
207 
208  case Qt::DecorationRole:
209  switch (column)
210  {
211  case 5:
212  return QIcon(":icons/document-open-4.ico");
213 
214  default:
215  return QVariant();
216  }
217 
218  case Qt::BackgroundColorRole:
219  {
220  if (column == 3) // Log Level color
221  {
222  if (row >= (signed int)logEntries.size() || row < 0)
223  {
224  return QVariant();
225  }
226 
227  const LogMessage& entry = logEntries[row];
228 
229  switch (entry.type)
230  {
231  case eVERBOSE:
232  return QColor(200, 200, 250);
233 
234  case eIMPORTANT:
235  return QColor(50, 255, 50);
236 
237  case eWARN:
238  return QColor(216, 88, 0);
239 
240  case eERROR:
241  return QColor(255, 64, 64);
242 
243  case eFATAL:
244  return QColor(176, 0, 0);
245 
246  default:
247  break;
248  }
249  }
250 
251 
252  if (activeSearchStr.length() == 0)
253  {
254  return QVariant();
255  }
256 
257 
258  std::unique_lock lock(logEntriesMutex);
259 
260  //std::cout << "row " << row << " column:" << column << std::endl;
261  if (row >= (signed int)logEntries.size() || row < 0)
262  {
263  return QVariant();
264  }
265 
266  const LogMessage& entry = logEntries[row];
267 
268  if (msgContainsString(entry, activeSearchStr))
269  {
270  return QColor(255, 244, 127);
271  }
272  else
273  {
274  return QVariant();
275  }
276 
277  }
278 
279  // case Qt::SizeHintRole:
280  // {
281  // if(column == 4)
282  // {
283  //// const armarx::LogMessage & entry = logEntries[row];
284  //// int lines = std::count(entry.what.begin(), entry.what.end(), '\n') +1 ;
285  //// if(lines > 5)
286  //// lines = 5;
287  //// std::cout << "SizeHintRole lines: " << lines << "-> " << lines*14 << std::endl;
288  // return QSize(350,logRowSize[row]);
289  // }
290 
291  // }
292 
293  }
294 
295  return QVariant();
296  }
297 
298  bool LogTableModel::rowContainsString(int row, const QString& searchStr) const
299  {
300  if (searchStr.length() == 0)
301  {
302  return true;
303  }
304 
305  for (int i = 0; i < columnCount(); i++)
306  {
307  if (data(createIndex(row, i), Qt::DisplayRole).toString().contains(searchStr, Qt::CaseInsensitive))
308  {
309  return true;
310  }
311  }
312 
313  return false;
314  }
315 
316  bool LogTableModel::msgContainsString(const LogMessage& logMsg, QString searchStr) const
317  {
318  if (QString(logMsg.who.c_str()).contains(searchStr, Qt::CaseInsensitive))
319  {
320  return true;
321  }
322 
323  if (QString(logMsg.tag.c_str()).contains(searchStr, Qt::CaseInsensitive))
324  {
325  return true;
326  }
327 
328  if (QString(logMsg.what.c_str()).contains(searchStr, Qt::CaseInsensitive))
329  {
330  return true;
331  }
332 
333  if (QString(logMsg.backtrace.c_str()).contains(searchStr, Qt::CaseInsensitive))
334  {
335  return true;
336  }
337 
338  if (QString(logMsg.file.c_str()).contains(searchStr, Qt::CaseInsensitive))
339  {
340  return true;
341  }
342 
343  if (QString(logMsg.function.c_str()).contains(searchStr, Qt::CaseInsensitive))
344  {
345  return true;
346  }
347 
348  if (QString::number(logMsg.line).contains(searchStr, Qt::CaseInsensitive))
349  {
350  return true;
351  }
352 
353  return false;
354  }
355 
356  bool LogTableModel::rowContainsSameContent(int row, const LogMessage& logMsg) const
357  {
358  if (row < 0 || row >= (signed int)logEntries.size())
359  {
360  return false;
361  }
362 
363  const LogMessage& entry = logEntries[row];
364 
365  if (logMsg.line != entry.line)
366  {
367  return false;
368  }
369 
370  if (logMsg.who != entry.who)
371  {
372  return false;
373  }
374 
375  if (logMsg.tag != entry.tag)
376  {
377  return false;
378  }
379 
380  if (logMsg.what != entry.what)
381  {
382  return false;
383  }
384 
385  if (logMsg.file != entry.file)
386  {
387  return false;
388  }
389 
390  if (logMsg.function != entry.function)
391  {
392  return false;
393  }
394 
395  return true;
396  }
397 
398  void LogTableModel::search(const QString& searchStr)
399  {
400  activeSearchStr = searchStr;
401  QModelIndex leftTop = index(0, 0);
402  QModelIndex rightBottom = index(logEntries.size() - 1, 6);
403  // std::cout << "updating " << leftTop.row() << " til " << rightBottom.row() << std::endl;
404  emit dataChanged(leftTop, rightBottom);
405 
406  // searchResultTask = new RunningTask<LogTableModel>(this, &LogTableModel::fillSearchResults, "logTableSearch");
407 
408  }
409 
410 
411 
412  QVariant LogTableModel::headerData(int section, Qt::Orientation orientation, int role) const
413  {
414  if (role == Qt::DisplayRole)
415  {
416  if (orientation == Qt::Horizontal)
417  {
418  switch (section)
419  {
420  case 0:
421  return QString(ARMARX_LOG_TIMESTR);
422 
423  case 1:
424  return QString(ARMARX_LOG_COMPONENTSTR);
425 
426  case 2:
427  return QString(ARMARX_LOG_TAGSTR);
428 
429  case 3:
430  return QString(ARMARX_LOG_VERBOSITYSTR);
431 
432  case 4:
433  return QString(ARMARX_LOG_MESSAGESTR);
434 
435  case 5:
436  return QString(ARMARX_LOG_FILESTR);
437 
438  case 6:
439  return QString(ARMARX_LOG_FUNCTIONSTR);
440 
441  case 7:
442  return QString(ARMARX_LOG_LOGGINGGROUPSTR);
443 
444  default:
445  return QString("");
446  }
447  }
448  }
449  else if (role == Qt::ToolTipRole)
450  {
451  if (orientation == Qt::Horizontal)
452  {
453  switch (section)
454  {
455  case 0:
456  return QString(ARMARX_LOG_TIMESTR);
457 
458  case 1:
459  return QString(ARMARX_LOG_COMPONENTSTR);
460 
461  case 2:
462  return QString(ARMARX_LOG_TAGSTR);
463 
464  case 3:
465  return QString(ARMARX_LOG_VERBOSITYSTR);
466 
467  case 4:
468  return QString(ARMARX_LOG_MESSAGESTR);
469 
470  case 5:
471  return QString::fromStdString(std::string(ARMARX_LOG_FILESTR) + std::string(": Double click cell to open Qtcreator at that location"));
472 
473  case 6:
474  return QString(ARMARX_LOG_FUNCTIONSTR);
475 
476  default:
477  return QString("");
478  }
479  }
480  }
481 
482  // else if(role == Qt::SizeHintRole)
483  // {
484  // QSize size(100,18);
485  // if (orientation == Qt::Horizontal) {
486  // std::cout << "size of header questioned" << std::endl;
487  // switch (section)
488  // {
489  // case 0:
490  // case 1:
491  // case 2:
492  // size.setWidth(90);
493  // return size;
494  // case 3:
495  // size.setWidth(60);
496  // return size;
497  // case 4:
498  // size.setWidth(350);
499  // return size;
500  // case 5:
501  // size.setWidth(150);
502  // return size;
503  // case 6:
504  // size.setWidth(200);
505  // return size;
506  // default:
507  // std::cout << "standard size" << std::endl;
508  // return size;
509  // }
510  // }
511  // }
512 
513  return QVariant();
514  }
515 
516  bool LogTableModel::setData(const QModelIndex& index, const QVariant& value, int role)
517  {
518  return false;
519  }
520 
521  Qt::ItemFlags LogTableModel::flags(const QModelIndex& index) const
522  {
523  if (index.column() == getColumn(ARMARX_LOG_MESSAGESTR))
524  {
525  return Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsEnabled ;
526  }
527  else
528  {
529  return Qt::ItemIsSelectable | Qt::ItemIsEnabled ;
530  }
531  }
532 
533  void LogTableModel::updateView()
534  {
535  // QModelIndex topLeft = createIndex(0,0);
536  // emit dataChanged(topLeft, topLeft);
537  QModelIndex leftTop = index(logEntries.size() - newEntryCount, 0);
538  QModelIndex rightBottom = index(logEntries.size() - 1, 6);
539  // std::cout << "updating " << leftTop.row() << " til " << rightBottom.row() << std::endl;
540  emit dataChanged(leftTop, rightBottom);
541  newEntryCount = 0;
542  maxNewLogLevelType = eUNDEFINED;
543  }
544 
545  bool LogTableModel::insertRows(int row, int count, const QModelIndex& parent)
546  {
547  beginInsertRows(QModelIndex(), row, row + count - 1);
548  int newEntries = row + count - logEntries.size();
549 
550  for (int i = 0; i < newEntries; i++)
551  {
552  logEntries.push_back(LogMessage());
553  }
554 
555  endInsertRows();
556  return true;
557  }
558 
559  void LogTableModel::addFilter(const std::string& columnName, const std::string& filter)
560  {
561  activeFilters.push_back(std::make_pair(columnName, filter));
562  }
563 
564  void LogTableModel::reapplyAllFilters()
565  {
566 
567  {
568  std::unique_lock lock(logEntriesMutex);
569  std::vector < LogMessage>::iterator it = logEntries.begin();
570  int row = 0;
571 
572  for (; it != logEntries.end(); ++it)
573  {
574  const LogMessage& entry = *it;
575 
576  if (!applyFilters(entry))
577  {
578  beginRemoveRows(QModelIndex(), row, row);
579  it = logEntries.erase(it);
580  it--;
581  endRemoveRows();
582  }
583  else
584  {
585  row++;
586  }
587  }
588  }
589  updateView();
590  }
591 
592  void LogTableModel::resetFilters()
593  {
594  activeFilters.clear();
595  }
596 
597  bool LogTableModel::addEntry(const LogMessage& entry, int* entriesAdded)
598  {
599  {
600  std::unique_lock lock(logEntriesMutex);
601 
602  if (entriesAdded)
603  {
604  *entriesAdded = 0;
605  }
606 
607  if (!applyFilters(entry))
608  {
609  return false;
610  }
611 
612  if (rowContainsSameContent(logEntries.size() - 1, entry))
613  {
614  *logEntries.rbegin() = entry;
615  return false;
616  }
617  else
618  {
619  newEntryCount++;
620 
621  if (entry.type > maxNewLogLevelType)
622  {
623  maxNewLogLevelType = entry.type;
624  }
625 
626  logEntries.push_back(entry);
627 
628  if (entriesAdded)
629  {
630  (*entriesAdded)++;
631  }
632  }
633  }
634  return true;
635  }
636 
637  int LogTableModel::addEntries(const std::vector<LogMessage>& entryList, const QString& filterStr)
638  {
639  if (entryList.size() == 0)
640  {
641  return 0;
642  }
643 
644  //std::cout << "adding entries " << entryList.size() << std::endl;
645  unsigned int size = entryList.size();
646  int entriesAdded = 0;
647 
648  for (unsigned int i = 0; i < size; i++)
649  {
650  if (addEntry(entryList[i]))
651  {
652  entriesAdded++;
653  }
654  }
655  if (entriesAdded > 0)
656  {
657  beginInsertRows(QModelIndex(), logEntries.size() - entriesAdded, logEntries.size() - 1);
658  endInsertRows();
659  updateView();
660  }
661  return entriesAdded;
662  }
663 
664 
665 
666  int LogTableModel::getColumn(const std::string& columnName) const
667  {
668  if (columnName.empty())
669  {
670  return -1;
671  }
672 
673  QString qcolumnName = QString::fromStdString(columnName);
674 
675  for (int i = 0; i < columnCount(QModelIndex()); i++)
676  {
677  if (headerData(i, Qt::Horizontal, Qt::DisplayRole).toString().compare(qcolumnName) == 0)
678  {
679  return i;
680  }
681  }
682 
683  return -1;
684  }
685 
686  int LogTableModel::clearData()
687  {
688  int size;
689  {
690  beginRemoveRows(QModelIndex(), 0, logEntries.size() - 1);
691  std::unique_lock lock(logEntriesMutex);
692  size = (int)logEntries.size();
693  removeRows(0, logEntries.size() - 1);
694  logEntries.clear();
695  endRemoveRows();
696  }
697  updateView();
698  return size;
699  }
700 
701  const LogMessage& LogTableModel::getLogEntry(size_t row) const
702  {
703  return logEntries.at(row);
704  }
705 
706 
707 
708  bool LogTableModel::applyFilter(std::pair<std::string, std::string> filter, const LogMessage& logMsg)
709  {
710  std::string columnName = filter.first;
711  QString filterStr = QString::fromStdString(filter.second);
712 
713  // for(unsigned int i = 0; i < columns.size(); i++)
714  // {
715  // if(columnName == columns[i].columnName)
716  // {
717  // if(logMsg.who.find(filterStr) == std::string::npos)
718  // return false;
719  // else
720  // return true;
721  // }
722  // }
723  // TODO: identify columns by integer instead of string for better performance
724  if (columnName == ARMARX_LOG_LOGGINGGROUPSTR)
725  {
726  if (QString(logMsg.group.c_str()).contains(filterStr, Qt::CaseSensitive))
727  {
728  return true;
729  }
730  else
731  {
732  return false;
733  }
734  }
735  else if (columnName == ARMARX_LOG_COMPONENTSTR)
736  {
737  if (QString(logMsg.who.c_str()).contains(filterStr, Qt::CaseInsensitive))
738  {
739  return true;
740  }
741  else
742  {
743  return false;
744  }
745  }
746  else if (columnName == ARMARX_LOG_TAGSTR)
747  {
748  if (QString(logMsg.tag.c_str()).contains(filterStr, Qt::CaseInsensitive))
749  {
750  return true;
751  }
752  else
753  {
754  return false;
755  }
756  }
757  else if (columnName == ARMARX_LOG_VERBOSITYSTR)
758  {
759  if (logMsg.type < QString(filterStr).toInt())
760  {
761  return false;
762  }
763  else
764  {
765  return true;
766  }
767  }
768  else if (columnName == ARMARX_LOG_MESSAGESTR)
769  {
770  if (QString(logMsg.what.c_str()).contains(filterStr, Qt::CaseInsensitive))
771  {
772  return true;
773  }
774  else
775  {
776  return false;
777  }
778  }
779  else if (columnName == ARMARX_LOG_FILESTR)
780  {
781  if (!QString(logMsg.file.c_str()).contains(filterStr, Qt::CaseInsensitive) && filterStr.toInt() != logMsg.line)
782  {
783  return false;
784  }
785  else
786  {
787  return true;
788  }
789  }
790  else if (columnName == ARMARX_LOG_FUNCTIONSTR)
791  {
792  if (QString(logMsg.function.c_str()).contains(filterStr, Qt::CaseInsensitive))
793  {
794  return true;
795  }
796  else
797  {
798  return false;
799  }
800  }
801 
802  return true;
803  }
804 
805  bool LogTableModel::applyFilter(std::string filter, int row, int column)
806  {
807  if (row >= rowCount(QModelIndex()) || column >= columnCount(QModelIndex()))
808  {
809  return true;
810  }
811 
812  return data(createIndex(row, column), Qt::DisplayRole).toString()
813  .contains(QString(filter.c_str()), Qt::CaseInsensitive);
814  return false;
815  }
816 
817  bool LogTableModel::applyFilters(int row)
818  {
819  for (unsigned int i = 0; i < activeFilters.size(); i++)
820  {
821  if (!applyFilter(activeFilters[i].second, row, getColumn(activeFilters[i].first)))
822  {
823  return false;
824  }
825  }
826 
827  return true;
828  }
829 
830  bool LogTableModel::applyFilters(const LogMessage& logMsg)
831  {
832  for (unsigned int i = 0; i < activeFilters.size(); i++)
833  {
834  if (!applyFilter(activeFilters[i], logMsg))
835  {
836  return false;
837  }
838  }
839 
840  return true;
841  }
842 
843 
844  //bool LogTableModel::applyFilter(std::pair filter, int row)
845  //{
846  // int selectedColumn = getColumn(filter.first);
847 
848  // if(selectedColumn == -1)
849  // {
850  // ARMARX_WARNING << "Could not find column " << filter.first << flush;
851  // return true;
852  // }
853 
854  // return true;
855  //}
856 }
armarx::LogTableModel::updateView
void updateView()
Definition: LogTableModel.cpp:533
armarx::LogTableModel::addEntries
int addEntries(const std::vector< LogMessage > &entryList, const QString &filterStr)
Definition: LogTableModel.cpp:637
armarx::MessageTypeT
MessageTypeT
Definition: LogSender.h:45
ARMARX_LOG_TIMESTR
#define ARMARX_LOG_TIMESTR
Definition: LogTable.h:39
armarx::LogTableModel::resetFilters
void resetFilters()
Definition: LogTableModel.cpp:592
GfxTL::Orientation
ScalarT Orientation(const VectorXD< 2, ScalarT > &p1, const VectorXD< 2, ScalarT > &p2, const VectorXD< 2, ScalarT > &c)
Definition: Orientation.h:9
index
uint8_t index
Definition: EtherCATFrame.h:59
LogTableModel.h
armarx::toInt
int toInt(const std::string &input)
Definition: StringHelpers.cpp:108
armarx::LogTableModel::headerData
QVariant headerData(int section, Qt::Orientation orientation, int role) const override
Definition: LogTableModel.cpp:412
armarx::LogTableModel::applyFilter
bool applyFilter(std::pair< std::string, std::string > filter, const LogMessage &logMsg)
Definition: LogTableModel.cpp:708
armarx::LogTableModel::msgContainsString
bool msgContainsString(const LogMessage &logMsg, QString searchStr) const
Definition: LogTableModel.cpp:316
ARMARX_LOG_FILESTR
#define ARMARX_LOG_FILESTR
Definition: LogTable.h:44
armarx::LogTableModel::UserRoles::FullMsgRole
@ FullMsgRole
c
constexpr T c
Definition: UnscentedKalmanFilterTest.cpp:43
armarx::LogTableModel::addFilter
void addFilter(const std::string &columnName, const std::string &filter)
Definition: LogTableModel.cpp:559
armarx::LogTableModel::rowCount
int rowCount(const QModelIndex &parent=QModelIndex()) const override
Definition: LogTableModel.cpp:37
ARMARX_LOG_FUNCTIONSTR
#define ARMARX_LOG_FUNCTIONSTR
Definition: LogTable.h:45
armarx::LogTableModel::search
void search(const QString &searchStr)
Definition: LogTableModel.cpp:398
armarx::LogTableModel::applyFilters
bool applyFilters(int row)
Definition: LogTableModel.cpp:817
armarx::LogTableModel::addEntry
bool addEntry(const LogMessage &entry, int *entriesAdded=NULL)
Definition: LogTableModel.cpp:597
cxxopts::value
std::shared_ptr< Value > value()
Definition: cxxopts.hpp:926
ARMARX_LOG_MESSAGESTR
#define ARMARX_LOG_MESSAGESTR
Definition: LogTable.h:43
armarx::LogTableModel::rowContainsSameContent
bool rowContainsSameContent(int row, const LogMessage &logMsg) const
Definition: LogTableModel.cpp:356
LogTable.h
armarx::LogTableModel::setData
bool setData(const QModelIndex &index, const QVariant &value, int role) override
Definition: LogTableModel.cpp:516
ARMARX_LOG_LOGGINGGROUPSTR
#define ARMARX_LOG_LOGGINGGROUPSTR
Definition: LogTable.h:46
armarx::LogTableModel::flags
Qt::ItemFlags flags(const QModelIndex &index) const override
Definition: LogTableModel.cpp:521
ARMARX_LOG_TAGSTR
#define ARMARX_LOG_TAGSTR
Definition: LogTable.h:41
armarx::armem::Time
armarx::core::time::DateTime Time
Definition: forward_declarations.h:13
armarx::LogTableModel::insertRows
bool insertRows(int row, int count, const QModelIndex &parent) override
Definition: LogTableModel.cpp:545
ARMARX_LOG_VERBOSITYSTR
#define ARMARX_LOG_VERBOSITYSTR
Definition: LogTable.h:42
armarx::LogTableModel::getLogEntry
const LogMessage & getLogEntry(size_t row) const
Definition: LogTableModel.cpp:701
armarx::LogTableModel::LogTableModel
LogTableModel(QObject *parent=0)
Definition: LogTableModel.cpp:30
armarx::LogTableModel::rowContainsString
bool rowContainsString(int row, const QString &searchStr) const
Definition: LogTableModel.cpp:298
armarx::LogTableModel::columnCount
int columnCount(const QModelIndex &parent=QModelIndex()) const override
Definition: LogTableModel.cpp:43
LogSender.h
armarx::LogTableModel::data
QVariant data(const QModelIndex &index, int role) const override
Definition: LogTableModel.cpp:48
armarx::LogTableModel::clearData
int clearData()
Definition: LogTableModel.cpp:686
armarx::LogTableModel::getColumn
int getColumn(const std::string &columnName) const
Definition: LogTableModel.cpp:666
ARMARX_LOG_COMPONENTSTR
#define ARMARX_LOG_COMPONENTSTR
Definition: LogTable.h:40
armarx::LogTableModel::reapplyAllFilters
void reapplyAllFilters()
Definition: LogTableModel.cpp:564
armarx
This file offers overloads of toIce() and fromIce() functions for STL container types.
Definition: ArmarXTimeserver.cpp:28
armarx::LogSender::levelToString
static std::string levelToString(MessageTypeT type)
Definition: LogSender.cpp:611