Merge pull request #173 from wravery/type-erasure

Merge work in progress from personal fork to start working on 4.0

Author: wravery

.github/workflows/linux.yml

@@ -3,7 +3,7 @@ name: Linux
 on: [push, pull_request]
 
 jobs:
-  gcc7:
+  gcc10:
     strategy:
       fail-fast: false
       matrix:
@@ -19,7 +19,7 @@ jobs:
     - name: Install Dependencies
       run: |
         sudo apt-get update
-        sudo apt-get install -yq libgtest-dev libboost-program-options-dev rapidjson-dev ninja-build
+        sudo apt-get install -yq libgtest-dev libboost-program-options-dev rapidjson-dev ninja-build gcc-10 g++-10
 
     - name: Build GTest
       run: |
@@ -34,6 +34,9 @@ jobs:
 
     - name: Configure CMake
       shell: pwsh
+      env:
+        CC: gcc-10
+        CXX: g++-10
       working-directory: build/
       run: |
         $cmakeBuildType = '${{ matrix.config }}'

.github/workflows/macos.yml

@@ -9,7 +9,7 @@ jobs:
       matrix:
         config: [Debug, Release]
 
-    runs-on: macos-latest
+    runs-on: macos-11
 
     steps:
     - uses: actions/checkout@v2

CMakeLists.txt

@@ -33,8 +33,6 @@ endif()
 
 project(cppgraphqlgen VERSION ${LATEST_VERSION})
 
-set(CMAKE_CXX_STANDARD 17)
-
 set(GRAPHQL_INSTALL_INCLUDE_DIR include CACHE PATH "Header file install directory")
 set(GRAPHQL_INSTALL_TOOLS_DIR bin CACHE PATH "schemagen install directory")
 set(GRAPHQL_INSTALL_CMAKE_DIR lib/cmake CACHE PATH "CMake config files install directory")

PEGTL

@@ -0,0 +1,59 @@
+// This is a dummy program that just needs to compile and link to tell us if
+// the C++20 coroutine API is available. Use CMake's configure_file command
+// to replace the COROUTINE_HEADER and COROUTINE_NAMESPACE tokens for each
+// combination of headers and namespaces which we want to pass to the CMake
+// try_compile command.
+
+#include <@COROUTINE_HEADER@>
+#include <future>
+
+struct task
+{
+    struct promise_type
+    {
+        task get_return_object() noexcept
+        {
+            return {};
+        }
+
+        @COROUTINE_NAMESPACE@::suspend_never initial_suspend() noexcept
+        {
+            return {};
+        }
+
+        @COROUTINE_NAMESPACE@::suspend_never final_suspend() noexcept
+        {
+            return {};
+        }
+
+        void return_void() noexcept
+        {
+            promise.set_value();
+        }
+
+        void unhandled_exception()
+        {
+            promise.set_exception(std::current_exception());
+        }
+
+        std::promise<void> promise;
+    };
+
+    constexpr bool await_ready() const noexcept
+    {
+        return true;
+    }
+
+    std::future<void> future;
+};
+
+task test_co_return()
+{
+    co_return;
+}
+
+int main()
+{
+    test_co_return().future.get();
+    return 0;
+}

cmake/test_coroutine.cpp.in

@@ -1 +1 @@
-3.6.0
+4.0.0

cmake/version.txt

@@ -34,17 +34,16 @@ schema {
 
 Executing a query or mutation starts by calling `Request::resolve` from [GraphQLService.h](../include/graphqlservice/GraphQLService.h):
 ```cpp
-GRAPHQLSERVICE_EXPORT std::future<response::Value> resolve(
+GRAPHQLSERVICE_EXPORT response::AwaitableValue resolve(
 	const std::shared_ptr<RequestState>& state, peg::ast& query,
 	const std::string& operationName, response::Value&& variables) const;
 ```
-By default, the `std::future` results are resolved on-demand but synchronously,
-using `std::launch::deferred` with the `std::async` function. You can also use
-an override of `Request::resolve` which lets you substitute the
-`std::launch::async` option to begin executing the query on multiple threads
-in parallel:
+By default, the `std::future` results are resolved on-demand but synchronously.
+You can also use an override of `Request::resolve` which lets you substitute
+the `std::launch::async` option to begin executing the query on multiple
+threads in parallel:
 ```cpp
-GRAPHQLSERVICE_EXPORT std::future<response::Value> resolve(std::launch launch,
+GRAPHQLSERVICE_EXPORT response::AwaitableValue resolve(std::launch launch,
 	const std::shared_ptr<RequestState>& state, peg::ast& query,
 	const std::string& operationName, response::Value&& variables) const;
 ```
@@ -70,7 +69,7 @@ recursively call the `resolvers` for each of the `fields` in the nested
 `graphql::today::object::Appointment` object from the `today` sample in
 [AppointmentObject.h](../samples/separate/AppointmentObject.h).
 ```cpp
-std::future<service::ResolverResult> resolveId(service::ResolverParams&& params);
+service::AwaitableResolver resolveId(service::ResolverParams&& params);
 ```
 In this example, the `resolveId` method invokes `getId`:
 ```cpp

doc/resolvers.md

@@ -15,11 +15,11 @@ and `Request::unsubscribe` methods in [GraphQLService.h](../include/graphqlservi
 ```cpp
 GRAPHQLSERVICE_EXPORT SubscriptionKey subscribe(
 	SubscriptionParams&& params, SubscriptionCallback&& callback);
-GRAPHQLSERVICE_EXPORT std::future<SubscriptionKey> subscribe(
+GRAPHQLSERVICE_EXPORT AwaitableSubscribe subscribe(
 	std::launch launch, SubscriptionParams&& params, SubscriptionCallback&& callback);
 
 GRAPHQLSERVICE_EXPORT void unsubscribe(SubscriptionKey key);
-GRAPHQLSERVICE_EXPORT std::future<void> unsubscribe(std::launch launch, SubscriptionKey key);
+GRAPHQLSERVICE_EXPORT AwaitableUnsubscribe unsubscribe(std::launch launch, SubscriptionKey key);
 ```
 You need to fill in a `SubscriptionParams` struct with the [parsed](./parsing.md)
 query and any other relevant operation parameters:
@@ -39,7 +39,7 @@ The `SubscriptionCallback` signature is:
 ```cpp
 // Subscription callbacks receive the response::Value representing the result of evaluating the
 // SelectionSet against the payload.
-using SubscriptionCallback = std::function<void(std::future<response::Value>)>;
+using SubscriptionCallback = std::function<void(response::Value&&)>;
 ```
 
 ## `ResolverContext::NotifySubscribe` and `ResolverContext::NotifyUnsubscribe`
@@ -114,27 +114,25 @@ GRAPHQLSERVICE_EXPORT void deliver(const SubscriptionName& name,
 ```
 
 By default, `deliver` invokes all of the `SubscriptionCallback` listeners with
-`std::future` payloads which are resolved on-demand but synchronously, using
-`std::launch::deferred` with the `std::async` function. There's also a version
-of each overload which  lets you substitute the `std::launch::async` option to
-begin executing the queries and invoke the callbacks on multiple threads in
-parallel:
+`std::future` payloads which are resolved on-demand but synchronously. You can
+also use an override of `Request::resolve` which lets you substitute the
+`std::launch::async` option to begin executing the queries and invoke the
+callbacks on multiple threads in parallel:
 ```cpp
-GRAPHQLSERVICE_EXPORT void deliver(std::launch launch, const SubscriptionName& name,
-	const std::shared_ptr<Object>& subscriptionObject) const;
-GRAPHQLSERVICE_EXPORT void deliver(std::launch launch, const SubscriptionName& name,
-	const SubscriptionArguments& arguments,
-	const std::shared_ptr<Object>& subscriptionObject) const;
-GRAPHQLSERVICE_EXPORT void deliver(std::launch launch, const SubscriptionName& name,
+GRAPHQLSERVICE_EXPORT AwaitableDeliver deliver(std::launch launch, const SubscriptionName& name,
+	std::shared_ptr<Object> subscriptionObject) const;
+GRAPHQLSERVICE_EXPORT AwaitableDeliver deliver(std::launch launch, const SubscriptionName& name,
+	const SubscriptionArguments& arguments, std::shared_ptr<Object> subscriptionObject) const;
+GRAPHQLSERVICE_EXPORT AwaitableDeliver deliver(std::launch launch, const SubscriptionName& name,
 	const SubscriptionArguments& arguments, const SubscriptionArguments& directives,
-	const std::shared_ptr<Object>& subscriptionObject) const;
-GRAPHQLSERVICE_EXPORT void deliver(std::launch launch, const SubscriptionName& name,
+	std::shared_ptr<Object> subscriptionObject) const;
+GRAPHQLSERVICE_EXPORT AwaitableDeliver deliver(std::launch launch, const SubscriptionName& name,
 	const SubscriptionFilterCallback& applyArguments,
-	const std::shared_ptr<Object>& subscriptionObject) const;
-GRAPHQLSERVICE_EXPORT void deliver(std::launch launch, const SubscriptionName& name,
+	std::shared_ptr<Object> subscriptionObject) const;
+GRAPHQLSERVICE_EXPORT AwaitableDeliver deliver(std::launch launch, const SubscriptionName& name,
 	const SubscriptionFilterCallback& applyArguments,
 	const SubscriptionFilterCallback& applyDirectives,
-	const std::shared_ptr<Object>& subscriptionObject) const;
+	std::shared_ptr<Object> subscriptionObject) const;
 ```
 
 ## Handling Multiple Operation Types

doc/subscriptions.md

@@ -42,6 +42,8 @@ class Generator
 	std::string getSourcePath() const noexcept;
 
 	bool outputHeader() const noexcept;
+	void outputObjectStubs(
+		std::ostream& headerFile, const ObjectType& objectType) const;
 	void outputObjectDeclaration(
 		std::ostream& headerFile, const ObjectType& objectType, bool isQueryType) const;
 	std::string getFieldDeclaration(const InputField& inputField) const noexcept;

include/SchemaGenerator.h

@@ -170,7 +170,7 @@ class ValidateVariableTypeVisitor
 class ValidateExecutableVisitor
 {
 public:
-	GRAPHQLSERVICE_EXPORT ValidateExecutableVisitor(const std::shared_ptr<schema::Schema>& schema);
+	GRAPHQLSERVICE_EXPORT ValidateExecutableVisitor(std::shared_ptr<schema::Schema> schema);
 
 	GRAPHQLSERVICE_EXPORT void visit(const peg::ast_node& root);