unformat.cxx 1.2019.3

package/CMakeLists.txt

@@ -0,0 +1,39 @@
+cmake_minimum_required(VERSION 3.0)
+
+project(Unformat)
+
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+include(DownloadProject/DownloadProject.cmake)
+
+# Functional test
+download_project(PROJ                googletest
+                 GIT_REPOSITORY      https://github.com/google/googletest.git
+                 GIT_TAG             release-1.8.0
+                 ${UPDATE_DISCONNECTED_IF_AVAILABLE}
+)
+# Prevent GoogleTest from overriding our compiler/linker options
+# when building with Visual Studio
+set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+add_subdirectory(${googletest_SOURCE_DIR} ${googletest_BINARY_DIR})
+add_executable(unformat_test unformat.h unformat_test.cpp)
+target_link_libraries(unformat_test gtest gmock_main)
+
+# Benchmark
+if (CMAKE_VERSION VERSION_LESS 3.2)
+    set(UPDATE_DISCONNECTED_IF_AVAILABLE "")
+else()
+    set(UPDATE_DISCONNECTED_IF_AVAILABLE "UPDATE_DISCONNECTED 1")
+endif()
+
+download_project(PROJ                benchmark
+                 GIT_REPOSITORY      https://github.com/google/benchmark.git
+                 GIT_TAG             v1.3.0
+                 ${UPDATE_DISCONNECTED_IF_AVAILABLE}
+)
+
+set(BENCHMARK_ENABLE_TESTING OFF)
+add_subdirectory(${benchmark_SOURCE_DIR} ${benchmark_BINARY_DIR})
+add_executable(unformat_benchmark unformat.h unformat_benchmark.cpp)
+target_link_libraries(unformat_benchmark benchmark)

package/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org>

package/README.md

@@ -0,0 +1,67 @@
+**[Source available on GitHub](https://github.com/adamyaxley/Unformat)**
+
+# Unformat
+Parsing and extraction of original data from brace style "{}" formatted strings. It basically _unformats_ what you thought was formatted for good. It is developed and maintained by [Adam Yaxley](https://github.com/adamyaxley).
+
+## Installation
+
+Run:
+```bash
+$ npm i unformat.cxx
+```
+
+And then include `unformat.h` as follows:
+```cxx
+#include "node_modules/unformat.cxx/unformat.h"
+```
+
+## Quick Example
+Unformat is simple to use and works on all basic types. See the below example for extracting a `std::string` and an 'int'
+```c++
+std::string name;
+int age;
+
+unformat("Harry is 18 years old.", "{} is {} years old.", name, age);
+// name == "Harry" and age == 18
+```
+As an optimisation, if the format string is known at compile time, it can be parsed into a constant expression by making use of `ay::make_format`. In tests, this increases runtime speed by a factor of 3 or 4.
+```c++
+std::string name;
+int age;
+
+constexpr auto format = ay::make_format("{} is {} years old.");
+unformat("Harry is 18 years old.", format, name, age);
+// name == "Harry" and age == 18
+```
+
+## How do I use this library?
+Unformat is a single-file header only library so integration is easy. All you need to do is copy `unformat.h` into your project, and away you go.
+
+## Public Domain
+This software is completely open source and in the public domain. See LICENSE for details.
+
+## Contributing
+Pull requests are very welcome. You may also create Issues and I will have a look into it as soon as I can.
+
+## Speed
+Unformat is super awesome back to the future style lightning fast compared to traditional parsing methods. Below is the output from Google Benchmark on unformat_benchmark.cpp. Great Scott!
+```
+Run on (16 X 2993 MHz CPU s)
+03/13/19 18:10:57
+--------------------------------------------------------------------
+Benchmark                             Time           CPU Iterations
+--------------------------------------------------------------------
+Unformat                             72 ns         71 ns    8960000
+Unformat_ConstChar                   69 ns         70 ns    8960000
+Unformat_ConstexprMakeFormat         36 ns         35 ns   19478261
+StdStringStream                     844 ns        854 ns     896000
+StdRegex                           9975 ns      10010 ns      64000
+StdScanf                           1716 ns       1726 ns     407273
+```
+
+<br>
+<br>
+
+
+[![ORG](https://img.shields.io/badge/org-nodef-green?logo=Org)](https://nodef.github.io)
+![](https://ga-beacon.deno.dev/G-RC63DPBH3P:SH3Eq-NoQ9mwgYeHWxu7cw/github.com/nodef/unformat.cxx)

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "unformat.cxx",
+  "version": "1.2019.3",
+  "description": "Fastest type-safe parsing library in the world for C++14 or C++17 (up to 300x faster than std::regex); Adam Yaxley (2017).",
+  "keywords": ["c", "library", "parsing", "formatting", "unformat", "unformatted", "fast", "safe", "type-safe", "cpp", "c++", "cxx"],
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nodef/unformat.cxx.git"
+  },
+  "bugs": {
+    "url": "https://github.com/nodef/unformat.cxx/issues"
+  },
+  "homepage": "https://github.com/nodef/unformat.cxx#readme"
+}

package/unformat.h

@@ -0,0 +1,341 @@
+#pragma once
+
+#ifdef _MSC_VER
+#if _MSC_VER >= 1910 && _HAS_CXX17
+#define UNFORMAT_CPP17
+#endif
+#endif
+
+#include <string>
+#ifdef UNFORMAT_CPP17
+#include <string_view>
+#endif
+
+namespace
+{
+	template <typename T>
+	void unformat_signed_int(const char* input, const char* inputEnd, T& output) noexcept
+	{
+		output = 0;
+		int sign = 1;
+		if (*input == '-')
+		{
+			sign = -1;
+			++input;
+		}
+
+#ifndef UNFORMAT_DISABLE_PLUS_SIGN
+		// Ignore plus
+		if (*input == '+')
+		{
+			++input;
+		}
+#endif
+
+		while (input != inputEnd)
+		{
+			output *= 10;
+			output += (*input - '0');
+			++input;
+		}
+		output *= sign;
+	}
+
+	template <typename T>
+	void unformat_unsigned_int(const char* input, const char* inputEnd, T& output) noexcept
+	{
+		output = 0;
+		while (input != inputEnd)
+		{
+			output *= 10;
+			output += (*input - '0');
+			++input;
+		}
+	}
+
+	template <typename T>
+	void unformat_real(const char* input, const char* inputEnd, T& output) noexcept
+	{
+		long double f = 0;
+
+		// Check for negative
+		if (*input == '-')
+		{
+			f = -f;
+			++input;
+		}
+
+#ifndef UNFORMAT_DISABLE_PLUS_SIGN
+		// Ignore plus
+		if (*input == '+')
+		{
+			++input;
+		}
+#endif
+
+		// Parse units
+		while (*input != '.' && input != inputEnd && *input != 'e')
+		{
+			f *= 10;
+			f += (*input - '0');
+			++input;
+		}
+
+		// Parse decimal
+		if (*input == '.')
+		{
+			++input;
+			long double decimal = 1.0L;
+			while (input != inputEnd && *input != 'e')
+			{
+				decimal *= 0.1L;
+				f += (*input - '0') * decimal;
+				++input;
+			}
+		}
+
+		// Parse exponent
+		if (*input == 'e')
+		{
+			++input;
+			if (*input == '+')
+			{
+				++input; // Skip + as unformat_signed_int can't handle it
+			}
+			int e;
+			unformat_signed_int(input, inputEnd, e);
+			f *= pow(10L, e);
+		}
+
+		output = static_cast<T>(f);
+	}
+}
+
+namespace ay
+{
+	// Not defined on purpose for the general case. Note that you can define custom unformatters by defining new specialisations
+	// for this function.
+	template <typename T>
+	void unformat_arg(const char* input, const char* inputEnd, T& output) noexcept;
+
+	template <typename T>
+	T unformat_arg(const char* input, const char* inputEnd) noexcept
+	{
+		T output;
+		unformat_arg(input, inputEnd, output);
+		return output;
+	}
+
+#ifdef UNFORMAT_CPP17
+	template <typename T>
+	T unformat_arg(std::string_view input) noexcept
+	{
+		return unformat_arg<T>(input.data(), input.data() + input.length());
+	}
+#endif
+
+	template <typename T>
+	T unformat_arg(std::string input) noexcept
+	{
+		return unformat_arg<T>(input.c_str(), input.c_str() + input.length());
+	}
+
+	template <>
+	inline void unformat_arg<char>(const char* input, const char* inputEnd, char& output) noexcept
+	{
+		output = input[0];
+	}
+
+	template <>
+	inline void unformat_arg<unsigned char>(const char* input, const char* inputEnd, unsigned char& output) noexcept
+	{
+		output = input[0];
+	}
+
+#ifdef UNFORMAT_CPP17
+	template <>
+	inline void unformat_arg<std::string_view>(const char* input, const char* inputEnd, std::string_view& output) noexcept
+	{
+		output = std::string_view(input, inputEnd - input);
+	}
+#endif
+
+	template <>
+	inline void unformat_arg<std::string>(const char* input, const char* inputEnd, std::string& output) noexcept
+	{
+		output.assign(input, inputEnd - input);
+	}
+
+	template <>
+	inline void unformat_arg<float>(const char* input, const char* inputEnd, float& output) noexcept
+	{
+		unformat_real<float>(input, inputEnd, output);
+	}
+
+	template <>
+	inline void unformat_arg<double>(const char* input, const char* inputEnd, double& output) noexcept
+	{
+		unformat_real<double>(input, inputEnd, output);
+	}
+
+	template <>
+	inline void unformat_arg<short>(const char* input, const char* inputEnd, short& output) noexcept
+	{
+		unformat_signed_int<short>(input, inputEnd, output);
+	}
+
+	template <>
+	inline void unformat_arg<int>(const char* input, const char* inputEnd, int& output) noexcept
+	{
+		unformat_signed_int<int>(input, inputEnd, output);
+	}
+
+	template <>
+	inline void unformat_arg<long>(const char* input, const char* inputEnd, long& output) noexcept
+	{
+		unformat_signed_int<long>(input, inputEnd, output);
+	}
+
+	template <>
+	inline void unformat_arg<long long>(const char* input, const char* inputEnd, long long& output) noexcept
+	{
+		unformat_signed_int<long long>(input, inputEnd, output);
+	}
+
+	template <>
+	inline void unformat_arg<unsigned short>(const char* input, const char* inputEnd, unsigned short& output) noexcept
+	{
+		unformat_unsigned_int<unsigned short>(input, inputEnd, output);
+	}
+
+	template <>
+	inline void unformat_arg<unsigned int>(const char* input, const char* inputEnd, unsigned int& output) noexcept
+	{
+		unformat_unsigned_int<unsigned int>(input, inputEnd, output);
+	}
+
+	template <>
+	inline void unformat_arg<unsigned long>(const char* input, const char* inputEnd, unsigned long& output) noexcept
+	{
+		unformat_unsigned_int<unsigned long>(input, inputEnd, output);
+	}
+
+	template <>
+	inline void unformat_arg<unsigned long long>(const char* input, const char* inputEnd, unsigned long long& output) noexcept
+	{
+		unformat_unsigned_int<unsigned long long>(input, inputEnd, output);
+	}
+
+	struct format;
+
+	constexpr format make_format_non_template(const char* str, std::size_t N);
+
+	struct format
+	{
+		constexpr format() {}
+
+		template <std::size_t N>
+		constexpr format(const char(&str)[N])
+		{
+			*this = make_format_non_template(str, N);
+		}
+
+		format(const char* str)
+		{
+			*this = make_format_non_template(str, std::strlen(str));
+		}
+
+		static constexpr std::size_t MAX_COUNT{ 16 };
+		std::size_t offsets[MAX_COUNT]{};
+		char endChar[MAX_COUNT]{};
+		std::size_t count{ 0 };
+	};
+
+	template <std::size_t N>
+	constexpr format make_format(const char(&str)[N]) noexcept
+	{
+		return make_format_non_template(str, N);
+	}
+
+	constexpr format make_format_non_template(const char* str, std::size_t N)
+	{
+		format format;
+
+		std::size_t from = 0;
+		for (std::size_t to = 0; to < N - 1; to++)
+		{
+			if (str[to] == '{' && str[to + 1] == '}')
+			{
+				if (format.count >= format::MAX_COUNT)
+				{
+					// Stops compilation in a constexpr context
+					throw std::exception("Max number of {} has been exceeded.");
+				}
+				format.offsets[format.count] = to - from;
+				format.endChar[format.count] = str[to + 2]; // May be '\0' which is fine
+				++format.count;
+				// Advance markers
+				from = to + 2;
+				to = from;
+			}
+		}
+
+		return format;
+	}
+
+	// Empty function to end recursion, no more args to process
+	inline void unformat_internal(std::size_t inputPos, const char* input, const format& format) noexcept
+	{
+	}
+
+	template <typename T, typename... TRest>
+	void unformat_internal(std::size_t inputPos, const char* input, const format& format, T& first, TRest&... rest) noexcept
+	{
+		const std::size_t argNo = format.count - sizeof...(rest) - 1;
+
+		// Get the location of the first brace
+		const auto offset = format.offsets[argNo];
+
+		// Find input string
+		inputPos += offset;
+		auto inputEnd = inputPos;
+		while (input[inputEnd] != format.endChar[argNo])
+		{
+			++inputEnd;
+		}
+
+		// Process this arg
+		unformat_arg(&input[inputPos], &input[inputEnd], first);
+
+		// Process TRest
+		unformat_internal(inputEnd, input, format, rest...);
+	}
+
+	// Parses and extracts data from 'input' given a braced styled "{}" 'format' into 'args...'
+	// For example:
+	//     std::string name, int age;
+	//     constexpr auto format = make_format("{} is {} years old.");
+	//     unformat("Harry is 18 years old.", format, name, age);
+	//
+	// Then the following data is extracted:
+	//     name == "Harry" and age == 18
+	template <typename... Args>
+	void unformat(const char* input, const format& format, Args&... args) noexcept
+	{
+		unformat_internal(0, input, format, args...);
+	}
+
+	// Parses and extracts data from 'input' given a braced styled "{}" 'format' into 'args...'
+	// For example:
+	//     std::string name, int age;
+	//     constexpr auto format = make_format("{} is {} years old.");
+	//     unformat("Harry is 18 years old.", format, name, age);
+	//
+	// Then the following data is extracted:
+	//     name == "Harry" and age == 18
+	template <typename... Args>
+	void unformat(const std::string& input, const format& format, Args&... args) noexcept
+	{
+		unformat_internal(0, input.c_str(), format, args...);
+	}
+}