niansa/llama_nds
1
0
Fork 0
mirror of https://gitlab.com/niansa/llama_nds.git synced 2025-03-06 20:53:28 +01:00
Code Releases Activity

Fixed 'Result' type conflict and added missing include to SingleEvent.cpp

Browse source
This commit is contained in:
niansa 2023-04-07 09:35:13 +02:00
parent 5fca6fa023
commit d76d8ced9b
9 changed files with 33 additions and 31 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
AsyncManager.cpp
View file

@ -102,7 +102,7 @@ void AsyncManager::run() {
// Set futures // Set futures
for (auto& [future, value] : execQueue) { for (auto& [future, value] : execQueue) {
future->set(value?Result::Error:Result::Success); future->set(value?AsyncResult::Error:AsyncResult::Success);
future = nullptr; future = nullptr;
} }

8
AsyncManager.hpp
View file

@ -11,14 +11,14 @@ class Runtime;
enum class Result { enum class AsyncResult {
Error, Error,
Success Success
}; };
class AsyncManager { class AsyncManager {
public: public:
using SockFuture = basiccoro::SingleEvent<Result>; using SockFuture = basiccoro::SingleEvent<AsyncResult>;
using SockFutureUnique = std::unique_ptr<SockFuture>; using SockFutureUnique = std::unique_ptr<SockFuture>;
using SockFutureMap = std::unordered_multimap<int, SockFutureUnique>; using SockFutureMap = std::unordered_multimap<int, SockFutureUnique>;
@ -43,13 +43,13 @@ public:
stopping = true; stopping = true;
} }
basiccoro::AwaitableTask<Result> waitRead(int fd) { basiccoro::AwaitableTask<AsyncResult> waitRead(int fd) {
auto event = std::make_unique<SockFuture>(); auto event = std::make_unique<SockFuture>();
auto eventPtr = event.get(); auto eventPtr = event.get();
sockReads.emplace(fd, std::move(event)); sockReads.emplace(fd, std::move(event));
co_return co_await *eventPtr; co_return co_await *eventPtr;
} }
basiccoro::AwaitableTask<Result> waitWrite(int fd) { basiccoro::AwaitableTask<AsyncResult> waitWrite(int fd) {
auto event = std::make_unique<SockFuture>(); auto event = std::make_unique<SockFuture>();
auto eventPtr = event.get(); auto eventPtr = event.get();
sockWrites.emplace(fd, std::move(event)); sockWrites.emplace(fd, std::move(event));

22
Client.cpp
View file

@ -72,18 +72,18 @@ Client::Client(const std::string& addr, unsigned port, AsyncManager& asyncManage
# endif # endif
} }
basiccoro::AwaitableTask<Result> Client::ask(std::string_view prompt, const std::function<basiccoro::AwaitableTask<void> (unsigned progress)>& on_progress, const std::function<basiccoro::AwaitableTask<void> (std::string_view token)>& on_token) { basiccoro::AwaitableTask<AsyncResult> Client::ask(std::string_view prompt, const std::function<basiccoro::AwaitableTask<void> (unsigned progress)>& on_progress, const std::function<basiccoro::AwaitableTask<void> (std::string_view token)>& on_token) {
std::string fres; std::string fres;
// Send prompt length // Send prompt length
uint8_t len = prompt.length(); uint8_t len = prompt.length();
if (co_await connection->writeObject(len, true) == Result::Error) { if (co_await connection->writeObject(len, true) == AsyncResult::Error) {
co_return Result::Error; co_return AsyncResult::Error;
} }
// Send prompt // Send prompt
if (co_await connection->write(prompt) == Result::Error) { if (co_await connection->write(prompt) == AsyncResult::Error) {
co_return Result::Error; co_return AsyncResult::Error;
} }
// Receive progress // Receive progress
@ -91,8 +91,8 @@ basiccoro::AwaitableTask<Result> Client::ask(std::string_view prompt, const std:
uint8_t progress; uint8_t progress;
// Receive percentage // Receive percentage
if (co_await connection->readObject(progress) == Result::Error) { if (co_await connection->readObject(progress) == AsyncResult::Error) {
co_return Result::Error; co_return AsyncResult::Error;
} }
// Run on_progress callback // Run on_progress callback
@ -105,8 +105,8 @@ basiccoro::AwaitableTask<Result> Client::ask(std::string_view prompt, const std:
// Receive response // Receive response
for (;;) { for (;;) {
// Receive response length // Receive response length
if (co_await connection->readObject(len) == Result::Error) { if (co_await connection->readObject(len) == AsyncResult::Error) {
co_return Result::Error; co_return AsyncResult::Error;
} }
// End if zero // End if zero
@ -118,7 +118,7 @@ basiccoro::AwaitableTask<Result> Client::ask(std::string_view prompt, const std:
// Receive response // Receive response
const auto token = co_await connection->read(len); const auto token = co_await connection->read(len);
if (token.empty()) { if (token.empty()) {
co_return Result::Error; co_return AsyncResult::Error;
} }
// Run on_token callback // Run on_token callback
@ -126,5 +126,5 @@ basiccoro::AwaitableTask<Result> Client::ask(std::string_view prompt, const std:
} }
// No error // No error
co_return Result::Success; co_return AsyncResult::Success;
} }

2
Client.hpp
View file

@ -43,7 +43,7 @@ class Client
public: public:
Client(const std::string &addr, unsigned port, AsyncManager& asyncManager); Client(const std::string &addr, unsigned port, AsyncManager& asyncManager);
basiccoro::AwaitableTask<Result> ask(std::string_view prompt, const std::function<basiccoro::AwaitableTask<void> (unsigned progress)>& on_progress, const std::function<basiccoro::AwaitableTask<void> (std::string_view token)>& on_token); basiccoro::AwaitableTask<AsyncResult> ask(std::string_view prompt, const std::function<basiccoro::AwaitableTask<void> (unsigned progress)>& on_progress, const std::function<basiccoro::AwaitableTask<void> (std::string_view token)>& on_token);
}; };
#endif // CLIENT_HPP #endif // CLIENT_HPP

12
Receiver.cpp
View file

@ -21,27 +21,27 @@ basiccoro::AwaitableTask<std::string> Receiver::Simple::read(size_t amount) {
// Return final buffer // Return final buffer
co_return fres; co_return fres;
} }
basiccoro::AwaitableTask<Result> Receiver::Simple::read(std::byte *buffer, size_t size) { basiccoro::AwaitableTask<AsyncResult> Receiver::Simple::read(std::byte *buffer, size_t size) {
size_t allBytesRead = 0; size_t allBytesRead = 0;
while (allBytesRead != size) { while (allBytesRead != size) {
// Wait for data // Wait for data
if (co_await aMan.waitRead(fd) == Result::Error) [[unlikely]] { if (co_await aMan.waitRead(fd) == AsyncResult::Error) [[unlikely]] {
// Error // Error
co_return Result::Error; co_return AsyncResult::Error;
} }
// Receive data // Receive data
ssize_t bytesRead; ssize_t bytesRead;
if ((bytesRead = recv(fd, reinterpret_cast<char*>(buffer+allBytesRead), size-allBytesRead, 0)) < 0) [[unlikely]] { if ((bytesRead = recv(fd, reinterpret_cast<char*>(buffer+allBytesRead), size-allBytesRead, 0)) < 0) [[unlikely]] {
// Error // Error
co_return Result::Error; co_return AsyncResult::Error;
} }
allBytesRead += bytesRead; allBytesRead += bytesRead;
} }
// No error // No error
co_return Result::Success; co_return AsyncResult::Success;
} }
basiccoro::AwaitableTask<std::string> Receiver::Simple::readSome(size_t max) { basiccoro::AwaitableTask<std::string> Receiver::Simple::readSome(size_t max) {
@ -50,7 +50,7 @@ basiccoro::AwaitableTask<std::string> Receiver::Simple::readSome(size_t max) {
fres.resize(max); fres.resize(max);
// Wait for data // Wait for data
if (co_await aMan.waitRead(fd) == Result::Error) [[unlikely]] { if (co_await aMan.waitRead(fd) == AsyncResult::Error) [[unlikely]] {
co_return ""; co_return "";
} }

2
Receiver.hpp
View file

@ -21,7 +21,7 @@ public:
// Reads the exact amount of bytes given // Reads the exact amount of bytes given
basiccoro::AwaitableTask<std::string> read(size_t amount); basiccoro::AwaitableTask<std::string> read(size_t amount);
basiccoro::AwaitableTask<Result> read(std::byte *buffer, size_t size); basiccoro::AwaitableTask<AsyncResult> read(std::byte *buffer, size_t size);
// Reads at max. the amount of bytes given // Reads at max. the amount of bytes given
basiccoro::AwaitableTask<std::string> readSome(size_t max); basiccoro::AwaitableTask<std::string> readSome(size_t max);

10
Sender.cpp
View file

@ -12,18 +12,18 @@
basiccoro::AwaitableTask<Result> Sender::Simple::write(std::string_view str, bool moreData) { basiccoro::AwaitableTask<AsyncResult> Sender::Simple::write(std::string_view str, bool moreData) {
co_return co_await this->write(reinterpret_cast<const std::byte*>(str.data()), str.size(), moreData); co_return co_await this->write(reinterpret_cast<const std::byte*>(str.data()), str.size(), moreData);
} }
basiccoro::AwaitableTask<Result> Sender::Simple::write(const std::byte *data, size_t size, bool moreData) { basiccoro::AwaitableTask<AsyncResult> Sender::Simple::write(const std::byte *data, size_t size, bool moreData) {
std::string fres; std::string fres;
// Wait for socket to get ready for writing // Wait for socket to get ready for writing
if (co_await aMan.waitWrite(fd) == Result::Error) [[unlikely]] { if (co_await aMan.waitWrite(fd) == AsyncResult::Error) [[unlikely]] {
co_return Result::Error; co_return AsyncResult::Error;
} }
// Write // Write
co_return (send(fd, reinterpret_cast<const char*>(data), size, MSG_FLAGS_OR_ZERO(MSG_NOSIGNAL | (int(moreData)*MSG_MORE))) < 0)?Result::Error:Result::Success; co_return (send(fd, reinterpret_cast<const char*>(data), size, MSG_FLAGS_OR_ZERO(MSG_NOSIGNAL | (int(moreData)*MSG_MORE))) < 0)?AsyncResult::Error:AsyncResult::Success;
} }

4
Sender.hpp
View file

@ -18,8 +18,8 @@ protected:
public: public:
Simple(AsyncManager& asyncManager, int fd) : aMan(asyncManager), fd(fd) {} Simple(AsyncManager& asyncManager, int fd) : aMan(asyncManager), fd(fd) {}
basiccoro::AwaitableTask<Result> write(std::string_view, bool moreData = false); basiccoro::AwaitableTask<AsyncResult> write(std::string_view, bool moreData = false);
basiccoro::AwaitableTask<Result> write(const std::byte *data, size_t, bool moreData = false); basiccoro::AwaitableTask<AsyncResult> write(const std::byte *data, size_t, bool moreData = false);
template<typename T> template<typename T>
auto writeObject(const T& o, bool moreData = false) { auto writeObject(const T& o, bool moreData = false) {

2
basic-coro/SingleEvent.cpp
View file

@ -1,5 +1,7 @@
#include "SingleEvent.hpp" #include "SingleEvent.hpp"
#include <utility>
namespace basiccoro namespace basiccoro
{ {