Made calltracing configurable

[casparcg] / common / enum_class.h

diff --git a/common/enum_class.h b/common/enum_class.h
index c1cec94d5dba1aacbe5a3775e5ce5f034de74559..54336823bfd4de3d8b968745d58a4a5532f1ce79 100644 (file)
--- a/common/enum_class.h
+++ b/common/enum_class.h
@@ -1,63 +1,68 @@
-#pragma once
-
-#include <type_traits>
-
-#include <boost/range/irange.hpp>
-
-#include "linq.h"
-
-// Macro that defines & and &= for an enum class. Add more when needed.
-
-#define ENUM_ENABLE_BITWISE(enum_class) \
-       static enum_class operator&(enum_class lhs, enum_class rhs) \
-       { \
-               return static_cast<enum_class>( \
-                               static_cast<std::underlying_type<enum_class>::type>(lhs) \
-                                       & static_cast<std::underlying_type<enum_class>::type>(rhs)); \
-       }; \
-       static enum_class& operator&=(enum_class& lhs, enum_class rhs) \
-       { \
-               lhs = lhs & rhs; \
-               return lhs; \
-       }; \
+#pragma once\r
+\r
+#include <type_traits>\r
+\r
+#include <boost/range/irange.hpp>\r
+\r
+#include "linq.h"\r
+\r
+// Macro that defines & and &= for an enum class. Add more when needed.\r
+\r
+#define ENUM_ENABLE_BITWISE(enum_class) \\r
+       static enum_class operator&(enum_class lhs, enum_class rhs) \\r
+       { \\r
+               return static_cast<enum_class>( \\r
+                               static_cast<std::underlying_type<enum_class>::type>(lhs) \\r
+                                       & static_cast<std::underlying_type<enum_class>::type>(rhs)); \\r
+       }; \\r
+       static enum_class& operator&=(enum_class& lhs, enum_class rhs) \\r
+       { \\r
+               lhs = lhs & rhs; \\r
+               return lhs; \\r
+       }; \\r
        static enum_class operator | (enum_class lhs, enum_class rhs) \\r
        { \\r
                return static_cast<enum_class>( \\r
                                static_cast<std::underlying_type<enum_class>::type>(lhs) \\r
                                        | static_cast<std::underlying_type<enum_class>::type>(rhs)); \\r
        }; \\r
-       static enum_class& operator|=(enum_class& lhs, enum_class rhs) \
-       { \
-               lhs = lhs | rhs; \
-               return lhs; \
-       }; \
+       static enum_class& operator|=(enum_class& lhs, enum_class rhs) \\r
+       { \\r
+               lhs = lhs | rhs; \\r
+               return lhs; \\r
+       }; \\r
        static enum_class operator ^ (enum_class lhs, enum_class rhs) \\r
        { \\r
                return static_cast<enum_class>( \\r
                                static_cast<std::underlying_type<enum_class>::type>(lhs) \\r
                                        ^ static_cast<std::underlying_type<enum_class>::type>(rhs)); \\r
        }; \\r
-       static enum_class& operator^=(enum_class& lhs, enum_class rhs) \
-       { \
-               lhs = lhs ^ rhs; \
-               return lhs; \
-       };
-
-namespace caspar {
-
-// For enum classes starting at 0 and without any gaps with a terminating count constant.
-template <typename E>
-const std::vector<E>& enum_constants()
-{
-       typedef typename std::underlying_type<E>::type integer;
-
-       static const auto ints = boost::irange(static_cast<integer>(0), static_cast<integer>(E::count));
-       static const auto result = cpplinq::from(ints.begin(), ints.end())
-               //.cast<E>()
-               .select([](int i) { return static_cast<E>(i); })
-               .to_vector();
-
-       return result;
-}
-
-}
+       static enum_class& operator^=(enum_class& lhs, enum_class rhs) \\r
+       { \\r
+               lhs = lhs ^ rhs; \\r
+               return lhs; \\r
+       }; \\r
+       static enum_class operator~ (enum_class e) \\r
+       { \\r
+               return static_cast<enum_class>( \\r
+                               ~static_cast<std::underlying_type<enum_class>::type>(e)); \\r
+       };\r
+\r
+namespace caspar {\r
+\r
+// For enum classes starting at 0 and without any gaps with a terminating count constant.\r
+template <typename E>\r
+const std::vector<E>& enum_constants()\r
+{\r
+       typedef typename std::underlying_type<E>::type integer;\r
+\r
+       static const auto ints = boost::irange(static_cast<integer>(0), static_cast<integer>(E::count));\r
+       static const auto result = cpplinq::from(ints.begin(), ints.end())\r
+               //.cast<E>()\r
+               .select([](int i) { return static_cast<E>(i); })\r
+               .to_vector();\r
+\r
+       return result;\r
+}\r
+\r
+}\r