diff --git a/Plugins/org.blueberry.core.runtime/src/berryDebugUtil.cpp b/Plugins/org.blueberry.core.runtime/src/berryDebugUtil.cpp
index aff853a324..b5eaf094f0 100755
--- a/Plugins/org.blueberry.core.runtime/src/berryDebugUtil.cpp
+++ b/Plugins/org.blueberry.core.runtime/src/berryDebugUtil.cpp
@@ -1,549 +1,541 @@
/*===================================================================
BlueBerry Platform
Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.
This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.
See LICENSE.txt or http://www.mitk.org for details.
===================================================================*/
#include "berryIDebugObjectListener.h"
#include "berryDebugUtil.h"
#include "berryObject.h"
#include "berryLog.h"
#include "berryPlatform.h"
#include "berryDebugBreakpointManager.h"
#include "internal/berryCTKPluginActivator.h"
#include <QDir>
#include <QDebug>
#include <Poco/Bugcheck.h>
#include <Poco/NumberParser.h>
#include <Poco/DOM/NodeList.h>
#include <Poco/DOM/DOMParser.h>
#include <Poco/DOM/Document.h>
#include <Poco/DOM/Element.h>
#include <Poco/DOM/DOMWriter.h>
#include <Poco/SAX/InputSource.h>
#include <Poco/SAX/SAXException.h>
#include <Poco/FileStream.h>
#include <sstream>
#include <numeric>
namespace berry
{
static IDebugObjectListener::Events _G_ObjectEvents;
const QString DebugUtil::DEBUG_UTIL_XML = "debugutil.xml";
const QString DebugUtil::DEBUGUTIL_TAG = "debugutil";
const QString DebugUtil::TRACEOBJECT_TAG = "traceObject";
const QString DebugUtil::TRACECLASS_TAG = "traceClass";
const QString DebugUtil::ID_ATTR = "id";
const QString DebugUtil::NAME_ATTR = "name";
QHash<quint32, QList<unsigned int> > DebugUtil::m_TraceIdToSmartPointerMap;
QHash<quint32, const Object*> DebugUtil::m_TraceIdToObjectMap;
QSet<unsigned int> DebugUtil::m_TracedObjects;
QSet<QString> DebugUtil::m_TracedClasses;
class NotClassName: public std::unary_function<const Object*, bool>
{
QString name;
public:
NotClassName(const QString& s) :
name(s)
{
}
bool operator()(const Object* entry) const
{
return name != entry->GetClassName();
}
};
-class AccumulateClassNames: public std::binary_function<QSet<QString>*, const Object*, QSet<QString>*>
-{
-public:
- QSet<QString>* operator()(QSet<QString>* names, const Object* entry)
- {
- names->insert(entry->GetClassName());
- return names;
- }
-};
-
DebugBreakpointManager* DebugUtil::GetBreakpointManager()
{
static DebugBreakpointManager breakpointManager;
return &breakpointManager;
}
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::TraceObject(const Object* object)
{
BERRY_INFO << "Tracing enabled for: " << object->GetTraceId() << std::endl;
m_TracedObjects.insert(object->GetTraceId());
_G_ObjectEvents.objTracingEvent(object->GetTraceId(), true, object);
}
#else
void DebugUtil::TraceObject(const Object* /*object*/)
{
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::TraceObject(unsigned int traceId)
{
BERRY_INFO << "Tracing enabled for: " << traceId << std::endl;
m_TracedObjects.insert(traceId);
TraceIdToObjectType::ConstIterator i = m_TraceIdToObjectMap.find(traceId);
if (i != m_TraceIdToObjectMap.end())
_G_ObjectEvents.objTracingEvent(traceId, true, i.value());
else
_G_ObjectEvents.objTracingEvent(traceId, true, 0);
}
#else
void DebugUtil::TraceObject(unsigned int /*traceId*/)
{
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::TraceClass(const QString& className)
{
BERRY_INFO << "Tracing enabled for: " << className << std::endl;
m_TracedClasses.insert(className);
//_G_ObjectEvents.objTracingEvent(object->GetTraceId(), true, object);
}
#else
void DebugUtil::TraceClass(const QString& /*className*/)
{
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::StopTracing(unsigned int traceId)
{
BERRY_INFO << "Tracing stopped for: " << traceId << std::endl;
m_TracedObjects.remove(traceId);
TraceIdToObjectType::ConstIterator i = m_TraceIdToObjectMap.find(traceId);
if (i != m_TraceIdToObjectMap.end())
_G_ObjectEvents.objTracingEvent(traceId, false, i.value());
else
_G_ObjectEvents.objTracingEvent(traceId, false, 0);
}
#else
void DebugUtil::StopTracing(unsigned int /*traceId*/)
{
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::StopTracing(const Object* obj)
{
BERRY_INFO << "Tracing stopped for: " << obj->GetTraceId() << std::endl;
m_TracedObjects.remove(obj->GetTraceId());
_G_ObjectEvents.objTracingEvent(obj->GetTraceId(), false, obj);
}
#else
void DebugUtil::StopTracing(const Object* /*obj*/)
{
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::StopTracing(const QString& className)
{
BERRY_INFO << "Tracing stopped for: " << className << std::endl;
m_TracedClasses.remove(className);
//_G_ObjectEvents.objTracingEvent(obj->GetTraceId(), false, obj);
}
#else
void DebugUtil::StopTracing(const QString& /*className*/)
{
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
bool DebugUtil::IsTraced(const Object* object)
{
if (m_TracedObjects.find(object->GetTraceId()) != m_TracedObjects.end())
return true;
if (m_TracedClasses.find(object->GetClassName()) != m_TracedClasses.end())
return true;
return false;
}
#else
bool DebugUtil::IsTraced(const Object* /*object*/)
{
return false;
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
bool DebugUtil::IsTraced(unsigned int traceId)
{
if (m_TracedObjects.find(traceId) != m_TracedObjects.end())
return true;
TraceIdToObjectType::Iterator it = m_TraceIdToObjectMap.find(traceId);
if (it != m_TraceIdToObjectMap.end())
{
if (m_TracedClasses.find(it.value()->GetClassName()) != m_TracedClasses.end())
return true;
}
return false;
}
#else
bool DebugUtil::IsTraced(unsigned int /*traceId*/)
{
return false;
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
bool DebugUtil::IsTraced(const QString& className)
{
return m_TracedClasses.find(className) != m_TracedClasses.end();
}
#else
bool DebugUtil::IsTraced(const QString& /*className*/)
{
return false;
}
#endif
QSet<unsigned int> DebugUtil::GetTracedObjects()
{
return m_TracedObjects;
}
const Object* DebugUtil::GetObject(unsigned int traceId)
{
return m_TraceIdToObjectMap[traceId];
}
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
QList<unsigned int> DebugUtil::GetSmartPointerIDs(
const Object* objectPointer, const QList<unsigned int>& excludeList)
{
Q_ASSERT(objectPointer != 0);
QList<unsigned int> ids = m_TraceIdToSmartPointerMap[objectPointer->GetTraceId()];
for (QList<unsigned int>::const_iterator iter = excludeList.begin();
iter != excludeList.end(); ++iter)
ids.removeAll(*iter);
return ids;
}
#else
QList<unsigned int> DebugUtil::GetSmartPointerIDs(
const Object* /*objectPointer*/, const QList<unsigned int>& /*excludeList*/)
{
return QList<unsigned int>();
}
#endif
QList<const Object*> DebugUtil::GetRegisteredObjects()
{
return m_TraceIdToObjectMap.values();
}
void DebugUtil::PrintSmartPointerIDs(const Object* objectPointer, const QList<unsigned int>& excludeList)
{
qDebug() << "SmartPointer IDs [ ";
if (IsTraced(objectPointer))
{
QList<unsigned int> ids = GetSmartPointerIDs(objectPointer, excludeList);
for (QList<unsigned int>::const_iterator iter = ids.begin();
iter != ids.end(); ++iter)
{
qDebug() << *iter << " ";
}
}
else
{
qDebug() << "n/a ";
}
qDebug() << "]\n";
}
void DebugUtil::AddObjectListener(IDebugObjectListener* listener)
{
_G_ObjectEvents.AddListener(listener);
}
void DebugUtil::RemoveObjectListener(IDebugObjectListener* listener)
{
_G_ObjectEvents.RemoveListener(listener);
}
void DebugUtil::ResetObjectSummary()
{
m_TraceIdToObjectMap.clear();
m_TraceIdToSmartPointerMap.clear();
m_TracedObjects.clear();
}
bool DebugUtil::PrintObjectSummary(bool details)
{
QSet<QString> names;
- std::accumulate(m_TraceIdToObjectMap.begin(), m_TraceIdToObjectMap.end(), &names, AccumulateClassNames());
+
+ for (auto object : m_TraceIdToObjectMap)
+ names.insert(object->GetClassName());
if (!names.isEmpty())
{
std::cout << std::endl << std::endl << "#########################################################" << std::endl;
std::cout << "######## berry::Object leakage summary: ########" << std::endl << std::endl;
for (QSet<QString>::const_iterator i = names.begin();
i != names.end(); ++i)
{
PrintObjectSummary(*i, details);
if (details) std::cout << std::endl;
}
std::cout << std::endl << "#########################################################" << std::endl << std::endl;
}
return !names.isEmpty();
}
bool DebugUtil::PrintObjectSummary(const QString& className, bool details)
{
TraceIdToObjectType::ConstIterator endIter =
std::remove_if(m_TraceIdToObjectMap.begin(), m_TraceIdToObjectMap.end(), NotClassName(className));
qDebug() << "Class:" << className;
if (details) std::cout << std::endl;
std::size_t count = 0;
for (TraceIdToObjectType::ConstIterator iter = m_TraceIdToObjectMap.begin();
iter != endIter; ++iter, ++count)
{
if (details)
{
qDebug() << (*(iter.value()));
PrintSmartPointerIDs(iter.value());
}
}
qDebug() << "(" << count << " instances)\n";
return (count!=0);
}
unsigned int& DebugUtil::GetSmartPointerCounter()
{
static unsigned int counter = 0;
return counter;
}
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::UnregisterSmartPointer(unsigned int smartPointerId, const Object* objectPointer)
{
poco_assert(objectPointer != 0);
m_TraceIdToSmartPointerMap[objectPointer->GetTraceId()].removeAll(smartPointerId);
_G_ObjectEvents.spDestroyedEvent(smartPointerId, objectPointer);
}
#else
void DebugUtil::UnregisterSmartPointer(unsigned int /*smartPointerId*/, const Object* /*objectPointer*/)
{
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::RegisterSmartPointer(unsigned int smartPointerId, const Object* objectPointer, bool /*recordStack*/)
{
poco_assert(objectPointer != 0);
if (m_TracedClasses.find(objectPointer->GetClassName()) != m_TracedClasses.end() ||
m_TracedObjects.find(objectPointer->GetTraceId()) != m_TracedObjects.end())
{
m_TraceIdToSmartPointerMap[objectPointer->GetTraceId()].push_back(smartPointerId);
_G_ObjectEvents.spCreatedEvent(smartPointerId, objectPointer);
}
if (GetBreakpointManager()->BreakAtSmartpointer(smartPointerId))
poco_debugger_msg("SmartPointer Breakpoint reached");
}
#else
void DebugUtil::RegisterSmartPointer(unsigned int /*smartPointerId*/, const Object* /*objectPointer*/, bool /*recordStack*/)
{
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::RegisterObject(const Object* objectPointer)
{
m_TraceIdToObjectMap.insert(objectPointer->GetTraceId(), objectPointer);
_G_ObjectEvents.objCreatedEvent(objectPointer);
if (GetBreakpointManager()->BreakAtObject(objectPointer->GetTraceId()))
{
std::string msg = "SmartPointer Breakpoint reached for ";
msg += objectPointer->GetClassName().toStdString();
poco_debugger_msg(msg.c_str());
}
}
#else
void DebugUtil::RegisterObject(const Object* /*objectPointer*/)
{
}
#endif
#ifdef BLUEBERRY_DEBUG_SMARTPOINTER
void DebugUtil::UnregisterObject(const Object* objectPointer)
{
m_TraceIdToObjectMap.remove(objectPointer->GetTraceId());
_G_ObjectEvents.objDestroyedEvent(objectPointer);
}
#else
void DebugUtil::UnregisterObject(const Object* /*objectPointer*/)
{
}
#endif
bool DebugUtil::GetPersistencePath(QDir& path)
{
QFileInfo statePath = CTKPluginActivator::getPluginContext()->getDataFile(QString());
path = statePath.absoluteFilePath();
return true;
}
void DebugUtil::SaveState(const QDir& path)
{
QString saveFile = path.absoluteFilePath(DEBUG_UTIL_XML);
auto doc = new Poco::XML::Document();
Poco::XML::Element* debugutil = doc->createElement(DEBUGUTIL_TAG.toStdString());
doc->appendChild(debugutil)->release();
for (QSet<unsigned int>::const_iterator i = m_TracedObjects.begin();
i != m_TracedObjects.end(); ++i)
{
Poco::XML::Element* traceObject = doc->createElement(TRACEOBJECT_TAG.toStdString());
debugutil->appendChild(traceObject)->release();
traceObject->setAttribute(ID_ATTR.toStdString(), QString::number(*i).toStdString());
}
for (QSet<QString>::const_iterator i = m_TracedClasses.begin();
i != m_TracedClasses.end(); ++i)
{
Poco::XML::Element* traceClass = doc->createElement(TRACECLASS_TAG.toStdString());
debugutil->appendChild(traceClass)->release();
traceClass->setAttribute(NAME_ATTR.toStdString(), i->toStdString());
}
try
{
Poco::FileOutputStream writer(saveFile.toStdString());
Poco::XML::DOMWriter out;
out.setOptions(3); //write declaration and pretty print
out.writeNode(writer, doc);
doc->release();
// save BreakpointManager
QString saveBM = path.absoluteFilePath(QString::fromStdString(DebugBreakpointManager::BREAKPOINTS_XML));
GetBreakpointManager()->SaveState(saveBM);
}
catch (Poco::FileException& e)
{
BERRY_WARN << e.displayText();
}
}
void DebugUtil::RestoreState(const QDir& path)
{
QString restoreFile = path.absoluteFilePath(DEBUG_UTIL_XML);
try
{
Poco::XML::DOMParser parser;
Poco::FileInputStream reader(restoreFile.toStdString());
Poco::XML::InputSource source(reader);
//source.setSystemId(baseDir);
Poco::XML::Document* doc = parser.parse(&source);
Poco::XML::Element* debugutil = doc->documentElement();
if (debugutil)
{
// restore traced objects
Poco::XML::NodeList* elementList = debugutil->getElementsByTagName(TRACEOBJECT_TAG.toStdString());
for (std::size_t i = 0; i < elementList->length(); i++)
{
Poco::XML::Element* elem =
dynamic_cast<Poco::XML::Element*> (elementList->item(static_cast<unsigned long>(i)));
if (!elem->hasAttribute(ID_ATTR.toStdString())) continue;
const std::string& attr = elem->getAttribute(ID_ATTR.toStdString());
int traceId = 0;
try
{
traceId = Poco::NumberParser::parse(attr);
}
catch (const Poco::SyntaxException& e)
{
BERRY_WARN << e.displayText();
}
DebugUtil::TraceObject(traceId);
}
elementList->release();
// restore traced classes
elementList = debugutil->getElementsByTagName(TRACECLASS_TAG.toStdString());
for (std::size_t i = 0; i < elementList->length(); i++)
{
Poco::XML::Element* elem =
dynamic_cast<Poco::XML::Element*> (elementList->item(static_cast<unsigned long>(i)));
if (!elem->hasAttribute(NAME_ATTR.toStdString())) continue;
const std::string& traceClass = elem->getAttribute(NAME_ATTR.toStdString());
if (!traceClass.empty())
DebugUtil::TraceClass(QString::fromStdString(traceClass));
}
elementList->release();
}
doc->release();
}
catch (Poco::XML::SAXParseException& e)
{
BERRY_WARN << e.displayText();
}
catch (Poco::FileNotFoundException&)
{
}
catch (Poco::FileException& e)
{
BERRY_WARN << e.displayText();
}
// restore BreakpointManager
GetBreakpointManager()->RestoreState(path.absoluteFilePath(QString::fromStdString(DebugBreakpointManager::BREAKPOINTS_XML)));
}
}