aboutsummaryrefslogtreecommitdiff
path: root/include/lldb/Core/UniqueCStringMap.h
diff options
context:
space:
mode:
Diffstat (limited to 'include/lldb/Core/UniqueCStringMap.h')
-rw-r--r--include/lldb/Core/UniqueCStringMap.h522
1 files changed, 218 insertions, 304 deletions
diff --git a/include/lldb/Core/UniqueCStringMap.h b/include/lldb/Core/UniqueCStringMap.h
index 1e50f747f2a8..77a350aaea15 100644
--- a/include/lldb/Core/UniqueCStringMap.h
+++ b/include/lldb/Core/UniqueCStringMap.h
@@ -30,326 +30,240 @@ namespace lldb_private {
// Any other string table that has guaranteed unique values can also
// be used.
//----------------------------------------------------------------------
-template <typename T>
-class UniqueCStringMap
-{
+template <typename T> class UniqueCStringMap {
public:
- struct Entry
- {
- Entry () :
- cstring(nullptr),
- value()
- {
- }
-
- Entry (const char *cstr) :
- cstring(cstr),
- value()
- {
- }
-
- Entry (const char *cstr, const T&v) :
- cstring(cstr),
- value(v)
- {
- }
-
- bool
- operator < (const Entry& rhs) const
- {
- return cstring < rhs.cstring;
- }
-
- const char* cstring;
- T value;
- };
-
- //------------------------------------------------------------------
- // Call this function multiple times to add a bunch of entries to
- // this map, then later call UniqueCStringMap<T>::Sort() before doing
- // any searches by name.
- //------------------------------------------------------------------
- void
- Append (const char *unique_cstr, const T& value)
- {
- m_map.push_back (typename UniqueCStringMap<T>::Entry(unique_cstr, value));
- }
-
- void
- Append (const Entry &e)
- {
- m_map.push_back (e);
- }
-
- void
- Clear ()
- {
- m_map.clear();
+ struct Entry {
+ Entry() {}
+
+ Entry(llvm::StringRef cstr) : cstring(cstr), value() {}
+
+ Entry(llvm::StringRef cstr, const T &v) : cstring(cstr), value(v) {}
+
+ bool operator<(const Entry &rhs) const { return cstring < rhs.cstring; }
+
+ llvm::StringRef cstring;
+ T value;
+ };
+
+ //------------------------------------------------------------------
+ // Call this function multiple times to add a bunch of entries to
+ // this map, then later call UniqueCStringMap<T>::Sort() before doing
+ // any searches by name.
+ //------------------------------------------------------------------
+ void Append(llvm::StringRef unique_cstr, const T &value) {
+ m_map.push_back(typename UniqueCStringMap<T>::Entry(unique_cstr, value));
+ }
+
+ void Append(const Entry &e) { m_map.push_back(e); }
+
+ void Clear() { m_map.clear(); }
+
+ //------------------------------------------------------------------
+ // Call this function to always keep the map sorted when putting
+ // entries into the map.
+ //------------------------------------------------------------------
+ void Insert(llvm::StringRef unique_cstr, const T &value) {
+ typename UniqueCStringMap<T>::Entry e(unique_cstr, value);
+ m_map.insert(std::upper_bound(m_map.begin(), m_map.end(), e), e);
+ }
+
+ void Insert(const Entry &e) {
+ m_map.insert(std::upper_bound(m_map.begin(), m_map.end(), e), e);
+ }
+
+ //------------------------------------------------------------------
+ // Get an entries by index in a variety of forms.
+ //
+ // The caller is responsible for ensuring that the collection does
+ // not change during while using the returned values.
+ //------------------------------------------------------------------
+ bool GetValueAtIndex(uint32_t idx, T &value) const {
+ if (idx < m_map.size()) {
+ value = m_map[idx].value;
+ return true;
}
-
- //------------------------------------------------------------------
- // Call this function to always keep the map sorted when putting
- // entries into the map.
- //------------------------------------------------------------------
- void
- Insert (const char *unique_cstr, const T& value)
- {
- typename UniqueCStringMap<T>::Entry e(unique_cstr, value);
- m_map.insert (std::upper_bound (m_map.begin(), m_map.end(), e), e);
+ return false;
+ }
+
+ llvm::StringRef GetCStringAtIndexUnchecked(uint32_t idx) const {
+ return m_map[idx].cstring;
+ }
+
+ // Use this function if you have simple types in your map that you
+ // can easily copy when accessing values by index.
+ T GetValueAtIndexUnchecked(uint32_t idx) const { return m_map[idx].value; }
+
+ // Use this function if you have complex types in your map that you
+ // don't want to copy when accessing values by index.
+ const T &GetValueRefAtIndexUnchecked(uint32_t idx) const {
+ return m_map[idx].value;
+ }
+
+ llvm::StringRef GetCStringAtIndex(uint32_t idx) const {
+ return ((idx < m_map.size()) ? m_map[idx].cstring : llvm::StringRef());
+ }
+
+ //------------------------------------------------------------------
+ // Find the value for the unique string in the map.
+ //
+ // Return the value for \a unique_cstr if one is found, return
+ // \a fail_value otherwise. This method works well for simple type
+ // T values and only if there is a sensible failure value that can
+ // be returned and that won't match any existing values.
+ //------------------------------------------------------------------
+ T Find(llvm::StringRef unique_cstr, T fail_value) const {
+ Entry search_entry(unique_cstr);
+ const_iterator end = m_map.end();
+ const_iterator pos = std::lower_bound(m_map.begin(), end, search_entry);
+ if (pos != end) {
+ if (pos->cstring == unique_cstr)
+ return pos->value;
}
-
- void
- Insert (const Entry &e)
- {
- m_map.insert (std::upper_bound (m_map.begin(), m_map.end(), e), e);
+ return fail_value;
+ }
+
+ //------------------------------------------------------------------
+ // Get a pointer to the first entry that matches "name". nullptr will
+ // be returned if there is no entry that matches "name".
+ //
+ // The caller is responsible for ensuring that the collection does
+ // not change during while using the returned pointer.
+ //------------------------------------------------------------------
+ const Entry *FindFirstValueForName(llvm::StringRef unique_cstr) const {
+ Entry search_entry(unique_cstr);
+ const_iterator end = m_map.end();
+ const_iterator pos = std::lower_bound(m_map.begin(), end, search_entry);
+ if (pos != end) {
+ llvm::StringRef pos_cstr = pos->cstring;
+ if (pos_cstr == unique_cstr)
+ return &(*pos);
}
-
- //------------------------------------------------------------------
- // Get an entries by index in a variety of forms.
- //
- // The caller is responsible for ensuring that the collection does
- // not change during while using the returned values.
- //------------------------------------------------------------------
- bool
- GetValueAtIndex (uint32_t idx, T &value) const
- {
- if (idx < m_map.size())
- {
- value = m_map[idx].value;
- return true;
- }
- return false;
+ return nullptr;
+ }
+
+ //------------------------------------------------------------------
+ // Get a pointer to the next entry that matches "name" from a
+ // previously returned Entry pointer. nullptr will be returned if there
+ // is no subsequent entry that matches "name".
+ //
+ // The caller is responsible for ensuring that the collection does
+ // not change during while using the returned pointer.
+ //------------------------------------------------------------------
+ const Entry *FindNextValueForName(const Entry *entry_ptr) const {
+ if (!m_map.empty()) {
+ const Entry *first_entry = &m_map[0];
+ const Entry *after_last_entry = first_entry + m_map.size();
+ const Entry *next_entry = entry_ptr + 1;
+ if (first_entry <= next_entry && next_entry < after_last_entry) {
+ if (next_entry->cstring == entry_ptr->cstring)
+ return next_entry;
+ }
}
-
- const char *
- GetCStringAtIndexUnchecked (uint32_t idx) const
- {
- return m_map[idx].cstring;
- }
-
- // Use this function if you have simple types in your map that you
- // can easily copy when accessing values by index.
- T
- GetValueAtIndexUnchecked (uint32_t idx) const
- {
- return m_map[idx].value;
+ return nullptr;
+ }
+
+ size_t GetValues(llvm::StringRef unique_cstr, std::vector<T> &values) const {
+ const size_t start_size = values.size();
+
+ Entry search_entry(unique_cstr);
+ const_iterator pos, end = m_map.end();
+ for (pos = std::lower_bound(m_map.begin(), end, search_entry); pos != end;
+ ++pos) {
+ if (pos->cstring == unique_cstr)
+ values.push_back(pos->value);
+ else
+ break;
}
- // Use this function if you have complex types in your map that you
- // don't want to copy when accessing values by index.
- const T &
- GetValueRefAtIndexUnchecked (uint32_t idx) const
- {
- return m_map[idx].value;
- }
+ return values.size() - start_size;
+ }
- const char *
- GetCStringAtIndex (uint32_t idx) const
- {
- return ((idx < m_map.size()) ? m_map[idx].cstring : nullptr);
- }
+ size_t GetValues(const RegularExpression &regex,
+ std::vector<T> &values) const {
+ const size_t start_size = values.size();
- //------------------------------------------------------------------
- // Find the value for the unique string in the map.
- //
- // Return the value for \a unique_cstr if one is found, return
- // \a fail_value otherwise. This method works well for simple type
- // T values and only if there is a sensible failure value that can
- // be returned and that won't match any existing values.
- //------------------------------------------------------------------
- T
- Find (const char *unique_cstr, T fail_value) const
- {
- Entry search_entry (unique_cstr);
- const_iterator end = m_map.end();
- const_iterator pos = std::lower_bound (m_map.begin(), end, search_entry);
- if (pos != end)
- {
- if (pos->cstring == unique_cstr)
- return pos->value;
- }
- return fail_value;
+ const_iterator pos, end = m_map.end();
+ for (pos = m_map.begin(); pos != end; ++pos) {
+ if (regex.Execute(pos->cstring))
+ values.push_back(pos->value);
}
- //------------------------------------------------------------------
- // Get a pointer to the first entry that matches "name". nullptr will
- // be returned if there is no entry that matches "name".
- //
- // The caller is responsible for ensuring that the collection does
- // not change during while using the returned pointer.
- //------------------------------------------------------------------
- const Entry *
- FindFirstValueForName (const char *unique_cstr) const
- {
- Entry search_entry (unique_cstr);
- const_iterator end = m_map.end();
- const_iterator pos = std::lower_bound (m_map.begin(), end, search_entry);
- if (pos != end)
- {
- const char *pos_cstr = pos->cstring;
- if (pos_cstr == unique_cstr)
- return &(*pos);
- }
- return nullptr;
+ return values.size() - start_size;
+ }
+
+ //------------------------------------------------------------------
+ // Get the total number of entries in this map.
+ //------------------------------------------------------------------
+ size_t GetSize() const { return m_map.size(); }
+
+ //------------------------------------------------------------------
+ // Returns true if this map is empty.
+ //------------------------------------------------------------------
+ bool IsEmpty() const { return m_map.empty(); }
+
+ //------------------------------------------------------------------
+ // Reserve memory for at least "n" entries in the map. This is
+ // useful to call when you know you will be adding a lot of entries
+ // using UniqueCStringMap::Append() (which should be followed by a
+ // call to UniqueCStringMap::Sort()) or to UniqueCStringMap::Insert().
+ //------------------------------------------------------------------
+ void Reserve(size_t n) { m_map.reserve(n); }
+
+ //------------------------------------------------------------------
+ // Sort the unsorted contents in this map. A typical code flow would
+ // be:
+ // size_t approximate_num_entries = ....
+ // UniqueCStringMap<uint32_t> my_map;
+ // my_map.Reserve (approximate_num_entries);
+ // for (...)
+ // {
+ // my_map.Append (UniqueCStringMap::Entry(GetName(...), GetValue(...)));
+ // }
+ // my_map.Sort();
+ //------------------------------------------------------------------
+ void Sort() { std::sort(m_map.begin(), m_map.end()); }
+
+ //------------------------------------------------------------------
+ // Since we are using a vector to contain our items it will always
+ // double its memory consumption as things are added to the vector,
+ // so if you intend to keep a UniqueCStringMap around and have
+ // a lot of entries in the map, you will want to call this function
+ // to create a new vector and copy _only_ the exact size needed as
+ // part of the finalization of the string map.
+ //------------------------------------------------------------------
+ void SizeToFit() {
+ if (m_map.size() < m_map.capacity()) {
+ collection temp(m_map.begin(), m_map.end());
+ m_map.swap(temp);
}
-
- //------------------------------------------------------------------
- // Get a pointer to the next entry that matches "name" from a
- // previously returned Entry pointer. nullptr will be returned if there
- // is no subsequent entry that matches "name".
- //
- // The caller is responsible for ensuring that the collection does
- // not change during while using the returned pointer.
- //------------------------------------------------------------------
- const Entry *
- FindNextValueForName (const Entry *entry_ptr) const
- {
- if (!m_map.empty())
- {
- const Entry *first_entry = &m_map[0];
- const Entry *after_last_entry = first_entry + m_map.size();
- const Entry *next_entry = entry_ptr + 1;
- if (first_entry <= next_entry && next_entry < after_last_entry)
- {
- if (next_entry->cstring == entry_ptr->cstring)
- return next_entry;
- }
- }
- return nullptr;
- }
-
- size_t
- GetValues (const char *unique_cstr, std::vector<T> &values) const
- {
- const size_t start_size = values.size();
-
- Entry search_entry (unique_cstr);
- const_iterator pos, end = m_map.end();
- for (pos = std::lower_bound (m_map.begin(), end, search_entry); pos != end; ++pos)
- {
- if (pos->cstring == unique_cstr)
- values.push_back (pos->value);
- else
- break;
- }
-
- return values.size() - start_size;
- }
-
- size_t
- GetValues (const RegularExpression& regex, std::vector<T> &values) const
- {
- const size_t start_size = values.size();
-
- const_iterator pos, end = m_map.end();
- for (pos = m_map.begin(); pos != end; ++pos)
- {
- if (regex.Execute(pos->cstring))
- values.push_back (pos->value);
- }
-
- return values.size() - start_size;
- }
-
- //------------------------------------------------------------------
- // Get the total number of entries in this map.
- //------------------------------------------------------------------
- size_t
- GetSize () const
- {
- return m_map.size();
- }
-
- //------------------------------------------------------------------
- // Returns true if this map is empty.
- //------------------------------------------------------------------
- bool
- IsEmpty() const
- {
- return m_map.empty();
- }
-
- //------------------------------------------------------------------
- // Reserve memory for at least "n" entries in the map. This is
- // useful to call when you know you will be adding a lot of entries
- // using UniqueCStringMap::Append() (which should be followed by a
- // call to UniqueCStringMap::Sort()) or to UniqueCStringMap::Insert().
- //------------------------------------------------------------------
- void
- Reserve (size_t n)
- {
- m_map.reserve (n);
- }
-
- //------------------------------------------------------------------
- // Sort the unsorted contents in this map. A typical code flow would
- // be:
- // size_t approximate_num_entries = ....
- // UniqueCStringMap<uint32_t> my_map;
- // my_map.Reserve (approximate_num_entries);
- // for (...)
- // {
- // my_map.Append (UniqueCStringMap::Entry(GetName(...), GetValue(...)));
- // }
- // my_map.Sort();
- //------------------------------------------------------------------
- void
- Sort ()
- {
- std::sort (m_map.begin(), m_map.end());
- }
-
- //------------------------------------------------------------------
- // Since we are using a vector to contain our items it will always
- // double its memory consumption as things are added to the vector,
- // so if you intend to keep a UniqueCStringMap around and have
- // a lot of entries in the map, you will want to call this function
- // to create a new vector and copy _only_ the exact size needed as
- // part of the finalization of the string map.
- //------------------------------------------------------------------
- void
- SizeToFit ()
- {
- if (m_map.size() < m_map.capacity())
- {
- collection temp (m_map.begin(), m_map.end());
- m_map.swap(temp);
- }
- }
-
- size_t
- Erase (const char *unique_cstr)
- {
- size_t num_removed = 0;
- Entry search_entry (unique_cstr);
- iterator end = m_map.end();
- iterator begin = m_map.begin();
- iterator lower_pos = std::lower_bound (begin, end, search_entry);
- if (lower_pos != end)
- {
- if (lower_pos->cstring == unique_cstr)
- {
- iterator upper_pos = std::upper_bound (lower_pos, end, search_entry);
- if (lower_pos == upper_pos)
- {
- m_map.erase (lower_pos);
- num_removed = 1;
- }
- else
- {
- num_removed = std::distance (lower_pos, upper_pos);
- m_map.erase (lower_pos, upper_pos);
- }
- }
+ }
+
+ size_t Erase(llvm::StringRef unique_cstr) {
+ size_t num_removed = 0;
+ Entry search_entry(unique_cstr);
+ iterator end = m_map.end();
+ iterator begin = m_map.begin();
+ iterator lower_pos = std::lower_bound(begin, end, search_entry);
+ if (lower_pos != end) {
+ if (lower_pos->cstring == unique_cstr) {
+ iterator upper_pos = std::upper_bound(lower_pos, end, search_entry);
+ if (lower_pos == upper_pos) {
+ m_map.erase(lower_pos);
+ num_removed = 1;
+ } else {
+ num_removed = std::distance(lower_pos, upper_pos);
+ m_map.erase(lower_pos, upper_pos);
}
- return num_removed;
+ }
}
+ return num_removed;
+ }
protected:
- typedef std::vector<Entry> collection;
- typedef typename collection::iterator iterator;
- typedef typename collection::const_iterator const_iterator;
- collection m_map;
+ typedef std::vector<Entry> collection;
+ typedef typename collection::iterator iterator;
+ typedef typename collection::const_iterator const_iterator;
+ collection m_map;
};
} // namespace lldb_private
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-27 02:30:25 +0000