Merge branch 'devel/master' into tizen

[platform/core/uifw/dali-core.git] / dali / internal / update / common / uniform-map.cpp

diff --git a/dali/internal/update/common/uniform-map.cpp b/dali/internal/update/common/uniform-map.cpp
index c68ac13..cdd979c 100644 (file)
--- a/dali/internal/update/common/uniform-map.cpp
+++ b/dali/internal/update/common/uniform-map.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 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.
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include <algorithm>
+
 // CLASS HEADER
 #include <dali/internal/update/common/uniform-map.h>
 
@@ -23,141 +25,63 @@ namespace Internal
 {
 namespace SceneGraph
 {
-UniformMap::UniformMap() = default;
-
-UniformMap::~UniformMap()
-{
-  // Nothing to do - let the owner container delete the maps
-}
-
-void UniformMap::AddObserver( Observer& observer )
-{
-  bool foundObserver = false;
-  for( ObserversIter iter = mObservers.Begin(); iter != mObservers.End(); ++iter )
-  {
-    if( *iter == &observer )
-    {
-      foundObserver = true;
-      break;
-    }
-  }
-  if( !foundObserver )
-  {
-    mObservers.PushBack( &observer );
-  }
-}
-
-void UniformMap::RemoveObserver( Observer& observer )
-{
-  for( ObserversIter iter = mObservers.Begin(); iter != mObservers.End(); ++iter )
-  {
-    if( *iter == &observer )
-    {
-      mObservers.Erase(iter);
-      return;
-    }
-  }
-}
-
 void UniformMap::MappingChanged()
 {
-  for( ObserversIter iter = mObservers.Begin(); iter != mObservers.End(); ++iter )
-  {
-    Observer* observer = (*iter);
-    observer->UniformMappingsChanged( *this );
-  }
+  ++mChangeCounter;
 }
 
-void UniformMap::Add( UniformPropertyMapping* newMap )
+void UniformMap::Add(UniformPropertyMapping newMap)
 {
-  UniformPropertyMapping::Hash nameHash = CalculateHash( newMap->uniformName );
-
-  bool found = false;
+  auto iter = std::find_if(mUniformMaps.Begin(),
+                           mUniformMaps.End(),
+                           [&](auto& element) { return element.uniformName == newMap.uniformName; });
 
-  for( UniformMapIter iter = mUniformMaps.Begin() ;
-       iter != mUniformMaps.End() ;
-       ++iter )
+  if(iter != mUniformMaps.End())
   {
-    UniformPropertyMapping* map = *iter;
-    if( map->uniformNameHash == nameHash )
-    {
-      if( map->uniformName == newMap->uniformName )
-      {
-        found = true;
-        // Mapping already exists - update it.
-        map->propertyPtr = newMap->propertyPtr;
-        break;
-      }
-    }
+    // Mapping already exists - update it.
+    (*iter).propertyPtr = newMap.propertyPtr;
   }
-
-  if( found == false )
+  else
   {
-    // Take ownership of the new map
+    // add the new map.
     mUniformMaps.PushBack(newMap);
   }
 
   MappingChanged();
 }
 
-void UniformMap::Remove( const std::string& uniformName )
+void UniformMap::Remove(ConstString uniformName)
 {
-  UniformPropertyMapping::Hash nameHash = CalculateHash( uniformName );
+  auto iter = std::find_if(mUniformMaps.Begin(),
+                           mUniformMaps.End(),
+                           [&](auto& element) { return element.uniformName == uniformName; });
 
-  bool found=false;
-
-  for( UniformMapIter iter = mUniformMaps.Begin() ;
-       iter != mUniformMaps.End() ;
-       ++iter )
-  {
-    UniformPropertyMapping* map = *iter;
-    if( map->uniformNameHash == nameHash )
-    {
-      if( map->uniformName == uniformName )
-      {
-        mUniformMaps.Erase( iter );
-        found = true;
-        break;
-      }
-    }
-  }
-
-  if( found )
+  if(iter != mUniformMaps.End())
   {
+    mUniformMaps.Erase(iter);
     MappingChanged();
   }
 }
 
-const PropertyInputImpl* UniformMap::Find( const std::string& uniformName )
+const PropertyInputImpl* UniformMap::Find(ConstString uniformName)
 {
-  UniformPropertyMapping::Hash nameHash = CalculateHash( uniformName );
+  auto iter = std::find_if(mUniformMaps.Begin(),
+                           mUniformMaps.End(),
+                           [&](auto& element) { return element.uniformName == uniformName; });
 
-  for( UniformMapIter iter = mUniformMaps.Begin() ;
-       iter != mUniformMaps.End() ;
-       ++iter )
-  {
-    UniformPropertyMapping* map = *iter;
-    if( map->uniformNameHash == nameHash )
-    {
-      if( map->uniformName == uniformName )
-      {
-        return map->propertyPtr;
-      }
-    }
-  }
-  return nullptr;
+  return (iter != mUniformMaps.End()) ? (*iter).propertyPtr : nullptr;
 }
 
 UniformMap::SizeType UniformMap::Count() const
 {
-  return static_cast<UniformMap::SizeType>( mUniformMaps.Count() );
+  return static_cast<UniformMap::SizeType>(mUniformMaps.Count());
 }
 
-const UniformPropertyMapping& UniformMap::operator[]( UniformMap::SizeType index ) const
+const UniformPropertyMapping& UniformMap::operator[](UniformMap::SizeType index) const
 {
-  return *mUniformMaps[index];
+  return mUniformMaps[index];
 }
 
-} // SceneGraph
-} // Internal
-} // Dali
+} // namespace SceneGraph
+} // namespace Internal
+} // namespace Dali