/*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <dali/integration-api/debug.h>
// EXTERNAL INCLUDES
-#include <cstdio>
+#include <chrono>
#include <cstdarg>
-#include <cstring>
-#include <cstdlib>
-#include <sstream>
-#include <iomanip>
-#include <ctime>
-
-// INTERNAL INCLUDES
-#include <dali/public-api/common/constants.h>
-#include <dali/public-api/math/matrix3.h>
-#include <dali/public-api/math/matrix.h>
-#include <dali/public-api/math/vector3.h>
-#include <dali/public-api/math/vector4.h>
-#include <dali/public-api/math/quaternion.h>
-#include <dali/internal/event/common/thread-local-storage.h>
namespace Dali
{
-
#ifdef DEBUG_ENABLED
// Fake globals for gdb typedefs
#endif
-
-namespace // unnamed namespace
-{
-
-const uint64_t NANOSECONDS_PER_SECOND = 1e+9;
-
-}
-
namespace Integration
{
-
namespace Log
{
-
-thread_local LogFunction gthreadLocalLogFunction = NULL;
+thread_local LogFunction gthreadLocalLogFunction = nullptr;
/* Forward declarations */
-std::string FormatToString(const char *format, ...);
-std::string ArgListToString(const char *format, va_list args);
+std::string FormatToString(const char* format, ...);
+std::string ArgListToString(const char* format, va_list args);
void LogMessage(DebugPriority priority, const char* format, ...)
{
- if ( !gthreadLocalLogFunction )
+ if(!gthreadLocalLogFunction)
{
return;
}
std::string message = ArgListToString(format, arg);
va_end(arg);
- gthreadLocalLogFunction(priority,message);
+ gthreadLocalLogFunction(priority, message);
}
void InstallLogFunction(const LogFunction& logFunction)
void UninstallLogFunction()
{
- gthreadLocalLogFunction = NULL;
+ gthreadLocalLogFunction = nullptr;
}
#ifdef DEBUG_ENABLED
Filter* Filter::gRender = Filter::New(Debug::Concise, false, "LOG_RENDER");
Filter* Filter::gResource = Filter::New(Debug::Concise, false, "LOG_RESOURCE");
Filter* Filter::gGLResource = Filter::New(Debug::Concise, false, "LOG_GL_RESOURCE");
-Filter* Filter::gObject = NULL;
+Filter* Filter::gObject = nullptr;
Filter* Filter::gImage = Filter::New(Debug::Concise, false, "LOG_IMAGE");
Filter* Filter::gModel = Filter::New(Debug::Concise, false, "LOG_MODEL");
-Filter* Filter::gNode = NULL;
-Filter* Filter::gElement = NULL;
+Filter* Filter::gNode = nullptr;
+Filter* Filter::gElement = nullptr;
Filter* Filter::gActor = Filter::New(Debug::Concise, false, "LOG_ACTOR");
Filter* Filter::gShader = Filter::New(Debug::Concise, false, "LOG_SHADER");
return activeFilters;
}
-Filter* Filter::New( LogLevel level, bool trace, const char * environmentVariableName )
+Filter* Filter::New(LogLevel level, bool trace, const char* environmentVariableName)
{
- char * environmentVariableValue = getenv( environmentVariableName );
- if ( environmentVariableValue )
+ char* environmentVariableValue = getenv(environmentVariableName);
+ if(environmentVariableValue)
{
unsigned int envLevel(0);
- char envTraceString(0);
- sscanf( environmentVariableValue, "%u,%c", &envLevel, &envTraceString );
+ char envTraceString(0);
+ sscanf(environmentVariableValue, "%u,%c", &envLevel, &envTraceString);
- if ( envLevel > Verbose )
+ if(envLevel > Verbose)
{
envLevel = Verbose;
}
- level = LogLevel( envLevel );
+ level = LogLevel(envLevel);
// Just use 'f' and 't' as it's faster than doing full string comparisons
- if ( envTraceString == 't' )
+ if(envTraceString == 't')
{
trace = true;
}
- else if ( envTraceString == 'f' )
+ else if(envTraceString == 'f')
{
trace = false;
}
}
}
+void Filter::SetGlobalLogLevel(LogLevel level)
+{
+ for(FilterIter iter = GetActiveFilters()->begin(); iter != GetActiveFilters()->end(); iter++)
+ {
+ (*iter)->SetLogLevel(level);
+ }
+}
void Filter::Log(LogLevel level, const char* format, ...)
{
va_list arg;
va_start(arg, format);
- if( mTraceEnabled )
+ if(mTraceEnabled)
{
- char *buffer = NULL;
- int numChars = asprintf( &buffer, " %-*c %s", mNesting, ':', format );
- if( numChars >= 0 ) // No error
+ char* buffer = nullptr;
+ int numChars = asprintf(&buffer, " %-*c %s", mNesting, ':', format);
+ if(numChars >= 0) // No error
{
- std::string message = ArgListToString( buffer, arg );
- LogMessage( DebugInfo, message.c_str() );
- free( buffer );
+ std::string message = ArgListToString(buffer, arg);
+ LogMessage(DebugInfo, message.c_str());
+ free(buffer);
}
}
else
{
- std::string message = ArgListToString( format, arg );
- LogMessage( DebugInfo, message.c_str() );
+ std::string message = ArgListToString(format, arg);
+ LogMessage(DebugInfo, message.c_str());
}
va_end(arg);
}
}
-
-TraceObj::TraceObj(Filter* filter, const char*format, ...) : mFilter(filter)
+TraceObj::TraceObj(Filter* filter, const char* format, ...)
+: mFilter(filter)
{
if(mFilter && mFilter->IsTraceEnabled())
{
{
if(mFilter && mFilter->IsTraceEnabled())
{
- if (mFilter->mNesting)
+ if(mFilter->mNesting)
{
--mFilter->mNesting;
}
#endif // DEBUG_ENABLED
-
-std::string ArgListToString(const char *format, va_list args)
+std::string ArgListToString(const char* format, va_list args)
{
std::string str; // empty string
- if(format != NULL)
+ if(format != nullptr)
{
- char* buffer = NULL;
- int err = vasprintf(&buffer, format, args);
+ char* buffer = nullptr;
+ int err = vasprintf(&buffer, format, args);
if(err >= 0) // No error
{
str = buffer;
return str;
}
-std::string FormatToString(const char *format, ...)
+std::string FormatToString(const char* format, ...)
{
va_list arg;
va_start(arg, format);
return s;
}
-void GetNanoseconds( uint64_t& timeInNanoseconds )
+#ifdef DEBUG_ENABLED
+
+void GetNanoseconds(uint64_t& timeInNanoseconds)
{
- timespec timeSpec;
- clock_gettime( CLOCK_MONOTONIC, &timeSpec );
+ // Get the time of a monotonic clock since its epoch.
+ auto epoch = std::chrono::steady_clock::now().time_since_epoch();
+
+ auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(epoch);
- // Convert all values to uint64_t to match our return type
- timeInNanoseconds = ( static_cast< uint64_t >( timeSpec.tv_sec ) * NANOSECONDS_PER_SECOND ) + static_cast< uint64_t >( timeSpec.tv_nsec );
+ timeInNanoseconds = static_cast<uint64_t>(duration.count());
}
+#endif // DEBUG_ENABLED
+
} // namespace Log
} // namespace Integration