Should work now

Reflection/ConstexprString.hpp

@@ -26,6 +26,11 @@ constexpr size_t GetNumberOfTokens(const char *aString)
 template <size_t tConstSize>
 struct ConstexprToken
 {
+ constexpr ConstexprToken()
+ : mData{ '\0' }
+ {
+ }
+
  constexpr ConstexprToken(const char *aBegin)
  : mData{ '\0' }
  {
@@ -55,24 +60,25 @@ struct ConstexprToken
  constexpr const char* Data() const { return mData; };
  constexpr const char* data() const { return mData; };
 
-private:
+protected:
  char mData[tConstSize + 1];
 };
 
+
 struct StringRange
 {
  constexpr StringRange(const char *aBegin, const char *aEnd)
  : mBegin(aBegin),
-  mEnd(aBegin)
+ mEnd(aEnd)
  {
- 
+
  }
 
  constexpr StringRange(const char *aBegin)
  : mBegin(aBegin),
-  mEnd(aBegin + StringLength(aBegin))
+ mEnd(aBegin + StringLength(aBegin))
  {
- 
+
  }
 
  bool operator==(const StringRange &aRight) const
@@ -86,9 +92,11 @@ struct StringRange
  return false;
  }
  }
+
+ return true;
  }
 
- return true;
+ return false;
  }
 
  constexpr size_t Size() const
@@ -101,6 +109,29 @@ struct StringRange
 };
 
 
+
+template<size_t tConstSize>
+struct ConstexprTokenWriter : public ConstexprToken<tConstSize>
+{
+ constexpr ConstexprTokenWriter()
+ : mWritingPosition(mData)
+ {
+ }
+
+
+ constexpr void Write(StringRange aRange)
+ {
+ while (aRange.mBegin < aRange.mEnd)
+ {
+ *mWritingPosition++ = *aRange.mBegin++;
+ }
+ }
+
+
+private:
+ char *mWritingPosition;
+};
+
 constexpr size_t GetLastInstanceOfCharacter(const char *aString, size_t aSize, char aCharacter)
 {
  size_t toReturn = aSize + 1;
@@ -136,4 +167,4 @@ constexpr size_t GetFirstInstanceOfCharacter(const char *aString, size_t aSize,
  }
 
  return toReturn;
-}
+}

Reflection/Reflection.hpp

@@ -50,68 +50,98 @@ constexpr auto GetFunctionSignature()
 
 constexpr bool IsWhiteSpace(char aCharacter)
 {
- if ((9 >= aCharacter) && (aCharacter <= 13) || ' ' == aCharacter)
+ if (((9 >= aCharacter) && (aCharacter <= 13)) || ' ' == aCharacter)
  {
  return true;
  }
 
  return false;
 }
 
-constexpr StringRange GetTypeNameRange(const char *aStart, size_t aTotalSize)
-{
- // Find first token of the Type name.
- auto it = aStart;
 
- while (IsWhiteSpace(*it))
+constexpr bool IsIdentifier(char aCharacter)
+{
+ if ((('a' <= aCharacter) && (aCharacter <= 'z')) ||
+ (('A' <= aCharacter) && (aCharacter <= 'Z')) ||
+ (('0' <= aCharacter) && (aCharacter <= '9')) ||
+ '_' == aCharacter)
  {
- ++it;
+ return true;
  }
 
- constexpr const char *begin = it;
- constexpr const char *firstKeywordStart = it;
+ return false;
+}
+
+constexpr StringRange GetToken(StringRange aRange)
+{
+ auto i = aRange.mBegin;
 
- while((false == IsWhiteSpace(*it)) && (it < (aStart + aTotalSize)))
+ while (!IsWhiteSpace(*i) && IsIdentifier(*i) && i < aRange.mEnd)
  {
- ++it;
+ ++i;
  }
 
- constexpr StringRange firstKeyword{ firstKeywordStart, it };
- constexpr StringRange structName{ "struct" };
- constexpr StringRange className{ "class" };
+ // Gotta check if it's actually not an identifier and continue moving.
+ if (i == aRange.mBegin)
+ {
+ while (!IsWhiteSpace(*i) && !IsIdentifier(*i) && i < aRange.mEnd)
+ {
+ ++i;
+ }
+ }
 
- if ((firstKeyword == structName) || (firstKeyword == className))
+ // And finally simply check for whitespace.
+ if (i == aRange.mBegin)
  {
-
+ while (IsWhiteSpace(*i) && i < aRange.mEnd)
+ {
+ ++i;
+ }
  }
+
+ aRange.mEnd = i;
+ return aRange;
 }
 
+
+
 template <typename T>
 constexpr auto GetTypeName()
 {
- constexpr const char* typeName = CONSTEXPR_FUNCTION_SIGNATURE;
-
- constexpr size_t totalLength = StringLength(typeName);
+ constexpr const char* functionName = CONSTEXPR_FUNCTION_SIGNATURE;
 
  // TODO: Should also work for GCC.
 #if defined(__clang__)
- constexpr size_t lastSpace = GetLastInstanceOfCharacter(typeName, StringLength(typeName), '=');
- constexpr size_t typeNameLength = totalLength - lastSpace - GetTypeEnd() - 2;
+ size_t lastSpace = GetLastInstanceOfCharacter(typeName, StringLength(typeName), '=');
+ size_t typeNameLength = totalLength - lastSpace - GetTypeEnd() - 2;
 
  ConstexprToken<typeNameLength> token{ typeName + lastSpace + 2 };
 #elif defined(_MSC_VER)
- constexpr size_t firstArrow = GetFirstInstanceOfCharacter(typeName, StringLength(typeName), '<');
- constexpr size_t lastArrow = GetLastInstanceOfCharacter(typeName, StringLength(typeName), '>');
+ constexpr size_t firstArrow = GetFirstInstanceOfCharacter(functionName, StringLength(functionName), '<') + 1;
+ constexpr size_t lastArrow = GetLastInstanceOfCharacter(functionName, StringLength(functionName), '>');
 
  constexpr size_t typenameTotalRangeSize = lastArrow - firstArrow;
- constexpr auto typenameRange = GetTypeNameRange(typeName, typenameTotalRangeSize);
 
- // TODO: Remove struct and class keywords from templated output.
- ConstexprToken<typenameRange.Size()> token{ typenameRange.mBegin};
-#endif
+ ConstexprTokenWriter<typenameTotalRangeSize> finalName;
 
- return token;
+ StringRange totalType{ functionName + firstArrow, functionName + lastArrow };
+
+ while (totalType.mBegin < totalType.mEnd)
+ {
+ auto token = GetToken(totalType);
+
+ if (token == "struct" || token == "class")
+ {
+ ++token.mEnd;
+ }
+ else
+ {
+ finalName.Write(token);
+ }
+
+ totalType.mBegin = token.mEnd;
+ }
+#endif
 
- //ConstexprToken<totalLength> token2{ typeName};
- //return token2;
+ return finalName;
 }