Merge "Clean up the code to build successfully on macOS" into devel/master

[platform/core/uifw/dali-core.git] / dali / internal / event / common / thread-local-storage.cpp

diff --git a/dali/internal/event/common/thread-local-storage.cpp b/dali/internal/event/common/thread-local-storage.cpp
index f59bd27..0628fbe 100644 (file)
--- a/dali/internal/event/common/thread-local-storage.cpp
+++ b/dali/internal/event/common/thread-local-storage.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -21,6 +21,24 @@
 // INTERNAL INCLUDES
 #include <dali/internal/common/core-impl.h>
 #include <dali/public-api/common/dali-common.h>
+#include <dali/internal/event/common/event-thread-services.h>
+#include <dali/integration-api/processor-interface.h>
+
+#if defined(DEBUG_ENABLED)
+#include <dali/integration-api/debug.h>
+Debug::Filter* gSingletonServiceLogFilter = Debug::Filter::New( Debug::NoLogging, false, "LOG_SINGLETON_SERVICE" );
+
+// Need to define own macro as the log function is not installed when this object is created so no logging is shown with DALI_LOG_INFO at construction and destruction
+#define DALI_LOG_SINGLETON_SERVICE_DIRECT(level, message)                        \
+    if(gSingletonServiceLogFilter && gSingletonServiceLogFilter->IsEnabledFor(level)) { std::string string(message); Dali::TizenPlatform::LogMessage( Debug::DebugInfo, string );  }
+
+#define DALI_LOG_SINGLETON_SERVICE(level, format, ...) DALI_LOG_INFO(gSingletonServiceLogFilter, level, format, ## __VA_ARGS__ )
+#else
+
+#define DALI_LOG_SINGLETON_SERVICE_DIRECT(level, message)
+#define DALI_LOG_SINGLETON_SERVICE(level, format, ...)
+
+#endif
 
 namespace Dali
 {
@@ -30,24 +48,22 @@ namespace Internal
 
 namespace
 {
-__thread ThreadLocalStorage* threadLocal = NULL;
+thread_local ThreadLocalStorage* threadLocal = nullptr;
 }
 
 ThreadLocalStorage::ThreadLocalStorage(Core* core)
 : mCore( core )
 {
-  DALI_ASSERT_ALWAYS( threadLocal == NULL && "Cannot create more than one ThreadLocalStorage object" );
+  DALI_ASSERT_ALWAYS( threadLocal == nullptr && "Cannot create more than one ThreadLocalStorage object" );
 
   threadLocal = this;
 }
 
-ThreadLocalStorage::~ThreadLocalStorage()
-{
-}
+ThreadLocalStorage::~ThreadLocalStorage() = default;
 
 void ThreadLocalStorage::Remove()
 {
-  threadLocal = NULL;
+  threadLocal = nullptr;
 }
 
 ThreadLocalStorage& ThreadLocalStorage::Get()
@@ -57,10 +73,20 @@ ThreadLocalStorage& ThreadLocalStorage::Get()
   return *threadLocal;
 }
 
+Dali::SingletonService ThreadLocalStorage::GetSingletonService()
+{
+  Dali::SingletonService singletonService;
+  if ( threadLocal )
+  {
+    singletonService = Dali::SingletonService( threadLocal );
+  }
+  return singletonService;
+}
+
 bool ThreadLocalStorage::Created()
 {
   // see if the TLS has been set yet
-  return (threadLocal != NULL);
+  return (threadLocal != nullptr);
 }
 
 ThreadLocalStorage* ThreadLocalStorage::GetInternal()
@@ -103,6 +129,93 @@ RelayoutController& ThreadLocalStorage::GetRelayoutController()
   return mCore->GetRelayoutController();
 }
 
+ObjectRegistry& ThreadLocalStorage::GetObjectRegistry()
+{
+  return mCore->GetObjectRegistry();
+}
+
+EventThreadServices& ThreadLocalStorage::GetEventThreadServices()
+{
+  return mCore->GetEventThreadServices();
+}
+
+PropertyNotificationManager& ThreadLocalStorage::GetPropertyNotificationManager()
+{
+  return mCore->GetPropertyNotificationManager();
+}
+
+AnimationPlaylist& ThreadLocalStorage::GetAnimationPlaylist()
+{
+  return mCore->GetAnimationPlaylist();
+}
+
+bool ThreadLocalStorage::IsBlendEquationSupported( DevelBlendEquation::Type blendEquation )
+{
+  return mCore->GetGlAbstraction().IsBlendEquationSupported( blendEquation );
+}
+
+std::string ThreadLocalStorage::GetShaderVersionPrefix()
+{
+  return mCore->GetGlAbstraction().GetShaderVersionPrefix();
+}
+
+std::string ThreadLocalStorage::GetVertexShaderPrefix()
+{
+  return mCore->GetGlAbstraction().GetVertexShaderPrefix();
+}
+
+std::string ThreadLocalStorage::GetFragmentShaderPrefix()
+{
+  return mCore->GetGlAbstraction().GetFragmentShaderPrefix();
+}
+
+void ThreadLocalStorage::AddScene( Scene* scene )
+{
+  mCore->AddScene( scene );
+}
+
+void ThreadLocalStorage::RemoveScene( Scene* scene )
+{
+  mCore->RemoveScene( scene );
+}
+
+void ThreadLocalStorage::Register( const std::type_info& info, BaseHandle singleton )
+{
+  if( singleton )
+  {
+    DALI_LOG_SINGLETON_SERVICE( Debug::General, "Singleton Added: %s\n", info.name() );
+    mSingletonContainer.push_back( SingletonPair( info.name(), singleton ) );
+
+    Integration::Processor* processor = dynamic_cast<Integration::Processor*>( &singleton.GetBaseObject() );
+    if( processor )
+    {
+      mCore->RegisterProcessor( *processor );
+    }
+  }
+}
+
+void ThreadLocalStorage::UnregisterAll( )
+{
+  mSingletonContainer.clear();
+}
+
+BaseHandle ThreadLocalStorage::GetSingleton( const std::type_info& info ) const
+{
+  BaseHandle object;
+
+  const SingletonContainer::const_iterator end = mSingletonContainer.end();
+  for( SingletonContainer::const_iterator iter = mSingletonContainer.begin(); iter != end; ++iter )
+  {
+    // comparing the addresses as these are allocated statically per library
+    if( ( *iter ).first == info.name() )
+    {
+      object = ( *iter ).second;
+    }
+  }
+
+  return object;
+}
+
 } // namespace Internal
 
 } // namespace Dali