Change CSV escape to replace at runtime

Move Grammar.inc to CsvGrammar.hpp

4 files changed, 371 insertions, 243 deletions

diff --git a/src/openvic-dataloader/csv/CsvGrammar.hpp b/src/openvic-dataloader/csv/CsvGrammar.hpp
index bfae8d0..69557da 100644
--- a/src/openvic-dataloader/csv/CsvGrammar.hpp
+++ b/src/openvic-dataloader/csv/CsvGrammar.hpp
@@ -1,41 +1,322 @@
 #pragma once
 
+#include <algorithm>
+#include <cstddef>
 #include <initializer_list>
-#include <memory>
 #include <string>
 #include <string_view>
-#include <tuple>
 #include <type_traits>
+#include <variant>
 #include <vector>
 
 #include <openvic-dataloader/csv/LineObject.hpp>
-#include <openvic-dataloader/csv/Parser.hpp>
 
 #include <lexy/callback.hpp>
 #include <lexy/dsl.hpp>
+#include <lexy/lexeme.hpp>
 
-#include <fmt/format.h>
+#include "openvic-dataloader/csv/ValueNode.hpp"
 
 #include "detail/LexyLitRange.hpp"
 
+namespace ovdl::csv::grammar {
+	template<typename T>
+	concept ParseChars = requires() {
+		{ T::character };
+		{ T::control };
+		{ T::xid_start_underscore };
+		{ T::xid_continue };
+	};
+
+	template<ParseChars T>
+	struct ParseOptions {
+		/// @brief Seperator character
+		char SepChar;
+		/// @brief Determines whether StringValue is supported
+		bool SupportStrings;
+		/// @brief Paradox-style localization escape characters
+		/// @note Is ignored if SupportStrings is true
+		char EscapeChar;
+
+		static constexpr auto parse_chars = T {};
+	};
+
+	constexpr auto escaped_symbols = lexy::symbol_table<char> //
+										 .map<'"'>('"')
+										 .map<'\''>('\'')
+										 .map<'\\'>('\\')
+										 .map<'/'>('/')
+										 .map<'b'>('\b')
+										 .map<'f'>('\f')
+										 .map<'n'>('\n')
+										 .map<'r'>('\r')
+										 .map<'t'>('\t');
+
+	constexpr auto escaped_quote = lexy::symbol_table<char> //
+									   .map<'"'>('"');
+
+	template<ParseOptions Options>
+	struct StringValue {
+		static constexpr auto rule = [] {
+			// Arbitrary code points
+			auto c = Options.parse_chars.character - Options.parse_chars.control;
+
+			auto back_escape = lexy::dsl::backslash_escape //
+								   .symbol<escaped_symbols>();
+
+			auto quote_escape = lexy::dsl::escape(lexy::dsl::lit_c<'"'>) //
+									.template symbol<escaped_quote>();
+
+			auto quotes = lexy::dsl::delimited(lexy::dsl::lit_c<'"'>, lexy::dsl::not_followed_by(lexy::dsl::lit_c<'"'>, lexy::dsl::lit_c<'"'>));
+
+			return quotes(c, back_escape, quote_escape);
+		}();
+
+		static constexpr auto value =
+			lexy::as_string<std::string> >>
+			lexy::callback<ovdl::csv::ValueNode>(
+				[](auto&& string) {
+					return ovdl::csv::ValueNode(LEXY_MOV(string));
+				});
+		;
+	};
+
+	template<ParseOptions Options>
+	struct EscapeValue {
+		static constexpr auto rule = [] {
+			auto id = lexy::dsl::identifier(Options.parse_chars.xid_start_underscore, Options.parse_chars.xid_continue);
+
+			return lexy::dsl::lit_b<Options.EscapeChar> >>
+				   (lexy::dsl::lit_b<Options.EscapeChar> |
+					   (id >> lexy::dsl::lit_b<Options.EscapeChar>));
+		}();
+		static constexpr auto value =
+			lexy::callback<ovdl::csv::ValueNode::internal_value_type>(
+				[](auto&& lexeme) {
+					return ovdl::csv::ValueNode::Placeholder { std::string { lexeme.data(), lexeme.size() } };
+				},
+				[](lexy::nullopt = {}) {
+					return std::string(1, Options.EscapeChar);
+				});
+	};
+
+	template<ParseOptions Options>
+	struct PlainValue {
+		static constexpr auto rule = [] {
+			auto min_skip = lexy::dsl::lit_b<Options.SepChar> / lexy::dsl::ascii::newline;
+			if constexpr (Options.SupportStrings) {
+				return lexy::dsl::identifier(Options.parse_chars.character - min_skip);
+			} else {
+				auto escape_check_char = [=] {
+					if constexpr (Options.EscapeChar != 0) {
+						return Options.parse_chars.character - (min_skip / lexy::dsl::lit_b<Options.EscapeChar>);
+					} else {
+						return Options.parse_chars.character - min_skip;
+					}
+				}();
+				auto id_check_char = escape_check_char - lexy::dsl::lit_b<'\\'>;
+				auto id_segment = lexy::dsl::identifier(id_check_char);
+				auto escape_segement = lexy::dsl::token(escape_check_char);
+				auto escape_sym = lexy::dsl::symbol<escaped_symbols>(escape_segement);
+				auto escape_rule = lexy::dsl::lit_b<'\\'> >> escape_sym;
+				if constexpr (Options.EscapeChar != 0) {
+					return lexy::dsl::list(lexy::dsl::p<EscapeValue<Options>> | id_segment | escape_rule);
+				} else {
+					return lexy::dsl::list(id_segment | escape_rule);
+				}
+			}
+		}();
+		static constexpr auto value =
+			lexy::fold_inplace<std::vector<ovdl::csv::ValueNode::internal_value_type>>(
+				std::initializer_list<ovdl::csv::ValueNode::internal_value_type> {},
+				[](auto& list, const char& c) {
+					if (list.empty()) {
+						list.push_back(std::string { c, 1 });
+						return;
+					}
+					std::visit([&](auto&& arg) {
+						using T = std::decay_t<decltype(arg)>;
+						if constexpr (std::is_same_v<T, std::string>) {
+							arg += c;
+						} else {
+							list.push_back(std::string { c, 1 });
+						}
+					},
+						list.back());
+				},
+				[]<typename Reader>(auto& list, lexy::lexeme<Reader> lexeme) {
+					if (list.empty()) {
+						list.push_back(std::string { lexeme.data(), lexeme.size() });
+						return;
+					}
+					std::visit([&](auto&& arg) {
+						using T = std::decay_t<decltype(arg)>;
+						if constexpr (std::is_same_v<T, std::string>) {
+							arg += std::string_view { lexeme.data(), lexeme.size() };
+						} else {
+							list.push_back(std::string { lexeme.data(), lexeme.size() });
+						}
+					},
+						list.back());
+				},
+				[](auto& list, ovdl::csv::ValueNode::internal_value_type&& arg) {
+					if (list.empty()) {
+						list.push_back(LEXY_MOV(arg));
+						return;
+					}
+					using T = std::decay_t<decltype(arg)>;
+					std::visit([&](auto&& list_arg) {
+						using list_T = std::decay_t<decltype(list_arg)>;
+						if constexpr (std::is_same_v<T, std::string> && std::is_same_v<list_T, std::string>) {
+							list_arg += LEXY_MOV(arg);
+						} else {
+							list.push_back(LEXY_MOV(arg));
+						}
+					},
+						list.back());
+				}) >>
+			lexy::callback<ovdl::csv::ValueNode>(
+				[](std::vector<ovdl::csv::ValueNode::internal_value_type>&& list) {
+					return ovdl::csv::ValueNode(LEXY_MOV(list));
+				},
+				[](auto&& lexeme) {
+					ovdl::csv::ValueNode result;
+					result.set_as_list(std::string { lexeme.data(), lexeme.size() });
+					return result;
+				});
+	};
+
+	template<ParseOptions Options>
+	struct Value {
+		static constexpr auto rule = [] {
+			if constexpr (Options.SupportStrings) {
+				return lexy::dsl::p<StringValue<Options>> | lexy::dsl::p<PlainValue<Options>>;
+			} else {
+				return lexy::dsl::p<PlainValue<Options>>;
+			}
+		}();
+		static constexpr auto value = lexy::forward<ovdl::csv::ValueNode>;
+	};
+
+	template<ParseOptions Options>
+	struct SepConst {
+		static constexpr auto rule = lexy::dsl::lit_b<Options.SepChar>;
+		static constexpr auto value = lexy::constant(1);
+	};
+
+	template<ParseOptions Options>
+	struct Seperator {
+		static constexpr auto rule = lexy::dsl::list(lexy::dsl::p<SepConst<Options>>);
+		static constexpr auto value = lexy::count;
+	};
+
+	template<ParseOptions Options>
+	struct LineEnd {
+		static constexpr auto rule = lexy::dsl::list(lexy::dsl::p<Value<Options>>, lexy::dsl::trailing_sep(lexy::dsl::p<Seperator<Options>>));
+		static constexpr auto value = lexy::fold_inplace<ovdl::csv::LineObject>(
+			std::initializer_list<ovdl::csv::LineObject::value_type> {},
+			[](ovdl::csv::LineObject& result, auto&& arg) {
+				if constexpr (std::is_same_v<std::decay_t<decltype(arg)>, std::size_t>) {
+					// Count seperators, adds to previous value, making it a position
+					using position_type = ovdl::csv::LineObject::position_type;
+					result.emplace_back("", static_cast<position_type>(arg + result.back().get_position()));
+				} else {
+					if (result.empty()) result.push_back(LEXY_MOV(arg));
+					else {
+						auto& object = result.back();
+						object = LEXY_MOV(arg);
+					}
+				}
+			});
+	};
+
+	template<ParseOptions Options>
+	struct Line {
+
+		static constexpr auto suffix_setter(ovdl::csv::LineObject& line) {
+			auto& object = line.back();
+			if (object.list_is_empty()) {
+				line.set_suffix_end(object.get_position());
+				line.pop_back();
+			} else {
+				line.set_suffix_end(object.get_position() + 1);
+			}
+		};
+
+		static constexpr auto rule = lexy::dsl::p<LineEnd<Options>> | lexy::dsl::p<Seperator<Options>> >> lexy::dsl::p<LineEnd<Options>>;
+		static constexpr auto value =
+			lexy::callback<ovdl::csv::LineObject>(
+				[](ovdl::csv::LineObject&& line) {
+					suffix_setter(line);
+					return LEXY_MOV(line);
+				},
+				[](std::size_t prefix_count, ovdl::csv::LineObject&& line) {
+					line.set_prefix_end(prefix_count);
+					// position needs to be adjusted to prefix
+					for (auto& object : line) {
+						object.set_position(object.get_position() + prefix_count);
+					}
+					suffix_setter(line);
+					return LEXY_MOV(line);
+				});
+	};
+
+	template<ParseOptions Options>
+	struct File {
+		static constexpr auto rule =
+			lexy::dsl::whitespace(lexy::dsl::newline) +
+			lexy::dsl::opt(lexy::dsl::list(lexy::dsl::p<Line<Options>>, lexy::dsl::trailing_sep(lexy::dsl::eol)));
+
+		static constexpr auto value = lexy::as_list<std::vector<ovdl::csv::LineObject>>;
+	};
+}
+
 // Grammar Definitions //
 namespace ovdl::csv::grammar::windows1252 {
-	constexpr auto character = detail::lexydsl::make_range<0x01, 0xFF>();
-	constexpr auto control =
-		lexy::dsl::ascii::control /
-		lexy::dsl::lit_b<0x81> / lexy::dsl::lit_b<0x8D> / lexy::dsl::lit_b<0x8F> /
-		lexy::dsl::lit_b<0x90> / lexy::dsl::lit_b<0x9D>;
-	constexpr auto id_head = lexy::dsl::ascii::alpha_underscore;
-	constexpr auto id_tail = lexy::dsl::ascii::alpha_digit_underscore;
-
-#include "Grammar.inc"
+	struct windows1252_t {
+		static constexpr auto character = detail::lexydsl::make_range<0x01, 0xFF>();
+		static constexpr auto control =
+			lexy::dsl::ascii::control /
+			lexy::dsl::lit_b<0x81> / lexy::dsl::lit_b<0x8D> / lexy::dsl::lit_b<0x8F> /
+			lexy::dsl::lit_b<0x90> / lexy::dsl::lit_b<0x9D>;
+		static constexpr auto xid_start_underscore = lexy::dsl::ascii::alpha_underscore;
+		static constexpr auto xid_continue = lexy::dsl::ascii::alpha_digit_underscore;
+	};
+
+	using CommaFile = File<ParseOptions<windows1252_t> { ',', false, '$' }>;
+	using ColonFile = File<ParseOptions<windows1252_t> { ':', false, '$' }>;
+	using SemiColonFile = File<ParseOptions<windows1252_t> { ';', false, '$' }>;
+	using TabFile = File<ParseOptions<windows1252_t> { '\t', false, '$' }>;
+	using BarFile = File<ParseOptions<windows1252_t> { '|', false, '$' }>;
+
+	namespace strings {
+		using CommaFile = File<ParseOptions<windows1252_t> { ',', true, '$' }>;
+		using ColonFile = File<ParseOptions<windows1252_t> { ':', true, '$' }>;
+		using SemiColonFile = File<ParseOptions<windows1252_t> { ';', true, '$' }>;
+		using TabFile = File<ParseOptions<windows1252_t> { '\t', true, '$' }>;
+		using BarFile = File<ParseOptions<windows1252_t> { '|', true, '$' }>;
+	}
 }
 
 namespace ovdl::csv::grammar::utf8 {
-	constexpr auto character = lexy::dsl::unicode::character;
-	constexpr auto control = lexy::dsl::unicode::control;
-	constexpr auto id_head = lexy::dsl::unicode::xid_start_underscore;
-	constexpr auto id_tail = lexy::dsl::unicode::xid_continue;
+	struct unicode_t {
+		static constexpr auto character = lexy::dsl::unicode::character;
+		static constexpr auto control = lexy::dsl::unicode::control;
+		static constexpr auto xid_start_underscore = lexy::dsl::unicode::xid_start_underscore;
+		static constexpr auto xid_continue = lexy::dsl::unicode::xid_continue;
+	};
+
+	using CommaFile = File<ParseOptions<unicode_t> { ',', false, '$' }>;
+	using ColonFile = File<ParseOptions<unicode_t> { ':', false, '$' }>;
+	using SemiColonFile = File<ParseOptions<unicode_t> { ';', false, '$' }>;
+	using TabFile = File<ParseOptions<unicode_t> { '\t', false, '$' }>;
+	using BarFile = File<ParseOptions<unicode_t> { '|', false, '$' }>;
 
-#include "Grammar.inc"
+	namespace strings {
+		using CommaFile = File<ParseOptions<unicode_t> { ',', true, '$' }>;
+		using ColonFile = File<ParseOptions<unicode_t> { ':', true, '$' }>;
+		using SemiColonFile = File<ParseOptions<unicode_t> { ';', true, '$' }>;
+		using TabFile = File<ParseOptions<unicode_t> { '\t', true, '$' }>;
+		using BarFile = File<ParseOptions<unicode_t> { '|', true, '$' }>;
+	}
 }
\ No newline at end of file
diff --git a/src/openvic-dataloader/csv/Grammar.inc b/src/openvic-dataloader/csv/Grammar.inc
deleted file mode 100644
index 7de9e81..0000000
--- a/src/openvic-dataloader/csv/Grammar.inc
+++ /dev/null
@@ -1,221 +0,0 @@
-// This is designed to be reused in CsvGrammar.hpp multiple times
-// Please ignore undeclared variable use for character and control, this is intended
-// Sorry was the cleanest way I could think of to prevent code duplication
-
-// Includes to keep file errors small
-#include <initializer_list>
-#include <memory>
-#include <string>
-#include <string_view>
-#include <tuple>
-#include <type_traits>
-#include <vector>
-
-#include <openvic-dataloader/csv/LineObject.hpp>
-#include <openvic-dataloader/csv/Parser.hpp>
-
-#include <lexy/callback.hpp>
-#include <lexy/dsl.hpp>
-
-#include <fmt/format.h>
-
-#include "detail/LexyLitRange.hpp"
-
-struct ParseOptions {
-	/// @brief Seperator character
-	char SepChar;
-	/// @brief Determines whether StringValue is supported
-	bool SupportStrings;
-	/// @brief Paradox-style localization escape characters
-	/// @note Is ignored if SupportStrings is true
-	char EscapeChar;
-};
-
-constexpr auto escaped_symbols = lexy::symbol_table<char> //
-									 .map<'"'>('"')
-									 .map<'\''>('\'')
-									 .map<'\\'>('\\')
-									 .map<'/'>('/')
-									 .map<'b'>('\b')
-									 .map<'f'>('\f')
-									 .map<'n'>('\n')
-									 .map<'r'>('\r')
-									 .map<'t'>('\t');
-
-constexpr auto escaped_quote = lexy::symbol_table<char> //
-								   .map<'"'>('"');
-
-template<ParseOptions Options>
-struct StringValue {
-	static constexpr auto rule = [] {
-		// Arbitrary code points
-		auto c = character - control;
-
-		auto back_escape = lexy::dsl::backslash_escape //
-							   .symbol<escaped_symbols>();
-
-		auto quote_escape = lexy::dsl::escape(lexy::dsl::lit_c<'"'>) //
-								.symbol<escaped_quote>();
-
-		auto quotes = lexy::dsl::delimited(lexy::dsl::lit_c<'"'>, lexy::dsl::not_followed_by(lexy::dsl::lit_c<'"'>, lexy::dsl::lit_c<'"'>));
-
-		return quotes(c, back_escape, quote_escape);
-	}();
-
-	static constexpr auto value = lexy::as_string<std::string>;
-};
-
-template<ParseOptions Options>
-struct EscapeValue {
-	static constexpr auto rule = [] {
-		auto id = lexy::dsl::identifier(id_head, id_tail);
-
-		return lexy::dsl::lit_b<Options.EscapeChar> >>
-			   (lexy::dsl::lit_b<Options.EscapeChar> |
-				   (id >> lexy::dsl::lit_b<Options.EscapeChar>));
-	}();
-	static constexpr auto value =
-		lexy::callback_with_state<std::string>(
-			[](const auto& state, auto&& lexeme) {
-				auto check = std::string_view { lexeme.data(), lexeme.size() };
-				if (auto value = state.find_value(check); value != state.end())
-					return std::string(value->second.data(), value->second.size());
-				return fmt::format("${}$", check);
-			},
-			[](auto&& lexeme) {
-				return fmt::format("${}$", std::string_view { lexeme.data(), lexeme.size() });
-			},
-			[](lexy::nullopt = {}) {
-				return std::string(1, Options.EscapeChar);
-			},
-			[](const auto& state, lexy::nullopt = {}) {
-				return std::string(1, Options.EscapeChar);
-			});
-};
-
-template<ParseOptions Options>
-struct PlainValue {
-	static constexpr auto rule = [] {
-		auto min_skip = lexy::dsl::lit_b<Options.SepChar> / lexy::dsl::ascii::newline;
-		if constexpr (Options.SupportStrings) {
-			return lexy::dsl::identifier(character - min_skip);
-		} else {
-			auto escape_check_char = [=] {
-				if constexpr (Options.EscapeChar != 0) {
-					return character - (min_skip / lexy::dsl::lit_b<Options.EscapeChar>);
-				} else {
-					return character - min_skip;
-				}
-			}();
-			auto id_check_char = escape_check_char - lexy::dsl::lit_b<'\\'>;
-			auto id_segment = lexy::dsl::identifier(id_check_char);
-			auto escape_segement = lexy::dsl::token(escape_check_char);
-			auto escape_sym = lexy::dsl::symbol<escaped_symbols>(escape_segement);
-			auto escape_rule = lexy::dsl::lit_b<'\\'> >> escape_sym;
-			if constexpr (Options.EscapeChar != 0) {
-				return lexy::dsl::list(lexy::dsl::p<EscapeValue<Options>> | id_segment | escape_rule);
-			} else {
-				return lexy::dsl::list(id_segment | escape_rule);
-			}
-		}
-	}();
-	static constexpr auto value = lexy::as_string<std::string>;
-};
-
-template<ParseOptions Options>
-struct Value {
-	static constexpr auto rule = [] {
-		if constexpr (Options.SupportStrings) {
-			return lexy::dsl::p<StringValue<Options>> | lexy::dsl::p<PlainValue<Options>>;
-		} else {
-			return lexy::dsl::p<PlainValue<Options>>;
-		}
-	}();
-	static constexpr auto value = lexy::forward<std::string>;
-};
-
-template<ParseOptions Options>
-struct SepConst {
-	static constexpr auto rule = lexy::dsl::lit_b<Options.SepChar>;
-	static constexpr auto value = lexy::constant(1);
-};
-
-template<ParseOptions Options>
-struct Seperator {
-	static constexpr auto rule = lexy::dsl::list(lexy::dsl::p<SepConst<Options>>);
-	static constexpr auto value = lexy::count;
-};
-
-template<ParseOptions Options>
-struct LineEnd {
-	static constexpr auto rule = lexy::dsl::list(lexy::dsl::p<Value<Options>>, lexy::dsl::trailing_sep(lexy::dsl::p<Seperator<Options>>));
-	static constexpr auto value = lexy::fold_inplace<ovdl::csv::LineObject>(
-		std::initializer_list<ovdl::csv::LineObject::value_type> {},
-		[](ovdl::csv::LineObject& result, auto&& arg) {
-			if constexpr (std::is_same_v<std::decay_t<decltype(arg)>, std::size_t>) {
-				// Count seperators, adds to previous value, making it a position
-				using position_type = ovdl::csv::LineObject::position_type;
-				result.emplace_back(static_cast<position_type>(arg + result.back().first), "");
-			} else {
-				if (result.empty()) result.emplace_back(0u, LEXY_MOV(arg));
-				else {
-					auto& [pos, value] = result.back();
-					value = arg;
-				}
-			}
-		});
-};
-
-template<ParseOptions Options>
-struct Line {
-
-	static constexpr auto suffix_setter(ovdl::csv::LineObject& line) {
-		auto& [position, value] = line.back();
-		if (value.empty()) {
-			line.set_suffix_end(position);
-			line.pop_back();
-		} else {
-			line.set_suffix_end(position + 1);
-		}
-	};
-
-	static constexpr auto rule = lexy::dsl::p<LineEnd<Options>> | lexy::dsl::p<Seperator<Options>> >> lexy::dsl::p<LineEnd<Options>>;
-	static constexpr auto value =
-		lexy::callback<ovdl::csv::LineObject>(
-			[](ovdl::csv::LineObject&& line) {
-				suffix_setter(line);
-				return LEXY_MOV(line);
-			},
-			[](std::size_t prefix_count, ovdl::csv::LineObject&& line) {
-				line.set_prefix_end(prefix_count);
-				// position needs to be adjusted to prefix
-				for (auto& [position, value] : line) {
-					position += prefix_count;
-				}
-				suffix_setter(line);
-				return LEXY_MOV(line);
-			});
-};
-
-template<ParseOptions Options>
-struct File {
-	static constexpr auto rule =
-		lexy::dsl::whitespace(lexy::dsl::newline) +
-		lexy::dsl::opt(lexy::dsl::list(lexy::dsl::p<Line<Options>>, lexy::dsl::trailing_sep(lexy::dsl::eol)));
-
-	static constexpr auto value = lexy::as_list<std::vector<ovdl::csv::LineObject>>;
-};
-
-using CommaFile = File<ParseOptions { ',', false, '$' }>;
-using ColonFile = File<ParseOptions { ':', false, '$' }>;
-using SemiColonFile = File<ParseOptions { ';', false, '$' }>;
-using TabFile = File<ParseOptions { '\t', false, '$' }>;
-using BarFile = File<ParseOptions { '|', false, '$' }>;
-
-namespace strings {
-	using CommaFile = File<ParseOptions { ',', true, '$' }>;
-	using ColonFile = File<ParseOptions { ':', true, '$' }>;
-	using SemiColonFile = File<ParseOptions { ';', true, '$' }>;
-	using TabFile = File<ParseOptions { '\t', true, '$' }>;
-	using BarFile = File<ParseOptions { '|', true, '$' }>;
-}
diff --git a/src/openvic-dataloader/csv/Parser.cpp b/src/openvic-dataloader/csv/Parser.cpp
index 40f0037..748b866 100644
--- a/src/openvic-dataloader/csv/Parser.cpp
+++ b/src/openvic-dataloader/csv/Parser.cpp
@@ -1,18 +1,29 @@
+#include <algorithm>
+#include <cstddef>
+#include <filesystem>
+#include <functional>
 #include <memory>
+#include <optional>
+#include <ostream>
+#include <string>
+#include <string_view>
+#include <utility>
 #include <vector>
 
+#include <openvic-dataloader/ParseData.hpp>
+#include <openvic-dataloader/ParseError.hpp>
+#include <openvic-dataloader/ParseWarning.hpp>
 #include <openvic-dataloader/csv/LineObject.hpp>
 #include <openvic-dataloader/csv/Parser.hpp>
-#include <openvic-dataloader/detail/ClassExport.hpp>
+#include <openvic-dataloader/csv/ValueNode.hpp>
+#include <openvic-dataloader/detail/Concepts.hpp>
 
 #include <lexy/action/parse.hpp>
 #include <lexy/encoding.hpp>
-#include <lexy/input/buffer.hpp>
-#include <lexy/input/file.hpp>
+#include <lexy/visualize.hpp>
 
 #include "csv/CsvGrammar.hpp"
 #include "detail/BasicBufferHandler.hpp"
-#include "detail/Errors.hpp"
 #include "detail/LexyReportError.hpp"
 #include "detail/OStreamOutputIterator.hpp"
 
diff --git a/src/openvic-dataloader/csv/ValueNode.cpp b/src/openvic-dataloader/csv/ValueNode.cpp
new file mode 100644
index 0000000..84c375c
--- /dev/null
+++ b/src/openvic-dataloader/csv/ValueNode.cpp
@@ -0,0 +1,57 @@
+#include <openvic-dataloader/csv/ValueNode.hpp>
+
+using namespace ovdl;
+using namespace ovdl::csv;
+
+ValueNode::ValueNode() = default;
+
+ValueNode::ValueNode(std::string_view string, position_type position)
+	: ValueNode(std::initializer_list<internal_value_type> { std::string(string) }, position) {
+}
+ValueNode::ValueNode(std::vector<internal_value_type> value_list, position_type position)
+	: _value_list(value_list),
+	  _position(position) {
+}
+ValueNode::ValueNode(std::initializer_list<internal_value_type> value_list, position_type position)
+	: _value_list(value_list),
+	  _position(position) {
+}
+
+void ValueNode::set_position(position_type position) {
+	_position = position;
+}
+
+ValueNode::position_type ValueNode::get_position() const {
+	return _position;
+}
+
+void ValueNode::set_as_list(internal_value_type value) {
+	_value_list.assign({ value });
+}
+
+void ValueNode::add_to_list(internal_value_type value) {
+	_value_list.push_back(value);
+}
+
+bool ValueNode::list_is_empty() const {
+	return _value_list.empty();
+}
+
+std::string ValueNode::make(std::string_view prefix, std::optional<std::string_view> suffix) const {
+	std::vector<std::string> pre_joined(_value_list.size());
+
+	for (auto&& value : _value_list) {
+		const auto& result = std::visit([&](auto&& arg) -> std::string {
+			using T = std::decay_t<decltype(arg)>;
+			if constexpr (std::is_same_v<T, std::string>) {
+				return arg;
+			} else if constexpr (std::is_same_v<T, Placeholder>) {
+				return arg.as_string(prefix, suffix);
+			}
+		},
+			value);
+		pre_joined.push_back(result);
+	}
+
+	return fmt::format("{}", fmt::join(pre_joined, ""));
+}
\ No newline at end of file