summaryrefslogtreecommitdiffstatshomepage
path: root/src/lib/netlist/plib/pstrutil.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib/netlist/plib/pstrutil.h')
-rw-r--r--src/lib/netlist/plib/pstrutil.h358
1 files changed, 358 insertions, 0 deletions
diff --git a/src/lib/netlist/plib/pstrutil.h b/src/lib/netlist/plib/pstrutil.h
new file mode 100644
index 00000000000..e88469a438c
--- /dev/null
+++ b/src/lib/netlist/plib/pstrutil.h
@@ -0,0 +1,358 @@
+// license:BSD-3-Clause
+// copyright-holders:Couriersud
+
+#ifndef PSTRUTIL_H_
+#define PSTRUTIL_H_
+
+///
+/// \file pstrutil.h
+///
+
+#include "pgsl.h"
+#include "pstring.h"
+#include "ptypes.h"
+
+#include <algorithm>
+#include <exception>
+#include <iterator>
+#include <limits>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace plib
+{
+ template<typename T>
+ pstring to_string(const T &v)
+ {
+ return pstring(putf8string(std::to_string(v)));
+ }
+
+ template<typename T>
+ pwstring to_wstring(const T &v)
+ {
+ return pwstring(std::to_wstring(v));
+ }
+
+ template<typename T>
+ typename T::size_type find_first_not_of(const T &str, const T &no)
+ {
+ typename T::size_type pos = 0;
+ for (auto it = str.begin(); it != str.end(); ++it, ++pos)
+ {
+ bool f = true;
+ for (typename T::value_type const jt : no)
+ {
+ if (*it == jt)
+ {
+ f = false;
+ break;
+ }
+ }
+ if (f)
+ return pos;
+ }
+ return T::npos;
+ }
+
+ template<typename T>
+ typename T::size_type find_last_not_of(const T &str, const T &no)
+ {
+ // FIXME: use reverse iterator
+ typename T::size_type last_found = T::npos;
+ typename T::size_type pos = 0;
+ for (auto it = str.begin(); it != str.end(); ++it, ++pos)
+ {
+ bool f = true;
+ for (typename T::value_type const jt : no)
+ {
+ if (*it == jt)
+ {
+ f = false;
+ break;
+ }
+ }
+ if (f)
+ last_found = pos;
+ }
+ return last_found;
+ }
+
+ template<typename T>
+ typename T::size_type find_last_of(const T &str, const T &no)
+ {
+ typename T::size_type last_found = T::npos;
+ typename T::size_type pos = 0;
+ for (auto it = str.begin(); it != str.end(); ++it, ++pos)
+ {
+ bool f = false;
+ for (typename T::value_type const jt : no)
+ {
+ if (*it == jt)
+ {
+ f = true;
+ break;
+ }
+ }
+ if (f)
+ last_found = pos;
+ }
+ return last_found;
+ }
+
+ template<typename T>
+ T ltrim(const T &str, const T &ws = T(" \t\n\r"))
+ {
+ auto f = find_first_not_of(str, ws);
+ return (f == T::npos) ? T() : str.substr(f);
+ }
+
+ template<typename T>
+ T rtrim(const T &str, const T &ws = T(" \t\n\r"))
+ {
+ auto f = find_last_not_of(str, ws);
+ return (f == T::npos) ? T() : str.substr(0, f + 1);
+ }
+
+ template<typename T>
+ T trim(const T &str, const T &ws = T(" \t\n\r"))
+ {
+ return rtrim(ltrim(str, ws), ws);
+ }
+
+ template<typename T>
+ T left(const T &str, typename T::size_type len)
+ {
+ return str.substr(0, len);
+ }
+
+ template<typename T>
+ T right(const T &str, typename T::size_type nlen)
+ {
+ return nlen >= str.length() ? str : str.substr(str.length() - nlen, nlen);
+ }
+
+ template<typename T>
+ bool startsWith(const T &str, const T &arg)
+ {
+ return (arg == left(str, arg.length()));
+ }
+
+ template<typename T>
+ bool endsWith(const T &str, const T &arg)
+ {
+ return (right(str, arg.length()) == arg);
+ }
+
+ template<typename T, typename TA>
+ bool startsWith(const T &str, const TA &arg)
+ {
+ return startsWith(str, static_cast<T>(arg));
+ }
+
+ template<typename T, typename TA>
+ bool endsWith(const T &str, const TA &arg)
+ {
+ return endsWith(str, static_cast<T>(arg));
+ }
+
+ template<typename T>
+ std::size_t strlen(const T *str)
+ {
+ const T *p = str;
+ while (*p != 0)
+ p++;
+ return narrow_cast<std::size_t>(p - str);
+ }
+
+ template<typename T>
+ T ucase(const T &str)
+ {
+ T ret;
+ for (const auto &c : str)
+ if (c >= 'a' && c <= 'z')
+ ret += (c - 'a' + 'A');
+ else
+ ret += c;
+ return ret;
+ }
+
+ template<typename T>
+ T lcase(const T &str)
+ {
+ T ret;
+ for (const auto &c : str)
+ if (c >= 'A' && c <= 'Z')
+ ret += (c - 'A' + 'a');
+ else
+ ret += c;
+ return ret;
+ }
+
+ template<typename T>
+ T rpad(const T &str, const T &ws, const typename T::size_type cnt)
+ {
+ // FIXME: pstringbuffer ret(*this);
+
+ T ret(str);
+ typename T::size_type wsl = ws.length();
+ for (auto i = ret.length(); i < cnt; i+=wsl)
+ ret += ws;
+ return ret;
+ }
+
+ template<typename T>
+ T replace_all(const T &str, typename T::value_type search, typename T::value_type replace)
+ {
+ T ret;
+ for (auto &c : str)
+ ret += (c == search) ? replace : c;
+ return ret;
+ }
+
+ template<typename T>
+ T replace_all(const T &str, const T &search, const T &replace)
+ {
+ T ret;
+ const typename T::size_type slen = search.length();
+
+ typename T::size_type last_s = 0;
+ typename T::size_type s = str.find(search, last_s);
+ while (s != T::npos)
+ {
+ ret += str.substr(last_s, s - last_s);
+ ret += replace;
+ last_s = s + slen;
+ s = str.find(search, last_s);
+ }
+ ret += str.substr(last_s);
+ return ret;
+ }
+
+ template<typename T, typename T1, typename T2>
+ std::enable_if_t<!std::is_integral<T1>::value, T>
+ replace_all(const T &str, const T1 &search, const T2 &replace)
+ {
+ return replace_all(str, static_cast<T>(search), static_cast<T>(replace));
+ }
+
+ template <typename T>
+ std::vector<T> psplit(const T &str, const T &onstr, bool ignore_empty = false)
+ {
+ std::vector<T> ret;
+
+ auto p = str.begin();
+ auto pn = std::search(p, str.end(), onstr.begin(), onstr.end());
+ const auto ol = static_cast<typename T::difference_type>(onstr.length());
+
+ while (pn != str.end())
+ {
+ if (!ignore_empty || p != pn)
+ ret.emplace_back(p, pn);
+ p = std::next(pn, ol);
+ pn = std::search(p, str.end(), onstr.begin(), onstr.end());
+ }
+ if (p != str.end())
+ {
+ ret.emplace_back(p, str.end());
+ }
+ return ret;
+ }
+
+ template <typename T>
+ std::vector<T> psplit(const T &str, const typename T::value_type &onstr, bool ignore_empty = false)
+ {
+ std::vector<T> ret;
+
+ auto p = str.begin();
+ auto pn = std::find(p, str.end(), onstr);
+
+ while (pn != str.end())
+ {
+ if (!ignore_empty || p != pn)
+ ret.emplace_back(p, pn);
+ p = std::next(pn, 1);
+ pn = std::find(p, str.end(), onstr);
+ }
+ if (p != str.end())
+ {
+ ret.emplace_back(p, str.end());
+ }
+ return ret;
+ }
+
+ template <typename T>
+ std::vector<T> psplit_r(const T &stri,
+ const T &token,
+ const std::size_t max_split)
+ {
+ T str(stri);
+ std::vector<T> result;
+ std::size_t splits = 0;
+
+ while(!str.empty())
+ {
+ std::size_t index = str.rfind(token);
+ bool found = index!=T::npos;
+ if (found)
+ splits++;
+ if ((splits <= max_split || max_split == 0) && found)
+ {
+ result.push_back(str.substr(index+token.size()));
+ str = str.substr(0, index);
+ if (str.empty())
+ result.push_back(str);
+ }
+ else
+ {
+ result.push_back(str);
+ str.clear();
+ }
+ }
+ return result;
+ }
+
+ template <typename T>
+ std::vector<T> psplit(const T &str, const std::vector<T> &onstrl)
+ {
+ T col = "";
+ std::vector<T> ret;
+
+ auto i = str.begin();
+ while (i != str.end())
+ {
+ auto p = T::npos;
+ for (std::size_t j=0; j < onstrl.size(); j++)
+ {
+ if (std::equal(onstrl[j].begin(), onstrl[j].end(), i))
+ {
+ p = j;
+ break;
+ }
+ }
+ if (p != T::npos)
+ {
+ if (!col.empty())
+ ret.push_back(col);
+
+ col.clear();
+ ret.push_back(onstrl[p]);
+ i = std::next(i, narrow_cast<typename T::difference_type>(onstrl[p].length()));
+ }
+ else
+ {
+ typename T::value_type c = *i;
+ col += c;
+ i++;
+ }
+ }
+ if (!col.empty())
+ ret.push_back(col);
+
+ return ret;
+ }
+
+} // namespace plib
+
+#endif // PSTRUTIL_H_