X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Fbuilder%2Fdictionary.h;h=b570c047513852f50cd83507a9f9d23b3ebabf91;hp=ccccf2c8d07d6a85dc1beee46ffef7c5e7f0c02f;hb=9ddd5fea6278d06b8874988498c7c4c6508750ba;hpb=c67661e5069476a5ce720a31bb0b06e6c4be793e diff --git a/dali-toolkit/internal/builder/dictionary.h b/dali-toolkit/internal/builder/dictionary.h index ccccf2c..b570c04 100644 --- a/dali-toolkit/internal/builder/dictionary.h +++ b/dali-toolkit/internal/builder/dictionary.h @@ -2,7 +2,7 @@ #define DALI_TOOLKIT_INTERNAL_BUILDER_DICTIONARY_H /* - * Copyright (c) 2017 Samsung Electronics Co., Ltd. + * Copyright (c) 2021 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. @@ -18,17 +18,18 @@ */ #include + #include +#include namespace Dali { -extern bool CaseInsensitiveStringCompare( const std::string& a, const std::string& b ); +extern bool CaseInsensitiveStringCompare(std::string_view a, std::string_view b); namespace Toolkit { namespace Internal { - /** * The Dictionary template class enables a means of storing key-value * pairs where the keys are strings and the value can be a complex @@ -36,6 +37,21 @@ namespace Internal * * It enables lookup of keys via case-insensitive match. */ + +using DictionaryKeys = std::vector; + +inline void Merge(DictionaryKeys& toDict, const DictionaryKeys& fromDict) +{ + for(const auto& element : fromDict) + { + auto iter = std::find(toDict.cbegin(), toDict.cend(), element); + if(iter == toDict.cend()) + { + toDict.push_back(element); + } + } +} + template class Dictionary { @@ -46,153 +62,168 @@ private: struct Element { std::string key; - EntryType entry; - Element( const std::string&name, EntryType entry ) - : key( name ), - entry( entry ) + EntryType entry; + Element(std::string name, EntryType entry) + : key(std::move(name)), + entry(std::move(entry)) { } }; - typedef std::vector Elements; + using Elements = std::vector; Elements container; + auto FindElementCaseInsensitive(std::string_view key) const + { + return std::find_if( + Begin(), End(), [key](auto& e) { return Dali::CaseInsensitiveStringCompare(e.key, key); }); + } + + auto FindElement(std::string_view key) + { + return std::find_if(container.begin(), container.end(), [key](auto& e) { + return bool(key == e.key); + }); + } + public: /** * Only allow const iteration over the dictionary */ - typedef typename Elements::const_iterator iterator; - + using iterator = typename Elements::const_iterator; /** * Constructor */ - Dictionary() - { - } + Dictionary() = default; /** * Add a key value pair to the dictionary. * If the entry does not already exist, add it to the dictionary - * using a shallow copy */ - bool Add( const std::string& name, const EntryType& entry ) + bool Add(std::string name, EntryType entry) { - for( typename Elements::iterator iter = container.begin(); iter != container.end(); ++iter ) + auto iter = FindElement(name); + if(iter != End()) { - if( iter->key == name ) - { - return false; - } + return false; } - container.push_back( Element(name, entry) ); + + container.push_back(Element(std::move(name), std::move(entry))); return true; } /** * Add a key-value pair to the dictionary * If the entry does not already exist, add it to the dictionary - * (shallow copy) */ - bool Add( const char* name, const EntryType& entry ) + bool Add(const char* name, EntryType entry) { - bool result=false; - if( name != NULL ) + if(name != nullptr) { - std::string theName(name); - result=Add(theName, entry); + return Add(std::string(name), std::move(entry)); } - return result; + return false; } /** - * Find the element in the dictionary pointed at by key, and - * insensitive search, and return a const pointer to it, or NULL + * Remove a key value pair from the dictionary. */ - const EntryType* FindConst( const std::string& key ) const + void Remove(std::string_view name) { - if( ! key.empty() ) + if(!name.empty()) { - for( typename Elements::const_iterator iter = container.begin(); iter != container.end(); ++iter ) + auto iter = FindElement(name); + + if(iter != End()) { - if( Dali::CaseInsensitiveStringCompare(iter->key, key )) - { - const EntryType* result = &(iter->entry); - return result; - } + container.erase(iter); } } - return NULL; } - /** - * Find the element in the dictionary pointed at by key using a case - * insensitive search, and return a non-const pointer to it, or NULL - */ - EntryType* Find( const std::string& key ) const + void Merge(const Dictionary& dictionary) { - EntryType* result = NULL; - if( ! key.empty() ) + for(const auto& element : dictionary.container) { - for( typename Elements::const_iterator iter = container.begin(); iter != container.end(); ++iter ) + auto iter = FindElement(element.key); + + if(iter == End()) { - if( Dali::CaseInsensitiveStringCompare(iter->key, key )) - { - // Const cast because of const_iterator. const_iterator because, STL. - result = const_cast(&(iter->entry)); - } + container.push_back(Element(element.key, element.entry)); + } + else + { + iter->entry = element.entry; } } - return result; } /** - * Find the element in the dictionary pointed at by key using a case + * Find the element in the dictionary pointed at by key, and * insensitive search, and return a const pointer to it, or NULL */ - const EntryType* FindConst( const char* key ) const + const EntryType* FindConst(std::string_view key) const { - if( key != NULL ) + if(!key.empty()) { - std::string theKey(key); - return FindConst( theKey ); + auto iter = FindElementCaseInsensitive(key); + + if(iter != End()) + { + return &(iter->entry); + } } - return NULL; + return nullptr; } /** * Find the element in the dictionary pointed at by key using a case * insensitive search, and return a non-const pointer to it, or NULL */ - EntryType* Find( const char* key ) const + EntryType* Find(std::string_view key) const { - if( key != NULL ) + if(!key.empty()) { - std::string theKey(key); - return Find( theKey ); + auto iter = FindElementCaseInsensitive(key); + + if(iter != End()) + { + return const_cast(&(iter->entry)); + } } - return NULL; + return nullptr; } - /** - * Return an iterator pointing at the first entry in the dictionary - */ - typename Elements::const_iterator Begin() const + + iterator Begin() const { - return container.begin(); + return container.cbegin(); } /** * Return an iterator pointing past the last entry in the dictionary */ - typename Elements::const_iterator End() const + iterator End() const { - return container.end(); + return container.cend(); } -}; + void GetKeys(DictionaryKeys& keys) const + { + keys.clear(); + for(const auto& element : container) + { + keys.push_back(element.key); + } + } + void Clear() + { + container.clear(); + } +}; -}//Internal -}//Toolkit -}//Dali +} // namespace Internal +} // namespace Toolkit +} // namespace Dali #endif // DALI_TOOLKIT_INTERNAL_BUILDER_DICTIONARY_H