Skip to main content
aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to 'runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/String.h')
-rw-r--r--runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/String.h318
1 files changed, 318 insertions, 0 deletions
diff --git a/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/String.h b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/String.h
new file mode 100644
index 000000000..70ac624b8
--- /dev/null
+++ b/runtime/org.eclipse.etrice.runtime.cpp/src/common/containers/String.h
@@ -0,0 +1,318 @@
+/*******************************************************************************
+ * Copyright (c) 2017 protos software gmbh (http://www.protos.de).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * CONTRIBUTORS:
+ * Henrik Rentz-Reichert (initial contribution)
+ *
+ *******************************************************************************/
+
+#ifndef STRING_H_
+#define STRING_H_
+
+#include <cstddef>
+#include <cstring>
+
+namespace etRuntime {
+
+/**
+ * a static size string class that basically encapsulates a C string
+ */
+class String {
+public:
+ /**
+ * default constructor is empty string
+ */
+ String();
+
+ /**
+ * copy constructor calls operator=(const char *rhs)
+ */
+ String(const String &rhs)
+ : _size(0)
+ , _data(0)
+ {
+ ++ncreated;
+ operator=(rhs._data);
+ }
+
+ /**
+ * constructor calls operator=(const char *rhs)
+ */
+ String(const char *rhs)
+ : _size(0)
+ , _data(0)
+ {
+ ++ncreated;
+ operator=(rhs);
+ }
+
+ /**
+ * virtual destructor
+ */
+ virtual ~String(void);
+
+
+ /**
+ * returns the length of the C string stored
+ */
+ size_t length(void) const
+ {
+ return std::strlen(this->_data);
+ }
+
+ /**
+ * returns a const char * pointer to the data of this array
+ */
+ const char* c_str(void) const
+ {
+ return this->_data;
+ }
+
+ /**
+ * returns the character at the given position. If index is out of range 0 is returned
+ */
+ char operator[](int index) const {
+ return (index < 0 || index >= (int)_size) ? 0 : _data[index];
+ }
+
+ /**
+ * forwards to operator=(const char *rhs)
+ */
+ String& operator=(const String &rhs)
+ {
+ return operator=(rhs._data);
+ }
+
+ /**
+ * creates a copy of the rhs
+ */
+ String& operator=(const char *rhs);
+
+ //
+ // string concatenation
+ //
+
+ /*
+ * concatenates the rhs to the end of the string.
+ */
+ const String operator+=(const String& rhs) {
+ return operator+=(rhs._data);
+ }
+
+ /*
+ * concatenates the rhs to the end of the string.
+ */
+ const String operator+=(const char* rhs);
+
+ /*
+ * concatenates the c to the end of the string.
+ */
+ const String operator+=(char c);
+
+ //
+ // comparison
+ //
+
+ /**
+ * compares two strings
+ */
+ int compare(const String& rhs) const {
+ return std::strcmp(this->_data, rhs._data);
+ }
+ int compareXX(const String& rhs) const {
+ return std::strcmp(this->_data, rhs._data);
+ }
+//
+// /**
+// * compares a string with a C-String
+// */
+// int compare(const char *rhs) const {
+// return strcmp(this->_data, rhs);
+// }
+
+ //
+ // find
+ //
+ static const size_t npos = -1;
+
+ size_t find(const String& str, size_t pos = 0) const;
+ size_t find(const char* str, size_t pos = 0) const;
+ size_t find(char c, size_t pos = 0) const;
+
+ size_t rfind(const String& str) const;
+ size_t rfind(const char* str) const;
+ size_t rfind(char c) const;
+
+ //
+ // sub strings
+ //
+ String substr(size_t pos = 0, size_t len = npos) const;
+
+ static size_t getNAllocations() { return nallocs; }
+ static size_t getNDeallocations() { return ndeallocs; }
+ static size_t getNCreated() { return ncreated; }
+ static size_t getNDestroyed() { return ndestroyed; }
+
+private:
+ static size_t nallocs;
+ static size_t ndeallocs;
+ static size_t ncreated;
+ static size_t ndestroyed;
+
+ size_t _size;
+ char* _data;
+};
+
+//
+// string concatenation
+//
+
+/**
+ * concatenates lhs and rhs.
+ */
+inline const String operator+(const String &lhs, const String &rhs) {
+ // make a copy and add
+ return String(lhs) += rhs;
+}
+
+/**
+ * concatenates lhs and rhs.
+ */
+inline const String operator+(const String &lhs, const char* rhs) {
+ // make a copy and add
+ return String(lhs) += rhs;
+}
+
+/**
+ * concatenates lhs and c
+ */
+inline const String operator+(const String &lhs, char c) {
+ // make a copy and add
+ String result(lhs);
+ result += c;
+ return result;
+}
+
+/**
+ * concatenates lhs and rhs.
+ */
+inline const String operator+(const char* lhs, const String& rhs) {
+ // create a string and add
+ String result(lhs);
+ result += rhs;
+ return result;
+}
+
+/**
+ * concatenates c and rhs.
+ */
+inline const String operator+(char c, const String& rhs) {
+ // create a string and add
+ String result("");
+ result += c;
+ result += rhs;
+ return result;
+}
+
+//
+// string comparison
+//
+
+/**
+ * compares two strings
+ */
+inline bool operator==(const String& lhs, const String &rhs) {
+ return lhs.compare(rhs)==0;
+}
+
+/**
+ * compares a string with a C-string
+ */
+inline bool operator==(const String& lhs, const char *rhs) {
+ return lhs.compare(rhs)==0;
+}
+
+/**
+ * compares a C-string with a string
+ */
+inline bool operator==(const char* lhs, const String& rhs) {
+ return rhs.compare(lhs)==0;
+}
+
+/**
+ * compares two strings
+ */
+inline bool operator!=(const String &lhs, const String &rhs) {
+ return !(lhs == rhs);
+}
+
+/**
+ * compares a string and a C-string
+ */
+inline bool operator!=(const String &lhs, const char *rhs) {
+ return !(lhs == rhs);
+}
+
+/**
+ * compares a C-string and a string
+ */
+inline bool operator!=(const char* lhs, const String& rhs) {
+ return !(lhs == rhs);
+}
+
+inline bool operator<(const String &lhs, const String& rhs) {
+ return lhs.compare(rhs) < 0;
+}
+
+inline bool operator<(const String &lhs, const char* rhs) {
+ return lhs.compare(rhs) < 0;
+}
+
+inline bool operator<(const char* lhs, const String& rhs) {
+ return rhs.compare(lhs) > 0;
+}
+
+inline bool operator<=(const String &lhs, const String& rhs) {
+ return lhs.compare(rhs) <= 0;
+}
+
+inline bool operator<=(const String &lhs, const char* rhs) {
+ return lhs.compare(rhs) <= 0;
+}
+
+inline bool operator<=(const char* lhs, const String& rhs) {
+ return rhs.compare(lhs) >= 0;
+}
+
+inline bool operator>(const String &lhs, const String& rhs) {
+ return lhs.compare(rhs) > 0;
+}
+
+inline bool operator>(const String &lhs, const char* rhs) {
+ return lhs.compare(rhs) > 0;
+}
+
+inline bool operator>(const char* lhs, const String& rhs) {
+ return rhs.compare(lhs) < 0;
+}
+
+inline bool operator>=(const String &lhs, const String& rhs) {
+ return lhs.compare(rhs) >= 0;
+}
+
+inline bool operator>=(const String &lhs, const char* rhs) {
+ return lhs.compare(rhs) >= 0;
+}
+
+inline bool operator>=(const char* lhs, const String& rhs) {
+ return rhs.compare(lhs) <= 0;
+}
+
+} /* namespace etRuntime */
+
+#endif /* STRING_H_ */
+

Back to the top