First release of open-appsec source code

core/include/general/common.h

@@ -0,0 +1,138 @@
+// Copyright (C) 2022 Check Point Software Technologies Ltd. All rights reserved.
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef __COMMON_H__
+#define __COMMON_H__
+
+#define CP_LIKELY(cond)    __builtin_expect((bool)(cond), 1)
+#define CP_UNLIKELY(cond)  __builtin_expect((bool)(cond), 0)
+#define CP_UNUSED          __attribute__((unused))
+#define CP_NO_RETURN       __attribute__((noreturn))
+
+#if defined(__GNUC__) && __GNUC__ >= 7
+#define CP_FALL_THROUGH __attribute__ ((fallthrough))
+#else
+#define CP_FALL_THROUGH ((void)0)
+#endif //  __GNUC__ >= 7
+
+#include <memory>
+#include <string>
+#include <sstream>
+#include <iomanip>
+#include <sys/types.h>
+
+namespace std
+{
+
+#if __cplusplus < 201402L
+// make_unique isn't part of C++11 - but pretty useful, so we'll define it in such cases
+
+template<typename ConstructedType, typename... Args>
+unique_ptr<ConstructedType>
+make_unique(Args&&... args)
+{
+    return unique_ptr<ConstructedType>(new ConstructedType(forward<Args>(args)...));
+}
+
+#endif // __cplusplus < 201402L
+
+// Not part of the C++11 standard, but is useful imitation of Python's `join`
+template <typename Iterable>
+string
+makeSeparatedStr(const Iterable &data, const string &separator)
+{
+    ostringstream os;
+    bool not_first = false;
+    for (const auto &element : data) {
+        if (not_first) os << separator;
+        os << element;
+        not_first = true;
+    }
+    return os.str();
+}
+
+template <typename Char>
+string
+dumpHexChar(const Char &ch)
+{
+    ostringstream stream;
+    if (isprint(ch) && (!isspace(ch) || ch==' ')) {
+        stream << "'" << ch << "'";
+    } else {
+        stream << "\\x" << setw(2) << setfill('0') << hex << static_cast<int>(ch);
+    }
+    return stream.str();
+}
+
+// Produce a hex string from some container of charecters.
+// The container must be iterable.
+template <typename CharIterable>
+string
+dumpHex(const CharIterable &arg)
+{
+    ostringstream stream;
+    stream << hex;
+    for (uint8_t ch : arg) {
+        if (isprint(ch) && (!isspace(ch) || ch==' ')) {
+            // Printable characters, except for whitespaces which aren't space.
+            if (ch == '\\') stream << '\\';
+            stream << ch;
+        } else {
+            stream << "\\x" << setw(2) << setfill('0') << static_cast<int>(ch);
+        }
+    }
+    return stream.str();
+}
+
+template <typename CharIterable>
+string
+dumpRealHex(const CharIterable &arg)
+{
+    ostringstream stream;
+    stream << hex;
+    for (uint8_t ch : arg) {
+        stream << " " << setw(2) << setfill('0') << static_cast<int>(ch);
+    }
+    return stream.str();
+}
+
+template <typename T, typename Helper = void>
+struct IsPrintable : false_type
+{
+};
+
+template <typename T>
+struct IsPrintable<T, decltype(static_cast<void>(declval<ostream &>() << declval<T>()))> : true_type
+{
+};
+
+template <typename CanPrint>
+ostream &
+operator<<(ostream &os, const decltype(declval<CanPrint>().print(declval<ostream &>()), declval<CanPrint>()) &obj)
+{
+    obj.print(os);
+    return os;
+}
+
+template <typename First, typename Second>
+ostream&
+operator<<(ostream &os, const pair<const First, Second> &printable_pair)
+{
+    os << "{" << printable_pair.first << "," << printable_pair.second << "}";
+    return os;
+}
+
+} // namespace std
+
+#endif // __COMMON_H__
+