Merge changes from master

rjp++/CMakeLists.txt

@@ -2,6 +2,7 @@ project(rjp++)
 cmake_minimum_required(VERSION 3.0.2)
 
 include(GNUInstallDirs)
+find_package(PkgConfig)
 
 set(rjp++_VERSION_MAJOR 0)
 set(rjp++_VERSION_MINOR 9)
@@ -14,13 +15,18 @@ option(BUILD_TESTS "Build test programs" OFF)
 option(ENABLE_PROFILING "Enable asan" OFF)
 mark_as_advanced(ENABLE_PROFILING)
 
+pkg_check_modules(LIBREXY REQUIRED librexy)
+
+set(LIBREXY_REAL_LIBRARIES ${LIBREXY_LIBRARIES})
+list(TRANSFORM LIBREXY_REAL_LIBRARIES PREPEND "-l")
+
 set(SOURCE_LIST "src/allocator.cpp" "src/array.cpp" "src/integral.cpp" "src/object.cpp" "src/rjp.cpp" "src/string.cpp" "src/string_val.cpp" "src/value.cpp" "src/vget_proxy.cpp" "src/container.cpp" "src/member.cpp")
 if(ENABLE_SHARED)
-	set(RJP++_LIBFLAGS "-lrjp++ -lrexy")
+	set(RJP++_LIBFLAGS "-lrjp++ ${LIBREXY_REAL_LIBRARIES}")
 	add_library(rjp++ SHARED ${SOURCE_LIST})
 	set_target_properties(rjp++ PROPERTIES SOVERSION "${rjp_VERSION_MAJOR}.${rjp_VERSION_MINOR}.${rjp_VERSION_REVISION}")
 else()
-	set(RJP++_LIBFLAGS "-lrjp++ -lrjp -lrexy")
+	set(RJP++_LIBFLAGS "-lrjp++ -lrjp ${LIBREXY_REAL_LIBRARIES}")
 	add_library(rjp++ STATIC ${SOURCE_LIST})
 endif()
 
@@ -46,9 +52,9 @@ if(BUILD_TESTS)
 endif()
 
 
-set_target_properties(rjp++ PROPERTIES COMPILE_FLAGS -std=c++17)
-target_compile_options(rjp++ PRIVATE -Wall -Wextra -pedantic)
-target_link_libraries(rjp++ rjp -lrexy)
+target_compile_options(rjp++ PUBLIC -Wall -Wextra -pedantic -std=c++20 ${LIBREXY_CFLAGS_OTHER})
+target_include_directories(rjp++ PUBLIC ${LIBREXY_INCLUDE_DIRS})
+target_link_libraries(rjp++ PUBLIC rjp ${LIBREXY_LINK_LIBRARIES})
 
 install(TARGETS rjp++
 	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}

rjp++/include/array.hpp

@@ -93,7 +93,7 @@ namespace rjp{
 		string_val add(const RJP_string&);
 		string_val add(RJP_string&&);
 		string_val add(const char*, RJP_index len = 0);
-		string_val add(const rexy::string_base<char>&);
+		string_val add(rexy::string_view);
 		string_val add(string&&);
 
 		value& remove(value& val);

rjp++/include/object.hpp

@@ -75,13 +75,13 @@ namespace rjp{
 		object& operator=(object&&) = default;
 
 		template<class Val>
-		member<std::decay_t<Val>> add(const rexy::string_view& key, typename std::decay_t<Val>::underlying_type t){
+		member<std::decay_t<Val>> add(rexy::string_view key, typename std::decay_t<Val>::underlying_type t){
 			RJP_value* newmem = add_member_impl(key);
 			detail::set_to_underlying<std::decay_t<Val>>(newmem, t);
 			return create_unmanaged(newmem);
 		}
 		template<class Val = null>
-		member<std::decay_t<Val>> add(const rexy::string_view& key){
+		member<std::decay_t<Val>> add(rexy::string_view key){
 			RJP_value* newmem = add_member_impl(key);
 			if constexpr(std::is_same<std::decay_t<Val>,rjp::array>::value)
 				set_array_value(newmem);
@@ -93,11 +93,11 @@ namespace rjp{
 				detail::set_to_underlying<std::decay_t<Val>>(newmem, 0);
 			return create_unmanaged(newmem);
 		}
-		member<string_val> add(const rexy::string_view& key, const RJP_string&);
-		member<string_val> add(const rexy::string_view& key, RJP_string&&);
-		member<string_val> add(const rexy::string_view& key, const char*, RJP_index len = 0);
-		member<string_val> add(const rexy::string_view& key, const rexy::string_view&);
-		member<string_val> add(const rexy::string_view& key, string&&);
+		member<string_val> add(rexy::string_view key, const RJP_string&);
+		member<string_val> add(rexy::string_view key, RJP_string&&);
+		member<string_val> add(rexy::string_view key, const char*, RJP_index len = 0);
+		member<string_val> add(rexy::string_view key, rexy::string_view);
+		member<string_val> add(rexy::string_view key, string&&);
 
 		template<class Val>
 		member<std::decay_t<Val>> add(string&& key, typename std::decay_t<Val>::underlying_type t){
@@ -121,13 +121,13 @@ namespace rjp{
 		member<string_val> add(string&& key, const RJP_string&);
 		member<string_val> add(string&& key, RJP_string&&);
 		member<string_val> add(string&& key, const char*, RJP_index len = 0);
-		member<string_val> add(string&& key, const rexy::string_view&);
+		member<string_val> add(string&& key, rexy::string_view);
 		member<string_val> add(string&& key, string&&);
 
-		value remove(const rexy::string_view& key);
+		value remove(rexy::string_view key);
 		value& remove(value& val);
 
-		void destroy(const rexy::string_view& key);
+		void destroy(rexy::string_view key);
 		void destroy(value&& val);
 
 		bool has_child(const value&);
@@ -142,10 +142,10 @@ namespace rjp{
 
 		size_type size(void)const;
 
-		value search(const rexy::string_view& key)const;
+		value search(rexy::string_view key)const;
 
 	private:
-		RJP_value* add_member_impl(const rexy::string_view& key);
+		RJP_value* add_member_impl(rexy::string_view key);
 		RJP_value* add_member_impl(string&& key);
 	};
 

rjp++/include/parse.hpp

@@ -51,7 +51,7 @@ namespace rjp{
 	[[nodiscard]]
 	string to_json(const value& val, int format = RJP_FORMAT_PRETTY);
 	[[nodiscard]]
-	parse_res parse_json(const rexy::string_base<char>& str, RJP_parse_flag = RJP_PARSE_NO_EXT);
+	parse_res parse_json(rexy::string_view str, RJP_parse_flag = RJP_PARSE_NO_EXT);
 	[[nodiscard]]
 	parse_res parse_json(const char* str, RJP_parse_flag = RJP_PARSE_NO_EXT);
 	namespace detail{

rjp++/include/string.hpp

@@ -25,8 +25,8 @@
 namespace rjp{
 
 	namespace detail{
-		struct allocator
-		{
+		struct allocator{
+			using value_type = char;
 			using size_type = size_t;
 			using pointer = char*;
 			using const_pointer = const char*;

rjp++/include/string_val.hpp

@@ -32,13 +32,13 @@ namespace rjp{
 		using underlying_type = RJP_string;
 	public:
 		using value::value;
-		string_val(const rexy::string_view& str);
+		string_val(rexy::string_view str);
 		string_val(string&& str);
 		string_val(void);
 		string_val(const value& val);
 		string_val(value&& val);
-		string_val(const value& val, const rexy::string_base<char>& i);
-		string_val(value&& val, const rexy::string_base<char>& i);
+		string_val(const value& val, rexy::string_view i);
+		string_val(value&& val, rexy::string_view i);
 		string_val(const value& val, string&& i);
 		string_val(value&& val, string&& i);
 
@@ -50,7 +50,7 @@ namespace rjp{
 
 		rexy::string_view get(void)const;
 		string steal(void);
-		void set(const rexy::string_base<char>& str);
+		void set(rexy::string_view str);
 		void set(string&& str);
 
 	};

rjp++/src/array.cpp

@@ -55,8 +55,8 @@ namespace rjp{
 		rjp_set_string(newelem, c, len);
 		return string_val(create_unmanaged(newelem));
 	}
-	string_val array::add(const rexy::string_base<char>& s){
-		return add(s.get(), s.length());
+	string_val array::add(rexy::string_view s){
+		return add(s.data(), s.length());
 	}
 	string_val array::add(string&& s){
 		RJP_value* newelem = rjp_new_element(m_value);

rjp++/src/object.cpp

@@ -39,62 +39,62 @@ namespace rjp{
 		if(rjp_value_type(m_value) != rjp_json_object)
 			rjp_set_object(m_value);
 	}
-	member<string_val> object::add(const rexy::string_view& key, const RJP_string& s){
-		RJP_value* newmem = rjp_new_member(m_value, key.get(), key.length());
+	member<string_val> object::add(rexy::string_view key, const RJP_string& s){
+		RJP_value* newmem = rjp_new_member(m_value, key.data(), key.length());
 		rjp_set_string(newmem, s.value, s.length);
 		return create_unmanaged(newmem);
 	}
-	member<string_val> object::add(const rexy::string_view& key, RJP_string&& s){
-		RJP_value* newmem = rjp_new_member(m_value, key.get(), key.length());
+	member<string_val> object::add(rexy::string_view key, RJP_string&& s){
+		RJP_value* newmem = rjp_new_member(m_value, key.data(), key.length());
 		rjp_set_string_steal(newmem, s.value, s.length);
 		return create_unmanaged(newmem);
 	}
-	member<string_val> object::add(const rexy::string_view& key, const char* s, RJP_index len){
-		RJP_value* newmem = rjp_new_member(m_value, key.get(), key.length());
+	member<string_val> object::add(rexy::string_view key, const char* s, RJP_index len){
+		RJP_value* newmem = rjp_new_member(m_value, key.data(), key.length());
 		rjp_set_string(newmem, s, len);
 		return create_unmanaged(newmem);
 	}
-	member<string_val> object::add(const rexy::string_view& key, const rexy::string_view& s){
-		RJP_value* newmem = rjp_new_member(m_value, key.get(), key.length());
-		rjp_set_string(newmem, s.get(), s.length());
+	member<string_val> object::add(rexy::string_view key, rexy::string_view s){
+		RJP_value* newmem = rjp_new_member(m_value, key.data(), key.length());
+		rjp_set_string(newmem, s.data(), s.length());
 		return create_unmanaged(newmem);
 	}
-	member<string_val> object::add(const rexy::string_view& key, string&& s){
-		RJP_value* newmem = rjp_new_member(m_value, key.get(), key.length());
+	member<string_val> object::add(rexy::string_view key, string&& s){
+		RJP_value* newmem = rjp_new_member(m_value, key.data(), key.length());
 		auto len = s.length();
 		rjp_set_string_steal(newmem, s.release(), len);
 		return create_unmanaged(newmem);
 	}
 
 	member<string_val> object::add(string&& key, const RJP_string& s){
-		RJP_value* newmem = rjp_new_member_steal_key(m_value, key.get(), key.length());
+		RJP_value* newmem = rjp_new_member_steal_key(m_value, key.data(), key.length());
 		rjp_set_string(newmem, s.value, s.length);
 		return create_unmanaged(newmem);
 	}
 	member<string_val> object::add(string&& key, RJP_string&& s){
-		RJP_value* newmem = rjp_new_member_steal_key(m_value, key.get(), key.length());
+		RJP_value* newmem = rjp_new_member_steal_key(m_value, key.data(), key.length());
 		rjp_set_string_steal(newmem, s.value, s.length);
 		return create_unmanaged(newmem);
 	}
 	member<string_val> object::add(string&& key, const char* s, RJP_index len){
-		RJP_value* newmem = rjp_new_member_steal_key(m_value, key.get(), key.length());
+		RJP_value* newmem = rjp_new_member_steal_key(m_value, key.data(), key.length());
 		rjp_set_string(newmem, s, len);
 		return create_unmanaged(newmem);
 	}
-	member<string_val> object::add(string&& key, const rexy::string_view& s){
-		RJP_value* newmem = rjp_new_member_steal_key(m_value, key.get(), key.length());
-		rjp_set_string(newmem, s.get(), s.length());
+	member<string_val> object::add(string&& key, rexy::string_view s){
+		RJP_value* newmem = rjp_new_member_steal_key(m_value, key.data(), key.length());
+		rjp_set_string(newmem, s.data(), s.length());
 		return create_unmanaged(newmem);
 	}
 	member<string_val> object::add(string&& key, string&& s){
-		RJP_value* newmem = rjp_new_member_steal_key(m_value, key.get(), key.length());
+		RJP_value* newmem = rjp_new_member_steal_key(m_value, key.data(), key.length());
 		auto len = s.length();
 		rjp_set_string_steal(newmem, s.release(), len);
 		return create_unmanaged(newmem);
 	}
 
-	value object::remove(const rexy::string_view& key){
-		RJP_value* removed = rjp_remove_member_by_key(m_value, key.get());
+	value object::remove(rexy::string_view key){
+		RJP_value* removed = rjp_remove_member_by_key(m_value, key.data());
 		return create_managed(removed);
 	}
 	value& object::remove(value& val){
@@ -103,8 +103,8 @@ namespace rjp{
 		return val;
 	}
 
-	void object::destroy(const rexy::string_view& key){
-		rjp_free_member_by_key(m_value, key.get());
+	void object::destroy(rexy::string_view key){
+		rjp_free_member_by_key(m_value, key.data());
 	}
 	void object::destroy(value&& val){
 		rjp_free_member(m_value, val.raw());
@@ -134,13 +134,13 @@ namespace rjp{
 	object::size_type object::size(void)const{
 		return rjp_num_members(m_value);
 	}
-	value object::search(const rexy::string_view& key)const{
-		RJP_value* result = rjp_search_member(m_value, key.get());
+	value object::search(rexy::string_view key)const{
+		RJP_value* result = rjp_search_member(m_value, key.data());
 		return create_unmanaged(result);
 	}
 
-	RJP_value* object::add_member_impl(const rexy::string_view& key){
-		return rjp_new_member(m_value, key.get(), key.length());
+	RJP_value* object::add_member_impl(rexy::string_view key){
+		return rjp_new_member(m_value, key.data(), key.length());
 	}
 	RJP_value* object::add_member_impl(string&& key){
 		auto length = key.length();

rjp++/src/rjp.cpp

@@ -57,8 +57,8 @@ namespace rjp{
 		s.reset(rjp_to_json(val.raw(), format));
 		return s;
 	}
-	parse_res parse_json(const rexy::string_base<char>& str, RJP_parse_flag flags){
-		return parse_json(str.get(), flags);
+	parse_res parse_json(rexy::string_view str, RJP_parse_flag flags){
+		return parse_json(str.data(), flags);
 	}
 	parse_res parse_json(const char* str, RJP_parse_flag flags){
 		RJP_parse_error err = {};

rjp++/src/string_val.cpp

@@ -22,10 +22,12 @@
 
 namespace rjp{
 
-	string_val::string_val(const rexy::string_view& str):
-		value(rjp_new_string(str.get(), str.length()), true){}
+	using namespace rexy::str_literals;
+
+	string_val::string_val(rexy::string_view str):
+		value(rjp_new_string(str.data(), str.length()), true){}
 	string_val::string_val(string&& str):
-		value(rjp_new_string_steal(str.get(), str.length()), true)
+		value(rjp_new_string_steal(str.data(), str.length()), true)
 	{
 		str.release();
 	}
@@ -47,15 +49,15 @@ namespace rjp{
 		if(rjp_value_type(m_value) != rjp_json_string)
 			rjp_set_string(m_value, "", 0);
 	}
-	string_val::string_val(const value& val, const rexy::string_base<char>& i):
+	string_val::string_val(const value& val, rexy::string_view i):
 		value(val)
 	{
-		rjp_set_string(m_value, i.get(), i.length());
+		rjp_set_string(m_value, i.data(), i.length());
 	}
-	string_val::string_val(value&& val, const rexy::string_base<char>& i):
+	string_val::string_val(value&& val, rexy::string_view i):
 		value(std::move(val))
 	{
-		rjp_set_string(m_value, i.get(), i.length());
+		rjp_set_string(m_value, i.data(), i.length());
 	}
 	string_val::string_val(const value& val, string&& i):
 		value(val)
@@ -77,8 +79,8 @@ namespace rjp{
 	string string_val::steal(void){
 		return string(m_value);
 	}
-	void string_val::set(const rexy::string_base<char>& str){
-		rjp_set_string(m_value, str.get(), str.length());
+	void string_val::set(rexy::string_view str){
+		rjp_set_string(m_value, str.data(), str.length());
 	}
 	void string_val::set(string&& str){
 		auto length = str.length();

rjp++/tests/CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.0.2)
 project(rjp++_tests)
 set(INCLUDE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../include)
 include_directories("${INCLUDE_PATH}")
-add_compile_options(-Wall -Wextra -pedantic -std=c++17)
+add_compile_options(-Wall -Wextra -pedantic -std=c++20)
 link_libraries(rjp++ rjp)
 
 if(ENABLE_PROFILING)

rjp++/tests/output.cpp

@@ -3,6 +3,8 @@
 #include <stdio.h>
 #include <string.h>
 
+using namespace rexy::str_literals;
+
 typedef struct{
 	rjp::value (*create)(void);
 	const char* res;
@@ -337,17 +339,17 @@ static test_pair tests[] = {
 int run_test(test_pair* p){
 	rjp::value test = p->create();
 	rjp::string buf = test.to_json(p->fmt);
-	if(!buf){
+	if(buf.empty()){
 		if(!p->res)
 			return 1;
 		return 0;
 	}
-	int retval = !strcmp(buf, p->res);
+	int retval = !strcmp(buf.c_str(), p->res);
 	if(retval){
 		fprintf(stderr, "Success\n");
 	}else{
 		fprintf(stderr, "Failure\n");
-		fprintf(stderr, "Expected: '%s'\nGot:      '%s'\n", p->res, buf.get());
+		fprintf(stderr, "Expected: '%s'\nGot:      '%s'\n", p->res, buf.c_str());
 	}
 	return retval;
 }

rjp++/tests/parse.cpp

@@ -20,7 +20,7 @@ int handle_res(const rjp::parse_res& res){
 	if(res.valid()){
 		fprintf(stderr, "Accepted\n");
 	}else{
-		fprintf(stderr, "%s\n", res.errstr().get());
+		fprintf(stderr, "%s\n", res.errstr().data());
 	}
 	return !res.valid();
 }