rename and restructure

mathisloge · mathisloge · commit 7d99a51d65d3 · 2025-01-11T21:17:06.000+01:00
diff --git a/.clangd b/.clangd
@@ -1,3 +1,3 @@
 CompileFlags:
-  Remove: [-mno-direct-extern-access]
+  Remove: [-mno-direct-extern-access,-fconcepts-diagnostics-depth=*]
   Compiler: clang++
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -59,7 +59,7 @@ feature_summary(WHAT PACKAGES_FOUND DESCRIPTION "Found packages:")
 
 include(CMakePackageConfigHelpers)
 
-install(TARGETS loggerlib quite-studio probe quite_protocol_proto
+install(TARGETS quite_core quite_logger quite-studio probe quite_protocol_proto
     EXPORT quiteTargets
     LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
     ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
diff --git a/libs/CMakeLists.txt b/libs/CMakeLists.txt
@@ -1,4 +1,5 @@
 add_subdirectory(logger)
+add_subdirectory(core)
 add_subdirectory(protocol)
 add_subdirectory(quite)
 add_subdirectory(testing)
diff --git a/libs/core/CMakeLists.txt b/libs/core/CMakeLists.txt
@@ -0,0 +1,25 @@
+add_library(quite_core)
+add_library(quite::core ALIAS quite_core)
+set_target_properties(quite_core PROPERTIES
+    POSITION_INDEPENDENT_CODE ON
+)
+generate_export_header(quite_core)
+
+target_include_directories(quite_core PUBLIC
+    "$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>"
+    "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
+    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+)
+
+target_link_libraries(quite_core PUBLIC
+    fmt::fmt
+    quill::quill
+)
+
+target_sources(quite_core
+    PRIVATE
+        src/core.cpp
+)
+
+install(DIRECTORY include/ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/quite_core_export.h" DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
diff --git a/libs/core/include/quite/meta/meta_registry.hpp b/libs/core/include/quite/meta/meta_registry.hpp
@@ -0,0 +1,9 @@
+#pragma once
+#include "quite_core_export.h"
+
+namespace quite
+{
+class QUITE_CORE_EXPORT MetaRegistry{
+
+};
+}
diff --git a/libs/core/include/quite/meta/meta_types.hpp b/libs/core/include/quite/meta/meta_types.hpp
@@ -24,32 +24,32 @@ struct Method
     std::vector<Property> parameters;
 };
 
-class MetaType
+struct MetaType
 {
-    std::string type_name_;
+    std::string name;
 
-    std::vector<Property> properties_;
-    std::vector<Method> signals_;
-    std::vector<Method> functions_;
+    std::vector<Property> properties;
+    std::vector<Method> signals;
+    std::vector<Method> functions;
 };
 
-class MapType
+struct MapType
 {
-    TypeId key_type_;
-    TypeId value_type_;
+    TypeId key_type;
+    TypeId value_type;
 };
 
-class ListType
+struct ListType
 {
-    TypeId element_type_;
+    TypeId value_type;
 };
 
-class EnumType
+struct EnumType
 {
     using ValueName = std::string;
 
-    std::string type_name_;
-    std::unordered_map<ValueName, std::int64_t> values_;
+    std::string name;
+    std::unordered_map<ValueName, std::int64_t> values;
 };
 
 enum class PrimitiveType
diff --git a/libs/core/src/core.cpp b/libs/core/src/core.cpp
diff --git a/libs/logger/CMakeLists.txt b/libs/logger/CMakeLists.txt
@@ -1,25 +1,25 @@
-add_library(loggerlib)
-add_library(quite::logger ALIAS loggerlib)
-set_target_properties(loggerlib PROPERTIES
+add_library(quite_logger)
+add_library(quite::logger ALIAS quite_logger)
+set_target_properties(quite_logger PROPERTIES
     POSITION_INDEPENDENT_CODE ON
 )
-generate_export_header(loggerlib)
+generate_export_header(quite_logger)
 
-target_include_directories(loggerlib PUBLIC
+target_include_directories(quite_logger PUBLIC
     "$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>"
     "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
     "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
 )
 
-target_link_libraries(loggerlib PUBLIC
+target_link_libraries(quite_logger PUBLIC
     fmt::fmt
     quill::quill
 )
 
-target_sources(loggerlib
+target_sources(quite_logger
     PRIVATE
         src/logger.cpp
 )
 
 install(DIRECTORY include/ DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
-install(FILES "${CMAKE_CURRENT_BINARY_DIR}/loggerlib_export.h" DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/quite_logger_export.h" DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}")
diff --git a/libs/logger/include/quite/logger.hpp b/libs/logger/include/quite/logger.hpp
@@ -1,11 +1,11 @@
 #pragma once
 #include <quill/LogMacros.h>
 #include <quill/Logger.h>
-#include "loggerlib_export.h"
+#include "quite_logger_export.h"
 
 namespace quite
 {
-LOGGERLIB_EXPORT quill::Logger *create_logger(std::string_view logger_name);
+QUITE_LOGGER_EXPORT quill::Logger *create_logger(std::string_view logger_name);
 }
 
 #define DEFINE_LOGGER(name)                                                                                            \
diff --git a/libs/logger/include/quite/setup_logger.hpp b/libs/logger/include/quite/setup_logger.hpp
@@ -1,6 +1,6 @@
 #pragma once
-#include "loggerlib_export.h"
+#include "quite_logger_export.h"
 namespace quite
 {
-LOGGERLIB_EXPORT void setup_logger();
+QUITE_LOGGER_EXPORT void setup_logger();
 }
diff --git a/libs/probeqt/meta_adapter.hpp b/libs/probeqt/meta_adapter.hpp
@@ -0,0 +1,16 @@
+#pragma once
+#include <entt/meta/meta.hpp>
+#include "result.hpp"
+
+namespace quite::probe
+{
+
+class MetaAdapter
+{
+  public:
+    Result<entt::meta_any> search_type_by_qualified_name(std::string_view qualified_type_name);
+    Result<entt::meta_any> invoke_method(const entt::meta_any &object,
+                                         std::string_view qualified_method_signature,
+                                         std::span<entt::meta_any> params) const;
+};
+} // namespace quite::probe
diff --git a/libs/quite/CMakeLists.txt b/libs/quite/CMakeLists.txt
@@ -26,6 +26,7 @@ target_link_libraries(quitelib PRIVATE
     quite::protocol
     quite::logger
 PUBLIC
+    quite::core
     STDEXEC::stdexec
 )
 
diff --git a/libs/quite/include/quite/meta/meta_type_registry.hpp b/libs/quite/include/quite/meta/meta_type_registry.hpp
@@ -1,6 +1,6 @@
 #pragma once
 #include <quite/async_result.hpp>
-#include "meta_types.hpp"
+#include <quite/meta/meta_types.hpp>
 
 namespace quite::meta
 {
diff --git a/libs/quite/src/grpc_impl/meta_service/grpc_meta_type_registry.cpp b/libs/quite/src/grpc_impl/meta_service/grpc_meta_type_registry.cpp
@@ -30,7 +30,7 @@ AsyncResult<meta::Type> GrpcMetaTypeRegistry::resolve_type(std::string_view type
     LOG_DEBUG(grpc_meta_type_registry_logger, "Resolve type for '{}'", type_name);
     const auto meta_obj_response = co_await make_meta_service_get_meta_object(
         probe_service_handle_->context(), probe_service_handle_->meta_service_stub(), type_name);
-    if (meta_obj_response.has_value() and not meta_obj_response->has_meta_type())
+    if (not meta_obj_response.has_value() or not meta_obj_response->has_meta_type())
     {
         co_return std::unexpected(Error{
             .code = ErrorCode::failed_precondition,
@@ -51,4 +51,4 @@ AsyncResult<meta::Type> GrpcMetaTypeRegistry::resolve_type(std::string_view type
     });
 }
 
-} // namespace quite::grpc_impl
+} // namespace quite::grpc_impl
diff --git a/test/quite/CMakeLists.txt b/test/quite/CMakeLists.txt
@@ -17,7 +17,8 @@ catch_discover_tests(api_test)
 
 
 target_sources(api_test PRIVATE
-    process_application.cpp # compile error on gcc-13
-    remote_object_test.cpp
-    image_diff_test.cpp
+    #process_application.cpp # compile error on gcc-13
+    #remote_object_test.cpp
+    #image_diff_test.cpp
+    meta_test.cpp
 )
diff --git a/test/quite/async_test_helper.hpp b/test/quite/async_test_helper.hpp
@@ -0,0 +1,9 @@
+#pragma once
+#include <exec/task.hpp>
+#include <stdexec/execution.hpp>
+
+#define ASYNC_BLOCK stdexec::sync_wait([&]() -> exec::task<void> {
+
+#define ASYNC_BLOCK_END                                                                                                \
+    co_return;                                                                                                         \
+    }());
diff --git a/test/quite/meta_test.cpp b/test/quite/meta_test.cpp
@@ -0,0 +1,32 @@
+#include <asio/co_spawn.hpp>
+#include <asio/detached.hpp>
+#include <asio/steady_timer.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <nlohmann/json.hpp>
+#include <quite/application.hpp>
+#include <quite/asio2exec.hpp>
+#include <quite/logger.hpp>
+#include <quite/property.hpp>
+#include <quite/quite.hpp>
+#include <quite/setup_logger.hpp>
+#include <quite/utils/dump_properties.hpp>
+#include <tester_app.hpp>
+#include "async_test_helper.hpp"
+
+DEFINE_LOGGER(test);
+
+TEST_CASE("Test if a process application can be created")
+{
+    quite::setup_logger();
+
+    ASYNC_BLOCK
+    auto app = quite::Application::CreateApplication(TESTER_APP_PATH);
+
+    const auto myCustomType = co_await app->meta_type_registry().resolve_type("MyCustomType");
+    if (not myCustomType.has_value())
+    {
+        LOG_ERROR(test, "Could not aquire type. Failed with {}", myCustomType.error().message);
+    }
+    REQUIRE(myCustomType.has_value());
+    ASYNC_BLOCK_END
+}
diff --git a/test/quite/process_application.cpp b/test/quite/process_application.cpp
@@ -33,7 +33,6 @@ TEST_CASE("Test if a process application can be created")
             auto snapshot = co_await xxxx.value()->take_snapshot();
             REQUIRE(snapshot.has_value());
         }
-        co_await app->get_views();
 
         auto btn_obj = co_await app->find_object({.properties = {{"objectName", "worldBtn"}}});
         REQUIRE(btn_obj.has_value());
diff --git a/test/simple_tester/CMakeLists.txt b/test/simple_tester/CMakeLists.txt
@@ -13,6 +13,8 @@ qt_add_qml_module(tester
     SOURCES
         MyLogArea.hpp
         MyLogArea.cpp
+        MyCustomType.hpp
+        MyCustomType.cpp
     NO_RESOURCE_TARGET_PATH
     DEPENDENCIES QtQuick
 )
diff --git a/test/simple_tester/MyCustomType.cpp b/test/simple_tester/MyCustomType.cpp
@@ -0,0 +1,6 @@
+#include "MyCustomType.hpp"
+
+double MyCustomType::addition(double a, double b) const
+{
+    return a + b;
+}
diff --git a/test/simple_tester/MyCustomType.hpp b/test/simple_tester/MyCustomType.hpp
@@ -0,0 +1,10 @@
+#pragma once
+#include <QObject>
+
+class MyCustomType : public QObject
+{
+    Q_OBJECT
+
+  public:
+    double addition(double a, double b) const;
+};
diff --git a/test/simple_tester/main.cpp b/test/simple_tester/main.cpp
@@ -3,6 +3,7 @@
 #include <QQuickItem>
 #include <QtQuick/QQuickView>
 #include <quite/probe.hpp>
+#include "MyCustomType.hpp"
 
 int main(int argc, char *argv[])
 {
@@ -15,5 +16,7 @@ int main(int argc, char *argv[])
     view.setSource(QUrl("qrc:///main.qml"));
     view.show();
 
+    MyCustomType my_custom_type_instance;
+
     return QGuiApplication::exec();
 }

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`add_subdirectory(logger)`
	`2`	`+add_subdirectory(core)`
`2`	`3`	`add_subdirectory(protocol)`
`3`	`4`	`add_subdirectory(quite)`
`4`	`5`	`add_subdirectory(testing)`
Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,11 @@`
`1`	`1`	`#pragma once`
`2`	`2`	`#include <quill/LogMacros.h>`
`3`	`3`	`#include <quill/Logger.h>`
`4`		`-#include "loggerlib_export.h"`
	`4`	`+#include "quite_logger_export.h"`
`5`	`5`
`6`	`6`	`namespace quite`
`7`	`7`	`{`
`8`		`-LOGGERLIB_EXPORT quill::Logger *create_logger(std::string_view logger_name);`
	`8`	`+QUITE_LOGGER_EXPORT quill::Logger *create_logger(std::string_view logger_name);`
`9`	`9`	`}`
`10`	`10`
`11`	`11`	`#define DEFINE_LOGGER(name) \`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`#pragma once`
`2`		`-#include "loggerlib_export.h"`
	`2`	`+#include "quite_logger_export.h"`
`3`	`3`	`namespace quite`
`4`	`4`	`{`
`5`		`-LOGGERLIB_EXPORT void setup_logger();`
	`5`	`+QUITE_LOGGER_EXPORT void setup_logger();`
`6`	`6`	`}`