//------------------------------------------------------------------------------------------------------------------------------------ // Helper for ErrorMessenger. //------------------------------------------------------------------------------------------------------------------------------------ LogMgr::ErrorDialogResult LogMgr::Error(const std::string& errorMessage, bool isFatal, const char* funcName, const char* sourceFile, unsigned int lineNum) { string tag = ((isFatal) ? ("FATAL") : ("ERROR")); // buffer for our final output string string buffer; GetOutputBuffer(buffer, tag, errorMessage, funcName, sourceFile, lineNum); // write the final buffer to all the various logs m_tagCriticalSection.Lock(); Tags::iterator findIt = m_tags.find(tag); if (findIt != m_tags.end()) OutputFinalBufferToLogs(buffer, findIt->second); m_tagCriticalSection.Unlock(); // show the dialog box int result = ::MessageBoxA(NULL, buffer.c_str(), tag.c_str(), MB_ABORTRETRYIGNORE|MB_ICONERROR|MB_DEFBUTTON3); // act upon the choice switch (result) { case IDIGNORE : return LogMgr::LOGMGR_ERROR_IGNORE; case IDABORT : __debugbreak(); return LogMgr::LOGMGR_ERROR_RETRY; // assembly language instruction to break into the debugger case IDRETRY : return LogMgr::LOGMGR_ERROR_RETRY; default : return LogMgr::LOGMGR_ERROR_RETRY; } }
void LogManager::Log(const std::string& tag, const std::string& msg, const char* funcName, const char* fileName, unsigned int lineNum) { m_CritSection.Lock(); Tags::iterator findIt = m_Tags.find(tag); if (findIt != m_Tags.end()) { std::string buffer; GetOutputBuffer(buffer, tag, msg, funcName, fileName, lineNum); OutputBufferToLogs(buffer, findIt->second); } m_CritSection.Unlock(); }
QSet<QString> TagComparator::_toSet(const Tags& t, const QString& k) { Tags::const_iterator it = t.find(k); if (OsmSchema::getInstance().isList(k, *it)) { return QSet<QString>::fromList(t.getList(k)); } else { QSet<QString> result; result.insert(*it); return result; } }
/* topological (depth-first) sorting of operations */ static void sort_operations_recursive(NodeOperationBuilder::Operations &sorted, Tags &visited, NodeOperation *op) { if (visited.find(op) != visited.end()) return; visited.insert(op); for (int i = 0; i < op->getNumberOfInputSockets(); ++i) { NodeOperationInput *input = op->getInputSocket(i); if (input->isConnected()) sort_operations_recursive(sorted, visited, &input->getLink()->getOperation()); } sorted.push_back(op); }
void LogManager::SetDisplayFlags(const std::string& tag, unsigned char flag) { m_CritSection.Lock(); if (flag != 0) { Tags::iterator findIt = m_Tags.find(tag); if (findIt == m_Tags.end()) m_Tags.insert(std::make_pair(tag, flag)); else findIt->second = flag; } else m_Tags.erase(tag); m_CritSection.Unlock(); }
static void add_group_operations_recursive(Tags &visited, NodeOperation *op, ExecutionGroup *group) { if (visited.find(op) != visited.end()) return; visited.insert(op); if (!group->addOperation(op)) return; /* add all eligible input ops to the group */ for (int i = 0; i < op->getNumberOfInputSockets(); ++i) { NodeOperationInput *input = op->getInputSocket(i); if (input->isConnected()) add_group_operations_recursive(visited, &input->getLink()->getOperation(), group); } }
void LogMgr::log(const std::string& tag, const std::string& message, const char* funcName, const char* sourceFile, unsigned int lineNum) { m_TagCriticalSection.lock(); Tags::iterator findIt = m_Tags.find(tag); if (findIt != m_Tags.end()) { m_TagCriticalSection.unlock(); std::string buffer; getOutputBuffer(buffer, tag, message, funcName, sourceFile, lineNum); outputFinalBufferToLogs(buffer, tag, findIt->second); } else { m_TagCriticalSection.unlock(); } }
/////////////////////////////////////////////////////////////////////////////////////////////////////// // this function builds up the log string and outputs it to various places based on display flags /////////////////////////////////////////////////////////////////////////////////////////////////////// void LogMgr::Log(const string& tag, const string& message, const char* func, const char* source, unsigned int line) { _tag_critical_section.Lock(); Tags::iterator it = _tags.find(tag); if(it != _tags.end()) { _tag_critical_section.Unlock(); string buffer; GetOutputBuffer(buffer, tag, message, func, source, line); OutputFinalBufferToLogs(buffer, it->second); } else { //critical section is exited in the if above, so need to do it here if above wasnt executed _tag_critical_section.Unlock(); } }
void LogMgr::setDisplayFLags(const std::string& tag, unsigned char flags) { m_TagCriticalSection.lock(); if (flags != 0) { Tags::iterator findIt = m_Tags.find(tag); if (findIt == m_Tags.end()) m_Tags.insert(std::make_pair(tag, flags)); else findIt->second = flags; } else { m_Tags.erase(tag); } m_TagCriticalSection.unlock(); }
/////////////////////////////////////////////////////////////////////////////////////// // sets one or more display flags /////////////////////////////////////////////////////////////////////////////////////// void LogMgr::SetDisplayFlags(const std::string& tag, unsigned char flags) { _tag_critical_section.Lock(); if(flags != 0) { Tags::iterator it = _tags.find(tag); if(it == _tags.end()) _tags.insert(std::make_pair(tag, flags)); else it->second = flags; } else { _tags.erase(tag); } _tag_critical_section.Unlock(); }
static void find_reachable_operations_recursive(Tags &reachable, NodeOperation *op) { if (reachable.find(op) != reachable.end()) return; reachable.insert(op); for (int i = 0; i < op->getNumberOfInputSockets(); ++i) { NodeOperationInput *input = op->getInputSocket(i); if (input->isConnected()) find_reachable_operations_recursive(reachable, &input->getLink()->getOperation()); } /* associated write-buffer operations are executed as well */ if (op->isReadBufferOperation()) { ReadBufferOperation *read_op = (ReadBufferOperation *)op; MemoryProxy *memproxy = read_op->getMemoryProxy(); find_reachable_operations_recursive(reachable, memproxy->getWriteBufferOperation()); } }
//------------------------------------------------------------------------------------------------------------------------------------ // This function builds up the log string and outputs it to various places based on the display flags (m_displayFlags). //------------------------------------------------------------------------------------------------------------------------------------ void LogMgr::Log(const string& tag, const string& message, const char* funcName, const char* sourceFile, unsigned int lineNum) { m_tagCriticalSection.Lock(); Tags::iterator findIt = m_tags.find(tag); if (findIt != m_tags.end()) { m_tagCriticalSection.Unlock(); string buffer; GetOutputBuffer(buffer, tag, message, funcName, sourceFile, lineNum); OutputFinalBufferToLogs(buffer, findIt->second); } else { // Critical section is exited in the if statement above, so we need to exit it here if that didn't // get executed. m_tagCriticalSection.Unlock(); } } // end LogMgr::Log()
LogMgr::ErrorDialogResult LogMgr::error(const std::string & errorMessage, bool isFatal, const char* funcName, const char* sourceFile, unsigned int lineNum) { std::string tag = ((isFatal) ? ("FATAL") : ("ERROR")); std::string buffer; getOutputBuffer(buffer, tag, errorMessage, funcName, sourceFile, lineNum); m_TagCriticalSection.lock(); Tags::iterator findIt = m_Tags.find(tag); if (findIt != m_Tags.end()) outputFinalBufferToLogs(buffer, tag, findIt->second); m_TagCriticalSection.unlock(); int result = ::MessageBoxA(NULL, buffer.c_str(), tag.c_str(), MB_ABORTRETRYIGNORE | MB_ICONERROR | MB_DEFBUTTON3); switch (result) { case IDIGNORE: return LogMgr::LOGMGR_ERROR_IGNORE; case IDABORT: __debugbreak(); return LogMgr::LOGMGR_ERROR_RETRY; case IDRETRY: return LogMgr::LOGMGR_ERROR_RETRY; default: return LogMgr::LOGMGR_ERROR_RETRY; } }
////////////////////////////////////////////////////////////////////////////////////////////// //helper for ErrorMessenger ///////////////////////////////////////////////////////////////////////////////////////////// LogMgr::ErrorDialogResult LogMgr::Error(const std::string& error_message, bool is_fatal, const char* func, const char* source, unsigned int line) { string tag = ((is_fatal) ? ("FATAL") : ("ERROR")); //buffer for final output string string buffer; GetOutputBuffer(buffer, tag, error_message, func, source, line); //write final buffer to various logs _tag_critical_section.Lock(); Tags::iterator it = _tags.find(tag); if(it != _tags.end()) OutputFinalBufferToLogs(buffer, it->second); _tag_critical_section.Unlock(); //show the dialog box int result = ::MessageBoxA(NULL, buffer.c_str(), tag.c_str(), MB_ABORTRETRYIGNORE|MB_ICONERROR|MB_DEFBUTTON3); switch(result) { case IDIGNORE: return LogMgr::LOGMGR_ERROR_IGNORE; case IDABORT: __debugbreak(); return LogMgr::LOGMGR_ERROR_ABORT; case IDRETRY: return LogMgr::LOGMGR_ERROR_RETRY; default: return LogMgr::LOGMGR_ERROR_RETRY; } }
void NodeOperationBuilder::prune_operations() { Tags reachable; for (Operations::const_iterator it = m_operations.begin(); it != m_operations.end(); ++it) { NodeOperation *op = *it; /* output operations are primary executed operations */ if (op->isOutputOperation(m_context->isRendering())) find_reachable_operations_recursive(reachable, op); } /* delete unreachable operations */ Operations reachable_ops; for (Operations::const_iterator it = m_operations.begin(); it != m_operations.end(); ++it) { NodeOperation *op = *it; if (reachable.find(op) != reachable.end()) reachable_ops.push_back(op); else delete op; } /* finally replace the operations list with the pruned list */ m_operations = reachable_ops; }
LogManager::ErrorDialogResult LogManager::Error(const std::string& msg, bool isFatal, const char* funcName, const char* fileName, unsigned int lineNum) { std::string tag = ((isFatal) ? "FATAL" : "ERROR"); std::string buffer; GetOutputBuffer(buffer, tag, msg, funcName, fileName, lineNum); m_CritSection.Lock(); Tags::iterator findIt = m_Tags.find(tag); if (findIt != m_Tags.end()) OutputBufferToLogs(buffer, findIt->second); m_CritSection.Unlock(); int result; // show dialog box if (isFatal) result = MessageBox(nullptr, buffer.c_str(), tag.c_str(), MB_OK | MB_ICONERROR | MB_DEFBUTTON1); else result = MessageBox(nullptr, buffer.c_str(), tag.c_str(), MB_ABORTRETRYIGNORE | MB_ICONERROR | MB_DEFBUTTON3); switch (result) { case IDOK: exit(EXIT_FAILURE); case IDIGNORE: return LogManager::ERROR_DIALOG_IGNORE; case IDABORT: __debugbreak(); // Assembly instruction to open VS debugger. return LogManager::ERROR_DIALOG_ABORT; case IDRETRY: return LogManager::ERROR_DIALOG_RETRY; default: return LogManager::ERROR_DIALOG_RETRY; } }
void TagComparator::_mergeExactMatches(Tags& t1, Tags& t2, Tags& result) { OsmSchema& schema = OsmSchema::getInstance(); Tags t1Copy = t1; for (Tags::ConstIterator it1 = t1Copy.begin(); it1 != t1Copy.end(); ++it1) { bool keepIt = false; Tags::const_iterator it2 = t2.find(it1.key()); if (it2 != t2.end()) { if (schema.isList(it1.key(), it1.value())) { // treat the inputs as unordered lists QSet<QString> values1 = QSet<QString>::fromList(t1.getList(it1.key())); QSet<QString> values2 = QSet<QString>::fromList(t2.getList(it2.key())); values1.intersect(values2); if (values1.size() == values2.size()) { keepIt = true; } } else if (it2.value() == it1.value()) { keepIt = true; } if (keepIt) { result[it1.key()] = it1.value(); t1.remove(it1.key()); t2.remove(it1.key()); } } } }