First commit

Author: Manu343726

.gitignore

@@ -0,0 +1,8 @@
+/build/
+*.idea
+CMakeLists.txt
+*.vcxproj*
+Debug/
+Release/
+*.exe
+*.s

LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2015 Manuel Sánchez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.md

@@ -0,0 +1,45 @@
+# CTTI
+
+Compile Time Type Information for the C++ programming language.
+
+## Background
+
+We know C++ is a statically typed compiled language, but it's disappointing that we cannot even get
+the name of a C++ type at compile time, having to use RTTI (Run Time Type Information) which introduces
+a lot of overhead. In fact, that's one of the most feared features of C++, usually disabled in performance dependent
+scenarios such as videogames programming. 
+
+This library aims to provide features similar to RTTI `std::type_info` at compile-time, currently `constexpr` type name and 
+a `constexpr` replacement of `std::type_index` for indexing maps with types.
+
+``` cpp
+#include "ctti/type_id.hpp"
+
+int main()
+{
+    static_assert(ctti::type_id<int>() != ctti::type_id("hello"), "compile-time type-id comparison");
+    
+    std::unordered_map<ctti::type_id_t, std::size_t> sizeof_map;
+    
+    sizeof_map[ctti::type_id<int>()] = sizeof(int);
+}
+```
+
+## Support and current status
+
+This was tested on both GCC 5.2.0 and Clang 3.6.2. It's fairly unstable (I'm currently working on it), and it leads 
+to ugly ICEs whenever the `constexpr` machinery fails. 
+
+### Current state: Bugs...
+
+`ctti::type_id` comparison and hashing works correctly, but I'm trying to find a bug that 
+causes `type_ide::name()` to return empty or even corrupted strings. I'm sure there's something wrong with the
+`ctti::detail::string::substr()` function. I'm on it :)
+
+## Acknowledgments 
+
+Thanks a lot to Jonathan "foonathan" Müller, both for the `constexpr` hash and the idea for the `__PRETTY_FUNCTION__` trick.
+
+## License
+
+This project is licensed under the MIT license. See LICENSE.md for more details.

ctti/ctti

@@ -0,0 +1,25 @@
+#ifndef CTTI_DETAIL_HASH_HPP
+#define CTTI_DETAIL_HASH_HPP
+
+#include <cstdint>
+
+namespace ctti
+{
+    namespace detail
+    {
+        // From https://github.com/foonathan/string_id. As usually, thanks Jonathan.
+
+        using hash_t = std::uint64_t;
+
+        constexpr hash_t fnv_basis = 14695981039346656037ull;
+        constexpr hash_t fnv_prime = 109951162821ull;
+
+        // FNV-1a 64 bit hash
+        constexpr hash_t sid_hash(std::size_t n, const char *str, hash_t hash = fnv_basis)
+        {
+            return n > 0 ? sid_hash(n - 1, str + 1, (hash ^ *str) * fnv_prime) : hash;
+        }
+    }
+}
+
+#endif /* CTTI_DETAIL_HASH_HPP */

ctti/detail/hash.hpp

@@ -0,0 +1,22 @@
+//
+// Created by manu343726 on 4/08/15.
+//
+
+#ifndef CTTI_PRETTY_FUNCTION_HPP
+#define CTTI_PRETTY_FUNCTION_HPP
+
+#if defined(__clang__)
+    #define CTTI_PRETTY_FUNCTION __PRETTY_FUNCTION__
+    #define CTTI_PRETTY_FUNCTION_PREFIX "ctti::type_id_t ctti::detail::type_id() [T = "
+    #define CTTI_PRETTY_FUNCTION_SUFFIX "]"
+#elif defined(__GNUC__) && !defined(__clang__)
+    #define CTTI_PRETTY_FUNCTION __PRETTY_FUNCTION__
+    #define CTTI_PRETTY_FUNCTION_PREFIX "ctti::type_id_t ctti::detail::type_id() [T = "
+    #define CTTI_PRETTY_FUNCTION_SUFFIX "]"
+#endif
+
+#define CTTI_PRETTY_FUNCTION_BEGIN (sizeof(CTTI_PRETTY_FUNCTION_PREFIX) - 1)
+#define CTTI_PRETTY_FUNCTION_END (sizeof(CTTI_PRETTY_FUNCTION) - 1 - sizeof(CTTI_PRETTY_FUNCTION_SUFFIX) - 1)
+#define CTTI_PRETTY_FUNCTION_LENGTH (CTTI_PRETTY_FUNCTION_END - CTTI_PRETTY_FUNCTION_BEGIN)
+
+#endif //CTTI_PRETTY_FUNCTION_HPP

ctti/detail/pretty_function.hpp

@@ -0,0 +1,79 @@
+//
+// Created by manu343726 on 4/08/15.
+//
+
+#ifndef CTTI_STRING_HPP
+#define CTTI_STRING_HPP
+
+#include <ostream>
+
+namespace ctti
+{
+    namespace detail
+    {
+        struct string
+        {
+            template<std::size_t N>
+            constexpr string(const char (&str)[N]) :
+                string{str, N}
+            {}
+
+            constexpr string(const char* str, std::size_t length) :
+                str_{str},
+                length_{length},
+                hash_{sid_hash(length, str)}
+            {}
+
+            constexpr hash_t hash() const
+            {
+                return hash_;
+            }
+
+            constexpr const char* c_str() const
+            {
+                return str_;
+            }
+
+            constexpr std::size_t length() const
+            {
+                return length_;
+            }
+
+            constexpr char operator[](std::size_t i) const
+            {
+                return str_[i];
+            }
+
+            template<std::size_t Begin, std::size_t End>
+            constexpr string substr() const
+            {
+                return substr_<Begin>(std::make_index_sequence<End - Begin>{});
+            }
+
+            friend std::ostream& operator<<(std::ostream& os, const string& str)
+            {
+                return os << str.c_str();
+            }
+
+        private:
+            template<std::size_t Begin, std::size_t... Is>
+            constexpr string substr_(std::index_sequence<Is...>) const
+            {
+                const char str[] = {str_[Begin + Is]...};
+                return { str };
+            }
+
+            const char* str_;
+            std::size_t length_;
+            hash_t hash_;
+        };
+
+        template<std::size_t N>
+        constexpr string make_string(const char (&str)[N])
+        {
+            return {str};
+        }
+    }
+}
+
+#endif //CTTI_STRING_HPP

ctti/detail/string.hpp

@@ -0,0 +1,27 @@
+//
+// Created by manu343726 on 4/08/15.
+//
+
+#include "type_id.hpp"
+#include <unordered_map>
+#include <iostream>
+
+int main()
+{
+    std::unordered_map<ctti::type_id_t, int> map;
+    std::string name = ctti::type_id("hello").name().c_str();
+
+    map[ctti::type_id(1)]   = 1;
+    map[ctti::type_id(1u)]  = 2;
+    map[ctti::type_id(1ul)] = 3;
+
+    static_assert(ctti::type_id<int>() == ctti::type_id(1), "???");
+    static_assert(ctti::type_id<int>() != ctti::type_id<int*>(), "???");
+
+    std::cout << map[ctti::type_id<int>()] << std::endl;
+    std::cout << map[ctti::type_id<char>()] << std::endl;
+    std::cout << map[ctti::type_id<unsigned long int>()] << std::endl;
+    std::cout << ctti::type_id<int>().name() << std::endl;
+
+    std::cin.get();
+}

ctti/main.cpp

@@ -0,0 +1,111 @@
+//
+// Created by manu343726 on 4/08/15.
+//
+
+#ifndef CTTI_HASH_HPP
+#define CTTI_HASH_HPP
+
+#include <functional>
+#include "detail/hash.hpp"
+#include "detail/pretty_function.hpp"
+#include "detail/string.hpp"
+
+namespace ctti
+{
+    struct type_id_t
+    {
+        constexpr type_id_t(const detail::string& name) :
+            name_{name}
+        {}
+
+        constexpr detail::hash_t hash() const
+        {
+            return name_.hash();
+        }
+
+        constexpr detail::string name() const
+        {
+            return name_;
+        }
+
+        friend constexpr bool operator==(const type_id_t& lhs, const type_id_t& rhs)
+        {
+            return lhs.hash() == rhs.hash();
+        }
+
+        friend constexpr bool operator!=(const type_id_t& lhs, const type_id_t& rhs)
+        {
+            return !(lhs == rhs);
+        }
+
+    private:
+        detail::string name_;
+    };
+
+    namespace detail
+    {
+        template<char... Chars>
+        struct ct_string
+        {
+            static constexpr const char value[] = {Chars..., '\0'};
+        };
+
+        template<char... Chars>
+        constexpr const char ct_string<Chars...>::value[];
+
+        // The trick is to be able to discard both the preffix and suffix of
+        // __PRETTY_FUNCTION__ string, getting T name only.
+        // This is done in two steps:
+        //
+        //  - type_id() function bellow gets T name length through CTTI_PRETTY_PRINT_LENGTH macro.
+        //  - Then __PRETTY_FUNCTION__ is computed again, using it to fill a variadic char string
+        //    template which will hold the T name.
+        template<typename T, std::size_t... Is, std::size_t N>
+        constexpr const char* parse_name(const char (&pretty_function)[N], std::index_sequence<Is...>)
+        {
+            constexpr std::size_t fn_length = 4 + sizeof("const char* parse_name(const char (&pretty_function)[N], std::index_sequence<Is...>)");
+            using str = ct_string<CTTI_PRETTY_FUNCTION[fn_length + Is]...>;
+
+            return str::value;
+        }
+
+        // Since _() is a template, __PRETTY_FUNCTION__ string varies with template parameter,
+        // pretty function is usually something like "hash_t _<T>() [with T = *type here*]".
+        template<typename T>
+        constexpr ctti::type_id_t type_id()
+        {
+            const auto str = detail::make_string(CTTI_PRETTY_FUNCTION);
+            const auto name = str.template substr<CTTI_PRETTY_FUNCTION_BEGIN, CTTI_PRETTY_FUNCTION_END>();
+
+            return {name};
+        }
+    }
+
+    template<typename T>
+    constexpr type_id_t type_id(T&&)
+    {
+        return detail::type_id<typename std::decay<T>::type>();
+    }
+
+    template<typename T>
+    constexpr type_id_t type_id()
+    {
+        return detail::type_id<typename std::decay<T>::type>();
+    }
+
+    //static_assert(type_id<void>() == type_id<void>(), "ctti::type_id_t instances must be constant expressions");
+}
+
+namespace std
+{
+    template<>
+    struct hash<ctti::type_id_t>
+    {
+        std::size_t operator()(const ctti::type_id_t& id) const
+        {
+            return id.hash();
+        }
+    };
+}
+
+#endif //CTTI_HASH_HPP