ZScript DAP Debug server (#3009)
* Add STL-standard type traits and functions to TMap to enable for loop iteration * add third-party range-map library I have e-mailed the author for clarifcation on the license, will update this when they respond * vcpkg: Add cppdap and eventpp libraries, update baseline * DAP implementation * Add `FileSystem::FileHash()` to get the CRC32 hash * add `starting_offset` param to `VMDisasm()` for debugger disassembly view Defaults to `0`, should not change output if it's not set * Add `VMFrameStack::HasFrames()` to prevent assertions when inspecting in the debugger * Add `PC` field to VMFrame, ensure that it is updated whenever vm increments/decrements the pc Does not change alignment, the offsets used in VMFrame still work We need this for the debugger because we otherwise have no way to get the pc; it was a local in `ExecScriptFunc()` * `ZCCCompiler::CreateClassTypes()`: ensure SourceLumpName is set for classes derived from non-native classes * start debug server in d_main, add `vm_debug` cvars and `-debug` CLI arg * Add documentation for `vm_debug` cvars * vm_exec: Add debugger hooks for instruction execution events * c_console: Add debugger hooks for logging events in `PrintString` * add `.cache/` to gitignore * vendor cppdap on main @ 6464cd7 Patches: removed .gitmodules (submodules were thirdparty/json, thirdparty/googletest) removed thirdparty/googletest, not needed removed thirdparty/json/docs, thirdparty/json/test, thirdparty/json/benchmarks to prevent massive bloat * vendor eventpp on master @ 1224dd6 * build: use internal cppdap and eventpp by default * dap: fix Binary::GetFunctionLineRange() * fix bug in range_map::find_ranges * make Binary dap::Source dynamic * cache source code upon retrieval * refactor Binary into a class, cleanup PexCache * fix ending session gracefully * d_main: Stop debug server in D_Cleanup() * Fix connecting to debugger when session already started * cleanup unused stuff in ZScriptDebugger * always send TerminateEvents on disconnect if initialized * tweak color display * Don't cache disassembly lines when scanning scripts * Cache nodes when getting runtime state * WIP display locals * Fix display of static arrays * Ensure names display in proper order * dap: Fix struct locals display, add args display * Support `start` parameter * Support `filter` parameter * remove struct unbound native data display Practically useless for debugging zscript and didn't work properly anyway * d_main: fix vm_jit and vm_jit not being disabled soon enough * support breaking on abort exceptions * dap: refactor game event emitter functions into seperate header * dap: show native functions on stack * dap: Remove "Native" from exception handling, simplify exception event emit * dap: add instruction breakpoints * dap: fix display of locals not in scope yet * dap: Make disassembly view display invalid instructions for non-code addresses * dap: remove dot initializers * dap: fix local structs in scope * dap: don't parse the non-used options in the launch/attach requests * dap: fix local struct view * dap: Fix displaying objects that aren't their actual types * dap: Fix action and state handling * dap: stack display view * dap: fix object display view * d_dehacked: set qualified name in addition to the printable name * dap: fix displaying breakpoint errors when script isn't loaded * dap: remove debug print * dap: Display parameter names * dap: Turn down verbosity of logging * dap: fix disassembly view * dap: fix performance problems with arrays * c_console: emit event only if not PRINT_NODAPEVENT * dap: improve logging * dap: update upstream cppdap library to fix deadlocks on no bind * dap: Fix ending session on client socket closed * dap: prevent DebugServer.h from pulling in `dap` and `ZScriptDebugger.h` * dap: fix pause event not being emitted on pause * dap: remove eventpp emitters, way too slow * Remove eventpp dependency * dap: Display correct register names * dap: Show special inits in registers * dap: Add stack offset to VMLocalVariable * dap: fix display of static arrays and local variables on stack vs. registers * dap: fix displaying function pointers * dap: tweak color display * dap: fix scalar display < 4 * dap: add Globals display to debugger * dap: unify methods to get vmvalue * dap: rename free method to freeValue to avoid running afoul of macro defs * fix windows builds * fix compile on linux * cleanup * Fix display of function breakpoints * dap: Don't send back binary files * dap: include sbarinfo in script types (no debug support for anything but zscript yet, this is just for returning source info) * dap: don't show ending session message unless initialized * fix erroneous commit * dap: handle evaluate requests * Fix getting bitfield values * Add CVars Scope and evaluation * add running console commands from repl * dap: disable commands via repl for now * fix loading functions DECORATE scripts * Add source information to Dehacked VM functions, add debugging support * dap: cleanup * fix resolving archive paths * don't send source back on native stack frames * handle `modules` request * cleanup * allow evaluating cvars on hover * fix oob bpinfos * fix restarting the game blowing out the debug server * dap: process input events while paused to prevent deadlocks * fix getting local state * dap: fix LocalState alignment * dap: fix DumpStateHelper * update cppdap protocol version to 1.68.0 * remove cppdap from vcpkg deps We can't use the upstream version anyway because the maintainers are not merging our patches * dap: make named variable nodes derive from the same class * dap: make cvar scope available in native stack frames * handle local variables with conflicting names * add I_GetWindowEvent() to win32 to only process window events when debugging is paused * dap: fix evaluate * dap: fix display of `out` variables
This commit is contained in:
Nikita
GitHub
parent
fcf529590f
commit
45ac7c1d9e
235 changed files with 83166 additions and 62 deletions
262
libraries/cppdap/src/any_test.cpp
Normal file
262
libraries/cppdap/src/any_test.cpp
Normal file
|
|
@ -0,0 +1,262 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "dap/any.h"
|
||||
#include "dap/typeof.h"
|
||||
#include "dap/types.h"
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
namespace dap {
|
||||
|
||||
struct AnyTestObject {
|
||||
dap::integer i;
|
||||
dap::number n;
|
||||
};
|
||||
|
||||
DAP_STRUCT_TYPEINFO(AnyTestObject,
|
||||
"AnyTestObject",
|
||||
DAP_FIELD(i, "i"),
|
||||
DAP_FIELD(n, "n"));
|
||||
|
||||
inline bool operator==(const AnyTestObject& a, const AnyTestObject& b) {
|
||||
return a.i == b.i && a.n == b.n;
|
||||
}
|
||||
|
||||
} // namespace dap
|
||||
|
||||
namespace {
|
||||
|
||||
template <typename T>
|
||||
struct TestValue {};
|
||||
|
||||
template <>
|
||||
struct TestValue<dap::null> {
|
||||
static const dap::null value;
|
||||
};
|
||||
template <>
|
||||
struct TestValue<dap::integer> {
|
||||
static const dap::integer value;
|
||||
};
|
||||
template <>
|
||||
struct TestValue<dap::boolean> {
|
||||
static const dap::boolean value;
|
||||
};
|
||||
template <>
|
||||
struct TestValue<dap::number> {
|
||||
static const dap::number value;
|
||||
};
|
||||
template <>
|
||||
struct TestValue<dap::string> {
|
||||
static const dap::string value;
|
||||
};
|
||||
template <>
|
||||
struct TestValue<dap::array<dap::string>> {
|
||||
static const dap::array<dap::string> value;
|
||||
};
|
||||
template <>
|
||||
struct TestValue<dap::AnyTestObject> {
|
||||
static const dap::AnyTestObject value;
|
||||
};
|
||||
|
||||
const dap::null TestValue<dap::null>::value = nullptr;
|
||||
const dap::integer TestValue<dap::integer>::value = 20;
|
||||
const dap::boolean TestValue<dap::boolean>::value = true;
|
||||
const dap::number TestValue<dap::number>::value = 123.45;
|
||||
const dap::string TestValue<dap::string>::value = "hello world";
|
||||
const dap::array<dap::string> TestValue<dap::array<dap::string>>::value = {
|
||||
"one", "two", "three"};
|
||||
const dap::AnyTestObject TestValue<dap::AnyTestObject>::value = {10, 20.30};
|
||||
|
||||
} // namespace
|
||||
|
||||
TEST(Any, EmptyConstruct) {
|
||||
dap::any any;
|
||||
ASSERT_TRUE(any.is<dap::null>());
|
||||
ASSERT_FALSE(any.is<dap::boolean>());
|
||||
ASSERT_FALSE(any.is<dap::integer>());
|
||||
ASSERT_FALSE(any.is<dap::number>());
|
||||
ASSERT_FALSE(any.is<dap::object>());
|
||||
ASSERT_FALSE(any.is<dap::string>());
|
||||
ASSERT_FALSE(any.is<dap::array<dap::integer>>());
|
||||
ASSERT_FALSE(any.is<dap::AnyTestObject>());
|
||||
}
|
||||
|
||||
TEST(Any, Boolean) {
|
||||
dap::any any(dap::boolean(true));
|
||||
ASSERT_TRUE(any.is<dap::boolean>());
|
||||
ASSERT_EQ(any.get<dap::boolean>(), dap::boolean(true));
|
||||
}
|
||||
|
||||
TEST(Any, Integer) {
|
||||
dap::any any(dap::integer(10));
|
||||
ASSERT_TRUE(any.is<dap::integer>());
|
||||
ASSERT_EQ(any.get<dap::integer>(), dap::integer(10));
|
||||
}
|
||||
|
||||
TEST(Any, Number) {
|
||||
dap::any any(dap::number(123.0f));
|
||||
ASSERT_TRUE(any.is<dap::number>());
|
||||
ASSERT_EQ(any.get<dap::number>(), dap::number(123.0f));
|
||||
}
|
||||
|
||||
TEST(Any, String) {
|
||||
dap::any any(dap::string("hello world"));
|
||||
ASSERT_TRUE(any.is<dap::string>());
|
||||
ASSERT_EQ(any.get<dap::string>(), dap::string("hello world"));
|
||||
}
|
||||
|
||||
TEST(Any, Array) {
|
||||
using array = dap::array<dap::integer>;
|
||||
dap::any any(array({10, 20, 30}));
|
||||
ASSERT_TRUE(any.is<array>());
|
||||
ASSERT_EQ(any.get<array>(), array({10, 20, 30}));
|
||||
}
|
||||
|
||||
TEST(Any, Object) {
|
||||
dap::object o;
|
||||
o["one"] = dap::integer(1);
|
||||
o["two"] = dap::integer(2);
|
||||
o["three"] = dap::integer(3);
|
||||
dap::any any(o);
|
||||
ASSERT_TRUE(any.is<dap::object>());
|
||||
if (any.is<dap::object>()) {
|
||||
auto got = any.get<dap::object>();
|
||||
ASSERT_EQ(got.size(), 3U);
|
||||
ASSERT_EQ(got.count("one"), 1U);
|
||||
ASSERT_EQ(got.count("two"), 1U);
|
||||
ASSERT_EQ(got.count("three"), 1U);
|
||||
ASSERT_TRUE(got["one"].is<dap::integer>());
|
||||
ASSERT_TRUE(got["two"].is<dap::integer>());
|
||||
ASSERT_TRUE(got["three"].is<dap::integer>());
|
||||
ASSERT_EQ(got["one"].get<dap::integer>(), dap::integer(1));
|
||||
ASSERT_EQ(got["two"].get<dap::integer>(), dap::integer(2));
|
||||
ASSERT_EQ(got["three"].get<dap::integer>(), dap::integer(3));
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Any, TestObject) {
|
||||
dap::any any(dap::AnyTestObject{5, 3.0});
|
||||
ASSERT_TRUE(any.is<dap::AnyTestObject>());
|
||||
ASSERT_EQ(any.get<dap::AnyTestObject>().i, 5);
|
||||
ASSERT_EQ(any.get<dap::AnyTestObject>().n, 3.0);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
class AnyT : public ::testing::Test {
|
||||
protected:
|
||||
template <typename T0,
|
||||
typename = std::enable_if<std::is_same<T, T0>::value &&
|
||||
!std::is_same<T0, dap::null>::value>>
|
||||
void check_val(const dap::any& any, const T0& expect) {
|
||||
ASSERT_EQ(any.is<T>(), any.is<T0>());
|
||||
ASSERT_EQ(any.get<T>(), expect);
|
||||
}
|
||||
|
||||
// Special case for Null assignment, as we can assign nullptr_t to any but
|
||||
// can't `get()` it
|
||||
template <typename = dap::null>
|
||||
void check_val(const dap::any& any, const dap::null& expect) {
|
||||
ASSERT_EQ(nullptr, expect);
|
||||
ASSERT_TRUE(any.is<dap::null>());
|
||||
}
|
||||
|
||||
void check_type(const dap::any& any) {
|
||||
ASSERT_EQ(any.is<dap::null>(), (std::is_same<T, dap::null>::value));
|
||||
ASSERT_EQ(any.is<dap::integer>(), (std::is_same<T, dap::integer>::value));
|
||||
ASSERT_EQ(any.is<dap::boolean>(), (std::is_same<T, dap::boolean>::value));
|
||||
ASSERT_EQ(any.is<dap::number>(), (std::is_same<T, dap::number>::value));
|
||||
ASSERT_EQ(any.is<dap::string>(), (std::is_same<T, dap::string>::value));
|
||||
ASSERT_EQ(any.is<dap::array<dap::string>>(),
|
||||
(std::is_same<T, dap::array<dap::string>>::value));
|
||||
ASSERT_EQ(any.is<dap::AnyTestObject>(),
|
||||
(std::is_same<T, dap::AnyTestObject>::value));
|
||||
}
|
||||
};
|
||||
TYPED_TEST_SUITE_P(AnyT);
|
||||
|
||||
TYPED_TEST_P(AnyT, CopyConstruct) {
|
||||
auto val = TestValue<TypeParam>::value;
|
||||
dap::any any(val);
|
||||
this->check_type(any);
|
||||
this->check_val(any, val);
|
||||
}
|
||||
|
||||
TYPED_TEST_P(AnyT, MoveConstruct) {
|
||||
auto val = TestValue<TypeParam>::value;
|
||||
dap::any any(std::move(val));
|
||||
this->check_type(any);
|
||||
this->check_val(any, val);
|
||||
}
|
||||
|
||||
TYPED_TEST_P(AnyT, Assign) {
|
||||
auto val = TestValue<TypeParam>::value;
|
||||
dap::any any;
|
||||
any = val;
|
||||
this->check_type(any);
|
||||
this->check_val(any, val);
|
||||
}
|
||||
|
||||
TYPED_TEST_P(AnyT, MoveAssign) {
|
||||
auto val = TestValue<TypeParam>::value;
|
||||
dap::any any;
|
||||
any = std::move(val);
|
||||
this->check_type(any);
|
||||
this->check_val(any, val);
|
||||
}
|
||||
|
||||
TYPED_TEST_P(AnyT, RepeatedAssign) {
|
||||
dap::string str = "hello world";
|
||||
auto val = TestValue<TypeParam>::value;
|
||||
dap::any any;
|
||||
any = str;
|
||||
any = val;
|
||||
this->check_type(any);
|
||||
this->check_val(any, val);
|
||||
}
|
||||
|
||||
TYPED_TEST_P(AnyT, RepeatedMoveAssign) {
|
||||
dap::string str = "hello world";
|
||||
auto val = TestValue<TypeParam>::value;
|
||||
dap::any any;
|
||||
any = std::move(str);
|
||||
any = std::move(val);
|
||||
this->check_type(any);
|
||||
this->check_val(any, val);
|
||||
}
|
||||
|
||||
REGISTER_TYPED_TEST_SUITE_P(AnyT,
|
||||
CopyConstruct,
|
||||
MoveConstruct,
|
||||
Assign,
|
||||
MoveAssign,
|
||||
RepeatedAssign,
|
||||
RepeatedMoveAssign);
|
||||
|
||||
using AnyTypes = ::testing::Types<dap::null,
|
||||
dap::integer,
|
||||
dap::boolean,
|
||||
dap::number,
|
||||
dap::string,
|
||||
dap::array<dap::string>,
|
||||
dap::AnyTestObject>;
|
||||
INSTANTIATE_TYPED_TEST_SUITE_P(T, AnyT, AnyTypes);
|
||||
|
||||
TEST(Any, Reset) {
|
||||
dap::any any(dap::integer(10));
|
||||
ASSERT_TRUE(any.is<dap::integer>());
|
||||
any.reset();
|
||||
ASSERT_FALSE(any.is<dap::integer>());
|
||||
}
|
||||
90
libraries/cppdap/src/chan.h
Normal file
90
libraries/cppdap/src/chan.h
Normal file
|
|
@ -0,0 +1,90 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifndef dap_chan_h
|
||||
#define dap_chan_h
|
||||
|
||||
#include "dap/optional.h"
|
||||
|
||||
#include <condition_variable>
|
||||
#include <mutex>
|
||||
#include <queue>
|
||||
|
||||
namespace dap {
|
||||
|
||||
template <typename T>
|
||||
struct Chan {
|
||||
public:
|
||||
void reset();
|
||||
void close();
|
||||
optional<T> take();
|
||||
void put(T&& in);
|
||||
void put(const T& in);
|
||||
|
||||
private:
|
||||
bool closed = false;
|
||||
std::queue<T> queue;
|
||||
std::condition_variable cv;
|
||||
std::mutex mutex;
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
void Chan<T>::reset() {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
queue = {};
|
||||
closed = false;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void Chan<T>::close() {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
closed = true;
|
||||
cv.notify_all();
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
optional<T> Chan<T>::take() {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
cv.wait(lock, [&] { return queue.size() > 0 || closed; });
|
||||
if (queue.size() == 0) {
|
||||
return optional<T>();
|
||||
}
|
||||
auto out = std::move(queue.front());
|
||||
queue.pop();
|
||||
return optional<T>(std::move(out));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void Chan<T>::put(T&& in) {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
auto notify = queue.size() == 0 && !closed;
|
||||
queue.push(std::move(in));
|
||||
if (notify) {
|
||||
cv.notify_all();
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void Chan<T>::put(const T& in) {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
auto notify = queue.size() == 0 && !closed;
|
||||
queue.push(in);
|
||||
if (notify) {
|
||||
cv.notify_all();
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace dap
|
||||
|
||||
#endif // dap_chan_h
|
||||
35
libraries/cppdap/src/chan_test.cpp
Normal file
35
libraries/cppdap/src/chan_test.cpp
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "chan.h"
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include <thread>
|
||||
|
||||
TEST(ChanTest, PutTakeClose) {
|
||||
dap::Chan<int> chan;
|
||||
auto thread = std::thread([&] {
|
||||
chan.put(10);
|
||||
chan.put(20);
|
||||
chan.put(30);
|
||||
chan.close();
|
||||
});
|
||||
EXPECT_EQ(chan.take(), dap::optional<int>(10));
|
||||
EXPECT_EQ(chan.take(), dap::optional<int>(20));
|
||||
EXPECT_EQ(chan.take(), dap::optional<int>(30));
|
||||
EXPECT_EQ(chan.take(), dap::optional<int>());
|
||||
thread.join();
|
||||
}
|
||||
198
libraries/cppdap/src/content_stream.cpp
Normal file
198
libraries/cppdap/src/content_stream.cpp
Normal file
|
|
@ -0,0 +1,198 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "content_stream.h"
|
||||
|
||||
#include "dap/io.h"
|
||||
|
||||
#include <string.h> // strlen
|
||||
#include <algorithm> // std::min
|
||||
|
||||
namespace dap {
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// ContentReader
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
ContentReader::ContentReader(
|
||||
const std::shared_ptr<Reader>& reader,
|
||||
OnInvalidData on_invalid_data /* = OnInvalidData::kIgnore */)
|
||||
: reader(reader), on_invalid_data(on_invalid_data) {}
|
||||
|
||||
ContentReader& ContentReader::operator=(ContentReader&& rhs) noexcept {
|
||||
buf = std::move(rhs.buf);
|
||||
reader = std::move(rhs.reader);
|
||||
on_invalid_data = std::move(rhs.on_invalid_data);
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool ContentReader::isOpen() {
|
||||
return reader ? reader->isOpen() : false;
|
||||
}
|
||||
|
||||
void ContentReader::close() {
|
||||
if (reader) {
|
||||
reader->close();
|
||||
}
|
||||
}
|
||||
|
||||
std::string ContentReader::read() {
|
||||
// Find Content-Length header prefix
|
||||
if (on_invalid_data == kClose) {
|
||||
if (!match("Content-Length:")) {
|
||||
return badHeader();
|
||||
}
|
||||
} else {
|
||||
if (!scan("Content-Length:")) {
|
||||
return "";
|
||||
}
|
||||
}
|
||||
// Skip whitespace and tabs
|
||||
while (matchAny(" \t")) {
|
||||
}
|
||||
// Parse length
|
||||
size_t len = 0;
|
||||
while (true) {
|
||||
auto c = matchAny("0123456789");
|
||||
if (c == 0) {
|
||||
break;
|
||||
}
|
||||
len *= 10;
|
||||
len += size_t(c) - size_t('0');
|
||||
}
|
||||
if (len == 0) {
|
||||
return "";
|
||||
}
|
||||
|
||||
// Expect \r\n\r\n
|
||||
if (!match("\r\n\r\n")) {
|
||||
return badHeader();
|
||||
}
|
||||
|
||||
// Read message
|
||||
if (!buffer(len)) {
|
||||
return "";
|
||||
}
|
||||
std::string out;
|
||||
out.reserve(len);
|
||||
for (size_t i = 0; i < len; i++) {
|
||||
out.push_back(static_cast<char>(buf.front()));
|
||||
buf.pop_front();
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
bool ContentReader::scan(const uint8_t* seq, size_t len) {
|
||||
while (buffer(len)) {
|
||||
if (match(seq, len)) {
|
||||
return true;
|
||||
}
|
||||
buf.pop_front();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ContentReader::scan(const char* str) {
|
||||
auto len = strlen(str);
|
||||
return scan(reinterpret_cast<const uint8_t*>(str), len);
|
||||
}
|
||||
|
||||
bool ContentReader::match(const uint8_t* seq, size_t len) {
|
||||
if (!buffer(len)) {
|
||||
return false;
|
||||
}
|
||||
auto it = buf.begin();
|
||||
for (size_t i = 0; i < len; i++, it++) {
|
||||
if (*it != seq[i]) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
for (size_t i = 0; i < len; i++) {
|
||||
buf.pop_front();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ContentReader::match(const char* str) {
|
||||
auto len = strlen(str);
|
||||
return match(reinterpret_cast<const uint8_t*>(str), len);
|
||||
}
|
||||
|
||||
char ContentReader::matchAny(const char* chars) {
|
||||
if (!buffer(1)) {
|
||||
return false;
|
||||
}
|
||||
int c = buf.front();
|
||||
if (auto p = strchr(chars, c)) {
|
||||
buf.pop_front();
|
||||
return *p;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool ContentReader::buffer(size_t bytes) {
|
||||
if (bytes < buf.size()) {
|
||||
return true;
|
||||
}
|
||||
bytes -= buf.size();
|
||||
while (bytes > 0) {
|
||||
uint8_t chunk[256];
|
||||
auto numWant = std::min(sizeof(chunk), bytes);
|
||||
auto numGot = reader->read(chunk, numWant);
|
||||
if (numGot == 0) {
|
||||
return false;
|
||||
}
|
||||
for (size_t i = 0; i < numGot; i++) {
|
||||
buf.push_back(chunk[i]);
|
||||
}
|
||||
bytes -= numGot;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
std::string ContentReader::badHeader() {
|
||||
if (on_invalid_data == kClose) {
|
||||
close();
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// ContentWriter
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
ContentWriter::ContentWriter(const std::shared_ptr<Writer>& rhs)
|
||||
: writer(rhs) {}
|
||||
|
||||
ContentWriter& ContentWriter::operator=(ContentWriter&& rhs) noexcept {
|
||||
writer = std::move(rhs.writer);
|
||||
return *this;
|
||||
}
|
||||
|
||||
bool ContentWriter::isOpen() {
|
||||
return writer ? writer->isOpen() : false;
|
||||
}
|
||||
|
||||
void ContentWriter::close() {
|
||||
if (writer) {
|
||||
writer->close();
|
||||
}
|
||||
}
|
||||
|
||||
bool ContentWriter::write(const std::string& msg) const {
|
||||
auto header =
|
||||
std::string("Content-Length: ") + std::to_string(msg.size()) + "\r\n\r\n";
|
||||
return writer->write(header.data(), header.size()) &&
|
||||
writer->write(msg.data(), msg.size());
|
||||
}
|
||||
|
||||
} // namespace dap
|
||||
73
libraries/cppdap/src/content_stream.h
Normal file
73
libraries/cppdap/src/content_stream.h
Normal file
|
|
@ -0,0 +1,73 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifndef dap_content_stream_h
|
||||
#define dap_content_stream_h
|
||||
|
||||
#include <deque>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#include "dap/session.h"
|
||||
|
||||
namespace dap {
|
||||
|
||||
// Forward declarations
|
||||
class Reader;
|
||||
class Writer;
|
||||
|
||||
class ContentReader {
|
||||
public:
|
||||
ContentReader() = default;
|
||||
ContentReader(const std::shared_ptr<Reader>&,
|
||||
const OnInvalidData on_invalid_data = kIgnore);
|
||||
ContentReader& operator=(ContentReader&&) noexcept;
|
||||
|
||||
bool isOpen();
|
||||
void close();
|
||||
std::string read();
|
||||
|
||||
private:
|
||||
bool scan(const uint8_t* seq, size_t len);
|
||||
bool scan(const char* str);
|
||||
bool match(const uint8_t* seq, size_t len);
|
||||
bool match(const char* str);
|
||||
char matchAny(const char* chars);
|
||||
bool buffer(size_t bytes);
|
||||
std::string badHeader();
|
||||
|
||||
std::shared_ptr<Reader> reader;
|
||||
std::deque<uint8_t> buf;
|
||||
OnInvalidData on_invalid_data;
|
||||
};
|
||||
|
||||
class ContentWriter {
|
||||
public:
|
||||
ContentWriter() = default;
|
||||
ContentWriter(const std::shared_ptr<Writer>&);
|
||||
ContentWriter& operator=(ContentWriter&&) noexcept;
|
||||
|
||||
bool isOpen();
|
||||
void close();
|
||||
bool write(const std::string&) const;
|
||||
|
||||
private:
|
||||
std::shared_ptr<Writer> writer;
|
||||
};
|
||||
|
||||
} // namespace dap
|
||||
|
||||
#endif // dap_content_stream_h
|
||||
126
libraries/cppdap/src/content_stream_test.cpp
Normal file
126
libraries/cppdap/src/content_stream_test.cpp
Normal file
|
|
@ -0,0 +1,126 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "content_stream.h"
|
||||
|
||||
#include "string_buffer.h"
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include <memory>
|
||||
|
||||
namespace {
|
||||
|
||||
// SingleByteReader wraps a dap::Reader to only provide a single byte for each
|
||||
// read() call, regardless of the number of bytes actually requested.
|
||||
class SingleByteReader : public dap::Reader {
|
||||
public:
|
||||
SingleByteReader(std::unique_ptr<dap::Reader>&& inner)
|
||||
: inner(std::move(inner)) {}
|
||||
|
||||
bool isOpen() override { return inner->isOpen(); }
|
||||
void close() override { return inner->close(); }
|
||||
size_t read(void* buffer, size_t) override { return inner->read(buffer, 1); };
|
||||
|
||||
private:
|
||||
std::unique_ptr<dap::Reader> inner;
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
TEST(ContentStreamTest, Write) {
|
||||
auto sb = dap::StringBuffer::create();
|
||||
auto ptr = sb.get();
|
||||
dap::ContentWriter cw(std::move(sb));
|
||||
cw.write("Content payload number one");
|
||||
cw.write("Content payload number two");
|
||||
cw.write("Content payload number three");
|
||||
ASSERT_EQ(ptr->string(),
|
||||
"Content-Length: 26\r\n\r\nContent payload number one"
|
||||
"Content-Length: 26\r\n\r\nContent payload number two"
|
||||
"Content-Length: 28\r\n\r\nContent payload number three");
|
||||
}
|
||||
|
||||
TEST(ContentStreamTest, Read) {
|
||||
auto sb = dap::StringBuffer::create();
|
||||
sb->write("Content-Length: 26\r\n\r\nContent payload number one");
|
||||
sb->write("some unrecognised garbage");
|
||||
sb->write("Content-Length: 26\r\n\r\nContent payload number two");
|
||||
sb->write("some more unrecognised garbage");
|
||||
sb->write("Content-Length: 28\r\n\r\nContent payload number three");
|
||||
dap::ContentReader cs(std::move(sb));
|
||||
ASSERT_EQ(cs.read(), "Content payload number one");
|
||||
ASSERT_EQ(cs.read(), "Content payload number two");
|
||||
ASSERT_EQ(cs.read(), "Content payload number three");
|
||||
ASSERT_EQ(cs.read(), "");
|
||||
}
|
||||
|
||||
TEST(ContentStreamTest, ShortRead) {
|
||||
auto sb = dap::StringBuffer::create();
|
||||
sb->write("Content-Length: 26\r\n\r\nContent payload number one");
|
||||
sb->write("some unrecognised garbage");
|
||||
sb->write("Content-Length: 26\r\n\r\nContent payload number two");
|
||||
sb->write("some more unrecognised garbage");
|
||||
sb->write("Content-Length: 28\r\n\r\nContent payload number three");
|
||||
dap::ContentReader cs(
|
||||
std::unique_ptr<SingleByteReader>(new SingleByteReader(std::move(sb))));
|
||||
ASSERT_EQ(cs.read(), "Content payload number one");
|
||||
ASSERT_EQ(cs.read(), "Content payload number two");
|
||||
ASSERT_EQ(cs.read(), "Content payload number three");
|
||||
ASSERT_EQ(cs.read(), "");
|
||||
}
|
||||
|
||||
TEST(ContentStreamTest, PartialReadAndParse) {
|
||||
auto sb = std::make_shared<dap::StringBuffer>();
|
||||
sb->write("Content");
|
||||
sb->write("-Length: ");
|
||||
sb->write("26");
|
||||
sb->write("\r\n\r\n");
|
||||
sb->write("Content payload number one");
|
||||
|
||||
dap::ContentReader cs(sb);
|
||||
ASSERT_EQ(cs.read(), "Content payload number one");
|
||||
ASSERT_EQ(cs.read(), "");
|
||||
}
|
||||
|
||||
TEST(ContentStreamTest, HttpRequest) {
|
||||
const char* const part1 =
|
||||
"POST / HTTP/1.1\r\n"
|
||||
"Host: localhost:8001\r\n"
|
||||
"Connection: keep-alive\r\n"
|
||||
"Content-Length: 99\r\n";
|
||||
const char* const part2 =
|
||||
"Pragma: no-cache\r\n"
|
||||
"Cache-Control: no-cache\r\n"
|
||||
"Content-Type: text/plain;charset=UTF-8\r\n"
|
||||
"Accept: */*\r\n"
|
||||
"Origin: null\r\n"
|
||||
"Sec-Fetch-Site: cross-site\r\n"
|
||||
"Sec-Fetch-Mode: cors\r\n"
|
||||
"Sec-Fetch-Dest: empty\r\n"
|
||||
"Accept-Encoding: gzip, deflate, br\r\n"
|
||||
"Accept-Language: en-US,en;q=0.9\r\n"
|
||||
"\r\n"
|
||||
"{\"type\":\"request\",\"command\":\"launch\",\"arguments\":{\"cmd\":\"/"
|
||||
"bin/sh -c 'echo remote code execution'\"}}";
|
||||
|
||||
auto sb = dap::StringBuffer::create();
|
||||
sb->write(part1);
|
||||
sb->write(part2);
|
||||
|
||||
dap::ContentReader cr(std::move(sb), dap::kClose);
|
||||
ASSERT_EQ(cr.read(), "");
|
||||
ASSERT_FALSE(cr.isOpen());
|
||||
}
|
||||
72
libraries/cppdap/src/dap_test.cpp
Normal file
72
libraries/cppdap/src/dap_test.cpp
Normal file
|
|
@ -0,0 +1,72 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "dap/dap.h"
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include <condition_variable>
|
||||
#include <mutex>
|
||||
#include <thread>
|
||||
#include <vector>
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
::testing::InitGoogleTest(&argc, argv);
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
|
||||
TEST(DAP, PairedInitializeTerminate) {
|
||||
dap::initialize();
|
||||
dap::terminate();
|
||||
}
|
||||
|
||||
TEST(DAP, NestedInitializeTerminate) {
|
||||
dap::initialize();
|
||||
dap::initialize();
|
||||
dap::initialize();
|
||||
dap::terminate();
|
||||
dap::terminate();
|
||||
dap::terminate();
|
||||
}
|
||||
|
||||
TEST(DAP, MultiThreadedInitializeTerminate) {
|
||||
const size_t numThreads = 64;
|
||||
|
||||
std::mutex mutex;
|
||||
std::condition_variable cv;
|
||||
size_t numInits = 0;
|
||||
|
||||
std::vector<std::thread> threads;
|
||||
threads.reserve(numThreads);
|
||||
for (size_t i = 0; i < numThreads; i++) {
|
||||
threads.emplace_back([&] {
|
||||
dap::initialize();
|
||||
{
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
numInits++;
|
||||
if (numInits == numThreads) {
|
||||
cv.notify_all();
|
||||
} else {
|
||||
cv.wait(lock, [&] { return numInits == numThreads; });
|
||||
}
|
||||
}
|
||||
dap::terminate();
|
||||
});
|
||||
}
|
||||
|
||||
for (auto& thread : threads) {
|
||||
thread.join();
|
||||
}
|
||||
}
|
||||
258
libraries/cppdap/src/io.cpp
Normal file
258
libraries/cppdap/src/io.cpp
Normal file
|
|
@ -0,0 +1,258 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "dap/io.h"
|
||||
|
||||
#include <atomic>
|
||||
#include <condition_variable>
|
||||
#include <cstdarg>
|
||||
#include <cstdio>
|
||||
#include <cstring> // strlen
|
||||
#include <deque>
|
||||
#include <mutex>
|
||||
#include <string>
|
||||
|
||||
namespace {
|
||||
|
||||
class Pipe : public dap::ReaderWriter {
|
||||
public:
|
||||
// dap::ReaderWriter compliance
|
||||
bool isOpen() override {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
return !closed;
|
||||
}
|
||||
|
||||
void close() override {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
closed = true;
|
||||
cv.notify_all();
|
||||
}
|
||||
|
||||
size_t read(void* buffer, size_t bytes) override {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
auto out = reinterpret_cast<uint8_t*>(buffer);
|
||||
size_t n = 0;
|
||||
while (true) {
|
||||
cv.wait(lock, [&] { return closed || data.size() > 0; });
|
||||
if (closed) {
|
||||
return n;
|
||||
}
|
||||
for (; n < bytes && data.size() > 0; n++) {
|
||||
out[n] = data.front();
|
||||
data.pop_front();
|
||||
}
|
||||
if (n == bytes) {
|
||||
return n;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool write(const void* buffer, size_t bytes) override {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
if (closed) {
|
||||
return false;
|
||||
}
|
||||
if (bytes == 0) {
|
||||
return true;
|
||||
}
|
||||
auto notify = data.size() == 0;
|
||||
auto src = reinterpret_cast<const uint8_t*>(buffer);
|
||||
for (size_t i = 0; i < bytes; i++) {
|
||||
data.emplace_back(src[i]);
|
||||
}
|
||||
if (notify) {
|
||||
cv.notify_all();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
private:
|
||||
std::mutex mutex;
|
||||
std::condition_variable cv;
|
||||
std::deque<uint8_t> data;
|
||||
bool closed = false;
|
||||
};
|
||||
|
||||
class RW : public dap::ReaderWriter {
|
||||
public:
|
||||
RW(const std::shared_ptr<Reader>& r, const std::shared_ptr<Writer>& w)
|
||||
: r(r), w(w) {}
|
||||
|
||||
// dap::ReaderWriter compliance
|
||||
bool isOpen() override { return r->isOpen() && w->isOpen(); }
|
||||
void close() override {
|
||||
r->close();
|
||||
w->close();
|
||||
}
|
||||
size_t read(void* buffer, size_t n) override { return r->read(buffer, n); }
|
||||
bool write(const void* buffer, size_t n) override {
|
||||
return w->write(buffer, n);
|
||||
}
|
||||
|
||||
private:
|
||||
const std::shared_ptr<dap::Reader> r;
|
||||
const std::shared_ptr<dap::Writer> w;
|
||||
};
|
||||
|
||||
class File : public dap::ReaderWriter {
|
||||
public:
|
||||
File(FILE* f, bool closable) : f(f), closable(closable) {}
|
||||
|
||||
~File() { close(); }
|
||||
|
||||
// dap::ReaderWriter compliance
|
||||
bool isOpen() override { return !closed; }
|
||||
void close() override {
|
||||
if (closable) {
|
||||
if (!closed.exchange(true)) {
|
||||
fclose(f);
|
||||
}
|
||||
}
|
||||
}
|
||||
size_t read(void* buffer, size_t n) override {
|
||||
std::unique_lock<std::mutex> lock(readMutex);
|
||||
auto out = reinterpret_cast<char*>(buffer);
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
int c = fgetc(f);
|
||||
if (c == EOF) {
|
||||
return i;
|
||||
}
|
||||
out[i] = char(c);
|
||||
}
|
||||
return n;
|
||||
}
|
||||
bool write(const void* buffer, size_t n) override {
|
||||
std::unique_lock<std::mutex> lock(writeMutex);
|
||||
if (fwrite(buffer, 1, n, f) == n) {
|
||||
fflush(f);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private:
|
||||
FILE* const f;
|
||||
const bool closable;
|
||||
std::mutex readMutex;
|
||||
std::mutex writeMutex;
|
||||
std::atomic<bool> closed = {false};
|
||||
};
|
||||
|
||||
class ReaderSpy : public dap::Reader {
|
||||
public:
|
||||
ReaderSpy(const std::shared_ptr<dap::Reader>& r,
|
||||
const std::shared_ptr<dap::Writer>& s,
|
||||
const std::string& prefix)
|
||||
: r(r), s(s), prefix(prefix) {}
|
||||
|
||||
// dap::Reader compliance
|
||||
bool isOpen() override { return r->isOpen(); }
|
||||
void close() override { r->close(); }
|
||||
size_t read(void* buffer, size_t n) override {
|
||||
auto c = r->read(buffer, n);
|
||||
if (c > 0) {
|
||||
auto chars = reinterpret_cast<const char*>(buffer);
|
||||
std::string buf = prefix;
|
||||
buf.append(chars, chars + c);
|
||||
s->write(buf.data(), buf.size());
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
private:
|
||||
const std::shared_ptr<dap::Reader> r;
|
||||
const std::shared_ptr<dap::Writer> s;
|
||||
const std::string prefix;
|
||||
};
|
||||
|
||||
class WriterSpy : public dap::Writer {
|
||||
public:
|
||||
WriterSpy(const std::shared_ptr<dap::Writer>& w,
|
||||
const std::shared_ptr<dap::Writer>& s,
|
||||
const std::string& prefix)
|
||||
: w(w), s(s), prefix(prefix) {}
|
||||
|
||||
// dap::Writer compliance
|
||||
bool isOpen() override { return w->isOpen(); }
|
||||
void close() override { w->close(); }
|
||||
bool write(const void* buffer, size_t n) override {
|
||||
if (!w->write(buffer, n)) {
|
||||
return false;
|
||||
}
|
||||
auto chars = reinterpret_cast<const char*>(buffer);
|
||||
std::string buf = prefix;
|
||||
buf.append(chars, chars + n);
|
||||
s->write(buf.data(), buf.size());
|
||||
return true;
|
||||
}
|
||||
|
||||
private:
|
||||
const std::shared_ptr<dap::Writer> w;
|
||||
const std::shared_ptr<dap::Writer> s;
|
||||
const std::string prefix;
|
||||
};
|
||||
|
||||
} // anonymous namespace
|
||||
|
||||
namespace dap {
|
||||
|
||||
std::shared_ptr<ReaderWriter> ReaderWriter::create(
|
||||
const std::shared_ptr<Reader>& r,
|
||||
const std::shared_ptr<Writer>& w) {
|
||||
return std::make_shared<RW>(r, w);
|
||||
}
|
||||
|
||||
std::shared_ptr<ReaderWriter> pipe() {
|
||||
return std::make_shared<Pipe>();
|
||||
}
|
||||
|
||||
std::shared_ptr<ReaderWriter> file(FILE* f, bool closable /* = true */) {
|
||||
return std::make_shared<File>(f, closable);
|
||||
}
|
||||
|
||||
std::shared_ptr<ReaderWriter> file(const char* path) {
|
||||
if (auto f = fopen(path, "wb")) {
|
||||
return std::make_shared<File>(f, true);
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// spy() returns a Reader that copies all reads from the Reader r to the Writer
|
||||
// s, using the given optional prefix.
|
||||
std::shared_ptr<Reader> spy(const std::shared_ptr<Reader>& r,
|
||||
const std::shared_ptr<Writer>& s,
|
||||
const char* prefix /* = "\n<-" */) {
|
||||
return std::make_shared<ReaderSpy>(r, s, prefix);
|
||||
}
|
||||
|
||||
// spy() returns a Writer that copies all writes to the Writer w to the Writer
|
||||
// s, using the given optional prefix.
|
||||
std::shared_ptr<Writer> spy(const std::shared_ptr<Writer>& w,
|
||||
const std::shared_ptr<Writer>& s,
|
||||
const char* prefix /* = "\n->" */) {
|
||||
return std::make_shared<WriterSpy>(w, s, prefix);
|
||||
}
|
||||
|
||||
bool writef(const std::shared_ptr<Writer>& w, const char* msg, ...) {
|
||||
char buf[2048];
|
||||
|
||||
va_list vararg;
|
||||
va_start(vararg, msg);
|
||||
vsnprintf(buf, sizeof(buf), msg, vararg);
|
||||
va_end(vararg);
|
||||
|
||||
return w->write(buf, strlen(buf));
|
||||
}
|
||||
|
||||
} // namespace dap
|
||||
47
libraries/cppdap/src/json_serializer.h
Normal file
47
libraries/cppdap/src/json_serializer.h
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
// Copyright 2020 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifndef dap_json_serializer_h
|
||||
#define dap_json_serializer_h
|
||||
|
||||
#if defined(CPPDAP_JSON_NLOHMANN)
|
||||
#include "nlohmann_json_serializer.h"
|
||||
#elif defined(CPPDAP_JSON_RAPID)
|
||||
#include "rapid_json_serializer.h"
|
||||
#elif defined(CPPDAP_JSON_JSONCPP)
|
||||
#include "jsoncpp_json_serializer.h"
|
||||
#else
|
||||
#error "Unrecognised cppdap JSON library"
|
||||
#endif
|
||||
|
||||
namespace dap {
|
||||
namespace json {
|
||||
|
||||
#if defined(CPPDAP_JSON_NLOHMANN)
|
||||
using Deserializer = NlohmannDeserializer;
|
||||
using Serializer = NlohmannSerializer;
|
||||
#elif defined(CPPDAP_JSON_RAPID)
|
||||
using Deserializer = RapidDeserializer;
|
||||
using Serializer = RapidSerializer;
|
||||
#elif defined(CPPDAP_JSON_JSONCPP)
|
||||
using Deserializer = JsonCppDeserializer;
|
||||
using Serializer = JsonCppSerializer;
|
||||
#else
|
||||
#error "Unrecognised cppdap JSON library"
|
||||
#endif
|
||||
|
||||
} // namespace json
|
||||
} // namespace dap
|
||||
|
||||
#endif // dap_json_serializer_h
|
||||
266
libraries/cppdap/src/json_serializer_test.cpp
Normal file
266
libraries/cppdap/src/json_serializer_test.cpp
Normal file
|
|
@ -0,0 +1,266 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "json_serializer.h"
|
||||
|
||||
#include "dap/typeinfo.h"
|
||||
#include "dap/typeof.h"
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
namespace dap {
|
||||
|
||||
struct JSONInnerTestObject {
|
||||
integer i;
|
||||
};
|
||||
|
||||
DAP_STRUCT_TYPEINFO(JSONInnerTestObject,
|
||||
"json-inner-test-object",
|
||||
DAP_FIELD(i, "i"));
|
||||
|
||||
struct JSONTestObject {
|
||||
boolean b;
|
||||
integer i;
|
||||
number n;
|
||||
array<integer> a;
|
||||
object o;
|
||||
string s;
|
||||
optional<integer> o1;
|
||||
optional<integer> o2;
|
||||
JSONInnerTestObject inner;
|
||||
};
|
||||
|
||||
DAP_STRUCT_TYPEINFO(JSONTestObject,
|
||||
"json-test-object",
|
||||
DAP_FIELD(b, "b"),
|
||||
DAP_FIELD(i, "i"),
|
||||
DAP_FIELD(n, "n"),
|
||||
DAP_FIELD(a, "a"),
|
||||
DAP_FIELD(o, "o"),
|
||||
DAP_FIELD(s, "s"),
|
||||
DAP_FIELD(o1, "o1"),
|
||||
DAP_FIELD(o2, "o2"),
|
||||
DAP_FIELD(inner, "inner"));
|
||||
|
||||
struct JSONObjectNoFields {};
|
||||
|
||||
DAP_STRUCT_TYPEINFO(JSONObjectNoFields, "json-object-no-fields");
|
||||
|
||||
struct SimpleJSONTestObject {
|
||||
boolean b;
|
||||
integer i;
|
||||
};
|
||||
DAP_STRUCT_TYPEINFO(SimpleJSONTestObject,
|
||||
"simple-json-test-object",
|
||||
DAP_FIELD(b, "b"),
|
||||
DAP_FIELD(i, "i"));
|
||||
|
||||
} // namespace dap
|
||||
|
||||
class JSONSerializer : public testing::Test {
|
||||
protected:
|
||||
static dap::object GetSimpleObject() {
|
||||
return dap::object({{"one", dap::integer(1)},
|
||||
{"two", dap::number(2)},
|
||||
{"three", dap::string("three")},
|
||||
{"four", dap::boolean(true)}});
|
||||
}
|
||||
void TEST_SIMPLE_OBJECT(const dap::object& obj) {
|
||||
NESTED_TEST_FAILED = true;
|
||||
auto ref_obj = GetSimpleObject();
|
||||
ASSERT_EQ(obj.size(), ref_obj.size());
|
||||
ASSERT_TRUE(obj.at("one").is<dap::integer>());
|
||||
ASSERT_TRUE(obj.at("two").is<dap::number>());
|
||||
ASSERT_TRUE(obj.at("three").is<dap::string>());
|
||||
ASSERT_TRUE(obj.at("four").is<dap::boolean>());
|
||||
|
||||
ASSERT_EQ(ref_obj.at("one").get<dap::integer>(),
|
||||
obj.at("one").get<dap::integer>());
|
||||
ASSERT_EQ(ref_obj.at("two").get<dap::number>(),
|
||||
obj.at("two").get<dap::number>());
|
||||
ASSERT_EQ(ref_obj.at("three").get<dap::string>(),
|
||||
obj.at("three").get<dap::string>());
|
||||
ASSERT_EQ(ref_obj.at("four").get<dap::boolean>(),
|
||||
obj.at("four").get<dap::boolean>());
|
||||
NESTED_TEST_FAILED = false;
|
||||
}
|
||||
template <typename T>
|
||||
void TEST_SERIALIZING_DESERIALIZING(const T& encoded, T& decoded) {
|
||||
NESTED_TEST_FAILED = true;
|
||||
dap::json::Serializer s;
|
||||
ASSERT_TRUE(s.serialize(encoded));
|
||||
dap::json::Deserializer d(s.dump());
|
||||
ASSERT_TRUE(d.deserialize(&decoded));
|
||||
NESTED_TEST_FAILED = false;
|
||||
}
|
||||
bool NESTED_TEST_FAILED = false;
|
||||
#define _ASSERT_PASS(NESTED_TEST) \
|
||||
NESTED_TEST; \
|
||||
ASSERT_FALSE(NESTED_TEST_FAILED);
|
||||
};
|
||||
|
||||
TEST_F(JSONSerializer, SerializeDeserialize) {
|
||||
dap::JSONTestObject encoded;
|
||||
encoded.b = true;
|
||||
encoded.i = 32;
|
||||
encoded.n = 123.456;
|
||||
encoded.a = {2, 4, 6, 8, 0x100000000, -2, -4, -6, -8, -0x100000000};
|
||||
encoded.o["one"] = dap::integer(1);
|
||||
encoded.o["two"] = dap::number(2);
|
||||
encoded.s = "hello world";
|
||||
encoded.o2 = 42;
|
||||
encoded.inner.i = 70;
|
||||
|
||||
dap::json::Serializer s;
|
||||
ASSERT_TRUE(s.serialize(encoded));
|
||||
|
||||
dap::JSONTestObject decoded;
|
||||
dap::json::Deserializer d(s.dump());
|
||||
ASSERT_TRUE(d.deserialize(&decoded));
|
||||
|
||||
ASSERT_EQ(encoded.b, decoded.b);
|
||||
ASSERT_EQ(encoded.i, decoded.i);
|
||||
ASSERT_EQ(encoded.n, decoded.n);
|
||||
ASSERT_EQ(encoded.a, decoded.a);
|
||||
ASSERT_EQ(encoded.o["one"].get<dap::integer>(),
|
||||
decoded.o["one"].get<dap::integer>());
|
||||
ASSERT_EQ(encoded.o["two"].get<dap::number>(),
|
||||
decoded.o["two"].get<dap::number>());
|
||||
ASSERT_EQ(encoded.s, decoded.s);
|
||||
ASSERT_EQ(encoded.o2, decoded.o2);
|
||||
ASSERT_EQ(encoded.inner.i, decoded.inner.i);
|
||||
}
|
||||
|
||||
TEST_F(JSONSerializer, SerializeObjectNoFields) {
|
||||
dap::JSONObjectNoFields obj;
|
||||
dap::json::Serializer s;
|
||||
ASSERT_TRUE(s.serialize(obj));
|
||||
ASSERT_EQ(s.dump(), "{}");
|
||||
}
|
||||
|
||||
TEST_F(JSONSerializer, SerializeDeserializeObject) {
|
||||
dap::object encoded = GetSimpleObject();
|
||||
dap::object decoded;
|
||||
_ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
|
||||
_ASSERT_PASS(TEST_SIMPLE_OBJECT(decoded));
|
||||
}
|
||||
|
||||
TEST_F(JSONSerializer, SerializeDeserializeEmbeddedObject) {
|
||||
dap::object encoded;
|
||||
dap::object decoded;
|
||||
// object nested inside object
|
||||
dap::object encoded_embed_obj = GetSimpleObject();
|
||||
dap::object decoded_embed_obj;
|
||||
encoded["embed_obj"] = encoded_embed_obj;
|
||||
_ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
|
||||
ASSERT_TRUE(decoded["embed_obj"].is<dap::object>());
|
||||
decoded_embed_obj = decoded["embed_obj"].get<dap::object>();
|
||||
_ASSERT_PASS(TEST_SIMPLE_OBJECT(decoded_embed_obj));
|
||||
}
|
||||
|
||||
TEST_F(JSONSerializer, SerializeDeserializeEmbeddedStruct) {
|
||||
dap::object encoded;
|
||||
dap::object decoded;
|
||||
// object nested inside object
|
||||
dap::SimpleJSONTestObject encoded_embed_struct;
|
||||
encoded_embed_struct.b = true;
|
||||
encoded_embed_struct.i = 50;
|
||||
encoded["embed_struct"] = encoded_embed_struct;
|
||||
|
||||
dap::object decoded_embed_obj;
|
||||
_ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
|
||||
ASSERT_TRUE(decoded["embed_struct"].is<dap::object>());
|
||||
decoded_embed_obj = decoded["embed_struct"].get<dap::object>();
|
||||
ASSERT_TRUE(decoded_embed_obj.at("b").is<dap::boolean>());
|
||||
ASSERT_TRUE(decoded_embed_obj.at("i").is<dap::integer>());
|
||||
|
||||
ASSERT_EQ(encoded_embed_struct.b, decoded_embed_obj["b"].get<dap::boolean>());
|
||||
ASSERT_EQ(encoded_embed_struct.i, decoded_embed_obj["i"].get<dap::integer>());
|
||||
}
|
||||
|
||||
TEST_F(JSONSerializer, SerializeDeserializeEmbeddedIntArray) {
|
||||
dap::object encoded;
|
||||
dap::object decoded;
|
||||
// array nested inside object
|
||||
dap::array<dap::integer> encoded_embed_arr = {1, 2, 3, 4};
|
||||
dap::array<dap::any> decoded_embed_arr;
|
||||
|
||||
encoded["embed_arr"] = encoded_embed_arr;
|
||||
|
||||
_ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
|
||||
// TODO: Deserializing array should infer basic member types
|
||||
ASSERT_TRUE(decoded["embed_arr"].is<dap::array<dap::any>>());
|
||||
decoded_embed_arr = decoded["embed_arr"].get<dap::array<dap::any>>();
|
||||
ASSERT_EQ(encoded_embed_arr.size(), decoded_embed_arr.size());
|
||||
for (std::size_t i = 0; i < decoded_embed_arr.size(); i++) {
|
||||
ASSERT_TRUE(decoded_embed_arr[i].is<dap::integer>());
|
||||
ASSERT_EQ(encoded_embed_arr[i], decoded_embed_arr[i].get<dap::integer>());
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(JSONSerializer, SerializeDeserializeEmbeddedObjectArray) {
|
||||
dap::object encoded;
|
||||
dap::object decoded;
|
||||
|
||||
dap::array<dap::object> encoded_embed_arr = {GetSimpleObject(),
|
||||
GetSimpleObject()};
|
||||
dap::array<dap::any> decoded_embed_arr;
|
||||
|
||||
encoded["embed_arr"] = encoded_embed_arr;
|
||||
|
||||
_ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
|
||||
// TODO: Deserializing array should infer basic member types
|
||||
ASSERT_TRUE(decoded["embed_arr"].is<dap::array<dap::any>>());
|
||||
decoded_embed_arr = decoded["embed_arr"].get<dap::array<dap::any>>();
|
||||
ASSERT_EQ(encoded_embed_arr.size(), decoded_embed_arr.size());
|
||||
for (std::size_t i = 0; i < decoded_embed_arr.size(); i++) {
|
||||
ASSERT_TRUE(decoded_embed_arr[i].is<dap::object>());
|
||||
_ASSERT_PASS(TEST_SIMPLE_OBJECT(decoded_embed_arr[i].get<dap::object>()));
|
||||
}
|
||||
}
|
||||
|
||||
TEST_F(JSONSerializer, DeserializeSerializeEmptyObject) {
|
||||
auto empty_obj = "{}";
|
||||
dap::object decoded;
|
||||
dap::json::Deserializer d(empty_obj);
|
||||
ASSERT_TRUE(d.deserialize(&decoded));
|
||||
dap::json::Serializer s;
|
||||
ASSERT_TRUE(s.serialize(decoded));
|
||||
ASSERT_EQ(s.dump(), empty_obj);
|
||||
}
|
||||
|
||||
TEST_F(JSONSerializer, SerializeDeserializeEmbeddedEmptyObject) {
|
||||
dap::object encoded_empty_obj;
|
||||
dap::object encoded = {{"empty_obj", encoded_empty_obj}};
|
||||
dap::object decoded;
|
||||
|
||||
_ASSERT_PASS(TEST_SERIALIZING_DESERIALIZING(encoded, decoded));
|
||||
ASSERT_TRUE(decoded["empty_obj"].is<dap::object>());
|
||||
dap::object decoded_empty_obj = decoded["empty_obj"].get<dap::object>();
|
||||
ASSERT_EQ(encoded_empty_obj.size(), decoded_empty_obj.size());
|
||||
}
|
||||
|
||||
TEST_F(JSONSerializer, SerializeDeserializeObjectWithNulledField) {
|
||||
auto thing = dap::any(dap::null());
|
||||
dap::object encoded;
|
||||
encoded["nulled_field"] = dap::null();
|
||||
dap::json::Serializer s;
|
||||
ASSERT_TRUE(s.serialize(encoded));
|
||||
dap::object decoded;
|
||||
auto dump = s.dump();
|
||||
dap::json::Deserializer d(dump);
|
||||
ASSERT_TRUE(d.deserialize(&decoded));
|
||||
ASSERT_TRUE(encoded["nulled_field"].is<dap::null>());
|
||||
}
|
||||
272
libraries/cppdap/src/jsoncpp_json_serializer.cpp
Normal file
272
libraries/cppdap/src/jsoncpp_json_serializer.cpp
Normal file
|
|
@ -0,0 +1,272 @@
|
|||
// Copyright 2023 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "jsoncpp_json_serializer.h"
|
||||
|
||||
#include "null_json_serializer.h"
|
||||
|
||||
#include <json/json.h>
|
||||
#include <cstdlib>
|
||||
#include <memory>
|
||||
|
||||
namespace dap {
|
||||
namespace json {
|
||||
|
||||
JsonCppDeserializer::JsonCppDeserializer(const std::string& str)
|
||||
: json(new Json::Value(JsonCppDeserializer::parse(str))), ownsJson(true) {}
|
||||
|
||||
JsonCppDeserializer::JsonCppDeserializer(const Json::Value* json)
|
||||
: json(json), ownsJson(false) {}
|
||||
|
||||
JsonCppDeserializer::~JsonCppDeserializer() {
|
||||
if (ownsJson) {
|
||||
delete json;
|
||||
}
|
||||
}
|
||||
|
||||
bool JsonCppDeserializer::deserialize(dap::boolean* v) const {
|
||||
if (!json->isBool()) {
|
||||
return false;
|
||||
}
|
||||
*v = json->asBool();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool JsonCppDeserializer::deserialize(dap::integer* v) const {
|
||||
if (!json->isInt64()) {
|
||||
return false;
|
||||
}
|
||||
*v = json->asInt64();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool JsonCppDeserializer::deserialize(dap::number* v) const {
|
||||
if (!json->isNumeric()) {
|
||||
return false;
|
||||
}
|
||||
*v = json->asDouble();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool JsonCppDeserializer::deserialize(dap::string* v) const {
|
||||
if (!json->isString()) {
|
||||
return false;
|
||||
}
|
||||
*v = json->asString();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool JsonCppDeserializer::deserialize(dap::object* v) const {
|
||||
v->reserve(json->size());
|
||||
for (auto i = json->begin(); i != json->end(); i++) {
|
||||
JsonCppDeserializer d(&*i);
|
||||
dap::any val;
|
||||
if (!d.deserialize(&val)) {
|
||||
return false;
|
||||
}
|
||||
(*v)[i.name()] = val;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool JsonCppDeserializer::deserialize(dap::any* v) const {
|
||||
if (json->isBool()) {
|
||||
*v = dap::boolean(json->asBool());
|
||||
} else if (json->type() == Json::ValueType::realValue) {
|
||||
// json->isDouble() returns true for integers as well, so we need to
|
||||
// explicitly look for the realValue type.
|
||||
*v = dap::number(json->asDouble());
|
||||
} else if (json->isInt64()) {
|
||||
*v = dap::integer(json->asInt64());
|
||||
} else if (json->isString()) {
|
||||
*v = json->asString();
|
||||
} else if (json->isObject()) {
|
||||
dap::object obj;
|
||||
if (!deserialize(&obj)) {
|
||||
return false;
|
||||
}
|
||||
*v = obj;
|
||||
} else if (json->isArray()) {
|
||||
dap::array<any> arr;
|
||||
if (!deserialize(&arr)) {
|
||||
return false;
|
||||
}
|
||||
*v = arr;
|
||||
} else if (json->isNull()) {
|
||||
*v = null();
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
size_t JsonCppDeserializer::count() const {
|
||||
return json->size();
|
||||
}
|
||||
|
||||
bool JsonCppDeserializer::array(
|
||||
const std::function<bool(dap::Deserializer*)>& cb) const {
|
||||
if (!json->isArray()) {
|
||||
return false;
|
||||
}
|
||||
for (const auto& value : *json) {
|
||||
JsonCppDeserializer d(&value);
|
||||
if (!cb(&d)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool JsonCppDeserializer::field(
|
||||
const std::string& name,
|
||||
const std::function<bool(dap::Deserializer*)>& cb) const {
|
||||
if (!json->isObject()) {
|
||||
return false;
|
||||
}
|
||||
auto value = json->find(name.data(), name.data() + name.size());
|
||||
if (value == nullptr) {
|
||||
return cb(&NullDeserializer::instance);
|
||||
}
|
||||
JsonCppDeserializer d(value);
|
||||
return cb(&d);
|
||||
}
|
||||
|
||||
Json::Value JsonCppDeserializer::parse(const std::string& text) {
|
||||
Json::CharReaderBuilder builder;
|
||||
auto jsonReader = std::unique_ptr<Json::CharReader>(builder.newCharReader());
|
||||
Json::Value json;
|
||||
std::string error;
|
||||
if (!jsonReader->parse(text.data(), text.data() + text.size(), &json,
|
||||
&error)) {
|
||||
// cppdap expects that the JSON layer does not throw exceptions.
|
||||
std::abort();
|
||||
}
|
||||
return json;
|
||||
}
|
||||
|
||||
JsonCppSerializer::JsonCppSerializer()
|
||||
: json(new Json::Value()), ownsJson(true) {}
|
||||
|
||||
JsonCppSerializer::JsonCppSerializer(Json::Value* json)
|
||||
: json(json), ownsJson(false) {}
|
||||
|
||||
JsonCppSerializer::~JsonCppSerializer() {
|
||||
if (ownsJson) {
|
||||
delete json;
|
||||
}
|
||||
}
|
||||
|
||||
std::string JsonCppSerializer::dump() const {
|
||||
Json::StreamWriterBuilder writer;
|
||||
return Json::writeString(writer, *json);
|
||||
}
|
||||
|
||||
bool JsonCppSerializer::serialize(dap::boolean v) {
|
||||
*json = (bool)v;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool JsonCppSerializer::serialize(dap::integer v) {
|
||||
*json = (Json::LargestInt)v;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool JsonCppSerializer::serialize(dap::number v) {
|
||||
*json = (double)v;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool JsonCppSerializer::serialize(const dap::string& v) {
|
||||
*json = v;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool JsonCppSerializer::serialize(const dap::object& v) {
|
||||
if (!json->isObject()) {
|
||||
*json = Json::Value(Json::objectValue);
|
||||
}
|
||||
for (auto& it : v) {
|
||||
JsonCppSerializer s(&(*json)[it.first]);
|
||||
if (!s.serialize(it.second)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool JsonCppSerializer::serialize(const dap::any& v) {
|
||||
if (v.is<dap::boolean>()) {
|
||||
*json = (bool)v.get<dap::boolean>();
|
||||
} else if (v.is<dap::integer>()) {
|
||||
*json = (Json::LargestInt)v.get<dap::integer>();
|
||||
} else if (v.is<dap::number>()) {
|
||||
*json = (double)v.get<dap::number>();
|
||||
} else if (v.is<dap::string>()) {
|
||||
*json = v.get<dap::string>();
|
||||
} else if (v.is<dap::object>()) {
|
||||
// reachable if dap::object nested is inside other dap::object
|
||||
return serialize(v.get<dap::object>());
|
||||
} else if (v.is<dap::null>()) {
|
||||
} else {
|
||||
// reachable if array or custom serialized type is nested inside other
|
||||
auto type = get_any_type(v);
|
||||
auto value = get_any_val(v);
|
||||
if (type && value) {
|
||||
return type->serialize(this, value);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool JsonCppSerializer::array(size_t count,
|
||||
const std::function<bool(dap::Serializer*)>& cb) {
|
||||
*json = Json::Value(Json::arrayValue);
|
||||
for (size_t i = 0; i < count; i++) {
|
||||
JsonCppSerializer s(&(*json)[Json::Value::ArrayIndex(i)]);
|
||||
if (!cb(&s)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool JsonCppSerializer::object(
|
||||
const std::function<bool(dap::FieldSerializer*)>& cb) {
|
||||
struct FS : public FieldSerializer {
|
||||
Json::Value* const json;
|
||||
|
||||
FS(Json::Value* json) : json(json) {}
|
||||
bool field(const std::string& name, const SerializeFunc& cb) override {
|
||||
JsonCppSerializer s(&(*json)[name]);
|
||||
auto res = cb(&s);
|
||||
if (s.removed) {
|
||||
json->removeMember(name);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
};
|
||||
|
||||
*json = Json::Value(Json::objectValue);
|
||||
FS fs{json};
|
||||
return cb(&fs);
|
||||
}
|
||||
|
||||
void JsonCppSerializer::remove() {
|
||||
removed = true;
|
||||
}
|
||||
|
||||
} // namespace json
|
||||
} // namespace dap
|
||||
134
libraries/cppdap/src/jsoncpp_json_serializer.h
Normal file
134
libraries/cppdap/src/jsoncpp_json_serializer.h
Normal file
|
|
@ -0,0 +1,134 @@
|
|||
// Copyright 2023 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifndef dap_jsoncpp_json_serializer_h
|
||||
#define dap_jsoncpp_json_serializer_h
|
||||
|
||||
#include "dap/protocol.h"
|
||||
#include "dap/serialization.h"
|
||||
#include "dap/types.h"
|
||||
|
||||
#include <json/forwards.h>
|
||||
|
||||
namespace dap {
|
||||
namespace json {
|
||||
|
||||
struct JsonCppDeserializer : public dap::Deserializer {
|
||||
explicit JsonCppDeserializer(const std::string&);
|
||||
~JsonCppDeserializer();
|
||||
|
||||
// dap::Deserializer compliance
|
||||
bool deserialize(boolean* v) const override;
|
||||
bool deserialize(integer* v) const override;
|
||||
bool deserialize(number* v) const override;
|
||||
bool deserialize(string* v) const override;
|
||||
bool deserialize(object* v) const override;
|
||||
bool deserialize(any* v) const override;
|
||||
size_t count() const override;
|
||||
bool array(const std::function<bool(dap::Deserializer*)>&) const override;
|
||||
bool field(const std::string& name,
|
||||
const std::function<bool(dap::Deserializer*)>&) const override;
|
||||
|
||||
// Unhide base overloads
|
||||
template <typename T>
|
||||
inline bool field(const std::string& name, T* v) {
|
||||
return dap::Deserializer::field(name, v);
|
||||
}
|
||||
|
||||
template <typename T,
|
||||
typename = std::enable_if<TypeOf<T>::has_custom_serialization>>
|
||||
inline bool deserialize(T* v) const {
|
||||
return dap::Deserializer::deserialize(v);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline bool deserialize(dap::array<T>* v) const {
|
||||
return dap::Deserializer::deserialize(v);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline bool deserialize(dap::optional<T>* v) const {
|
||||
return dap::Deserializer::deserialize(v);
|
||||
}
|
||||
|
||||
template <typename T0, typename... Types>
|
||||
inline bool deserialize(dap::variant<T0, Types...>* v) const {
|
||||
return dap::Deserializer::deserialize(v);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline bool field(const std::string& name, T* v) const {
|
||||
return dap::Deserializer::deserialize(name, v);
|
||||
}
|
||||
|
||||
private:
|
||||
JsonCppDeserializer(const Json::Value*);
|
||||
static Json::Value parse(const std::string& text);
|
||||
const Json::Value* const json;
|
||||
const bool ownsJson;
|
||||
};
|
||||
|
||||
struct JsonCppSerializer : public dap::Serializer {
|
||||
JsonCppSerializer();
|
||||
~JsonCppSerializer();
|
||||
|
||||
std::string dump() const;
|
||||
|
||||
// dap::Serializer compliance
|
||||
bool serialize(boolean v) override;
|
||||
bool serialize(integer v) override;
|
||||
bool serialize(number v) override;
|
||||
bool serialize(const string& v) override;
|
||||
bool serialize(const dap::object& v) override;
|
||||
bool serialize(const any& v) override;
|
||||
bool array(size_t count,
|
||||
const std::function<bool(dap::Serializer*)>&) override;
|
||||
bool object(const std::function<bool(dap::FieldSerializer*)>&) override;
|
||||
void remove() override;
|
||||
|
||||
// Unhide base overloads
|
||||
template <typename T,
|
||||
typename = std::enable_if<TypeOf<T>::has_custom_serialization>>
|
||||
inline bool serialize(const T& v) {
|
||||
return dap::Serializer::serialize(v);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline bool serialize(const dap::array<T>& v) {
|
||||
return dap::Serializer::serialize(v);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline bool serialize(const dap::optional<T>& v) {
|
||||
return dap::Serializer::serialize(v);
|
||||
}
|
||||
|
||||
template <typename T0, typename... Types>
|
||||
inline bool serialize(const dap::variant<T0, Types...>& v) {
|
||||
return dap::Serializer::serialize(v);
|
||||
}
|
||||
|
||||
inline bool serialize(const char* v) { return dap::Serializer::serialize(v); }
|
||||
|
||||
private:
|
||||
JsonCppSerializer(Json::Value*);
|
||||
Json::Value* const json;
|
||||
const bool ownsJson;
|
||||
bool removed = false;
|
||||
};
|
||||
|
||||
} // namespace json
|
||||
} // namespace dap
|
||||
|
||||
#endif // dap_jsoncpp_json_serializer_h
|
||||
107
libraries/cppdap/src/network.cpp
Normal file
107
libraries/cppdap/src/network.cpp
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "dap/network.h"
|
||||
|
||||
#include "socket.h"
|
||||
|
||||
#include <atomic>
|
||||
#include <mutex>
|
||||
#include <string>
|
||||
#include <thread>
|
||||
|
||||
namespace {
|
||||
|
||||
class Impl : public dap::net::Server {
|
||||
public:
|
||||
Impl() : stopped{true} {}
|
||||
|
||||
~Impl() { stop(); }
|
||||
|
||||
bool start(int port,
|
||||
const OnConnect& onConnect,
|
||||
const OnError& onError) override {
|
||||
return start("localhost", port, onConnect, onError);
|
||||
}
|
||||
|
||||
bool start(const char* address,
|
||||
int port,
|
||||
const OnConnect& onConnect,
|
||||
const OnError& onError) override {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
stopWithLock();
|
||||
socket = std::unique_ptr<dap::Socket>(
|
||||
new dap::Socket(address, std::to_string(port).c_str()));
|
||||
|
||||
if (!socket->isOpen()) {
|
||||
onError("Failed to open socket");
|
||||
return false;
|
||||
}
|
||||
|
||||
stopped = false;
|
||||
thread = std::thread([=] {
|
||||
while (true) {
|
||||
if (auto rw = socket->accept()) {
|
||||
onConnect(rw);
|
||||
continue;
|
||||
}
|
||||
if (!stopped) {
|
||||
onError("Failed to accept connection");
|
||||
}
|
||||
break;
|
||||
};
|
||||
});
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void stop() override {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
stopWithLock();
|
||||
}
|
||||
|
||||
private:
|
||||
bool isRunning() { return !stopped; }
|
||||
|
||||
void stopWithLock() {
|
||||
if (!stopped.exchange(true)) {
|
||||
socket->close();
|
||||
thread.join();
|
||||
}
|
||||
}
|
||||
|
||||
std::mutex mutex;
|
||||
std::thread thread;
|
||||
std::unique_ptr<dap::Socket> socket;
|
||||
std::atomic<bool> stopped;
|
||||
OnError errorHandler;
|
||||
};
|
||||
|
||||
} // anonymous namespace
|
||||
|
||||
namespace dap {
|
||||
namespace net {
|
||||
|
||||
std::unique_ptr<Server> Server::create() {
|
||||
return std::unique_ptr<Server>(new Impl());
|
||||
}
|
||||
|
||||
std::shared_ptr<ReaderWriter> connect(const char* addr,
|
||||
int port,
|
||||
uint32_t timeoutMillis) {
|
||||
return Socket::connect(addr, std::to_string(port).c_str(), timeoutMillis);
|
||||
}
|
||||
|
||||
} // namespace net
|
||||
} // namespace dap
|
||||
110
libraries/cppdap/src/network_test.cpp
Normal file
110
libraries/cppdap/src/network_test.cpp
Normal file
|
|
@ -0,0 +1,110 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "dap/network.h"
|
||||
#include "dap/io.h"
|
||||
|
||||
#include "chan.h"
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include <chrono>
|
||||
#include <thread>
|
||||
|
||||
namespace {
|
||||
|
||||
constexpr int port = 19021;
|
||||
|
||||
bool write(const std::shared_ptr<dap::Writer>& w, const std::string& s) {
|
||||
return w->write(s.data(), s.size()) && w->write("\0", 1);
|
||||
}
|
||||
|
||||
std::string read(const std::shared_ptr<dap::Reader>& r) {
|
||||
char c;
|
||||
std::string s;
|
||||
while (r->read(&c, sizeof(c)) > 0) {
|
||||
if (c == '\0') {
|
||||
return s;
|
||||
}
|
||||
s += c;
|
||||
}
|
||||
return r->isOpen() ? "<read failed>" : "<stream closed>";
|
||||
}
|
||||
|
||||
} // anonymous namespace
|
||||
|
||||
TEST(Network, ClientServer) {
|
||||
dap::Chan<bool> done;
|
||||
auto server = dap::net::Server::create();
|
||||
if (!server->start(
|
||||
port,
|
||||
[&](const std::shared_ptr<dap::ReaderWriter>& rw) {
|
||||
ASSERT_EQ(read(rw), "client to server");
|
||||
ASSERT_TRUE(write(rw, "server to client"));
|
||||
done.put(true);
|
||||
},
|
||||
[&](const char* err) { FAIL() << "Server error: " << err; })) {
|
||||
FAIL() << "Couldn't start server";
|
||||
return;
|
||||
}
|
||||
|
||||
for (int i = 0; i < 5; i++) {
|
||||
auto client = dap::net::connect("localhost", port);
|
||||
ASSERT_NE(client, nullptr) << "Failed to connect client " << i;
|
||||
ASSERT_TRUE(write(client, "client to server"));
|
||||
ASSERT_EQ(read(client), "server to client");
|
||||
done.take();
|
||||
std::this_thread::sleep_for(std::chrono::seconds(1));
|
||||
}
|
||||
|
||||
server.reset();
|
||||
}
|
||||
|
||||
TEST(Network, ServerRepeatStopAndRestart) {
|
||||
dap::Chan<bool> done;
|
||||
auto onConnect = [&](const std::shared_ptr<dap::ReaderWriter>& rw) {
|
||||
ASSERT_EQ(read(rw), "client to server");
|
||||
ASSERT_TRUE(write(rw, "server to client"));
|
||||
done.put(true);
|
||||
};
|
||||
auto onError = [&](const char* err) { FAIL() << "Server error: " << err; };
|
||||
|
||||
auto server = dap::net::Server::create();
|
||||
if (!server->start(port, onConnect, onError)) {
|
||||
FAIL() << "Couldn't start server";
|
||||
return;
|
||||
}
|
||||
|
||||
server->stop();
|
||||
server->stop();
|
||||
server->stop();
|
||||
|
||||
if (!server->start(port, onConnect, onError)) {
|
||||
FAIL() << "Couldn't restart server";
|
||||
return;
|
||||
}
|
||||
|
||||
auto client = dap::net::connect("localhost", port);
|
||||
ASSERT_NE(client, nullptr) << "Failed to connect";
|
||||
ASSERT_TRUE(write(client, "client to server"));
|
||||
ASSERT_EQ(read(client), "server to client");
|
||||
done.take();
|
||||
|
||||
server->stop();
|
||||
server->stop();
|
||||
server->stop();
|
||||
|
||||
server.reset();
|
||||
}
|
||||
260
libraries/cppdap/src/nlohmann_json_serializer.cpp
Normal file
260
libraries/cppdap/src/nlohmann_json_serializer.cpp
Normal file
|
|
@ -0,0 +1,260 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "nlohmann_json_serializer.h"
|
||||
|
||||
#include "null_json_serializer.h"
|
||||
|
||||
// Disable JSON exceptions. We should be guarding against any exceptions being
|
||||
// fired in this file.
|
||||
#define JSON_NOEXCEPTION 1
|
||||
#include <nlohmann/json.hpp>
|
||||
|
||||
namespace dap {
|
||||
namespace json {
|
||||
|
||||
NlohmannDeserializer::NlohmannDeserializer(const std::string& str)
|
||||
: json(new nlohmann::json(nlohmann::json::parse(str, nullptr, false))),
|
||||
ownsJson(true) {}
|
||||
|
||||
NlohmannDeserializer::NlohmannDeserializer(const nlohmann::json* json)
|
||||
: json(json), ownsJson(false) {}
|
||||
|
||||
NlohmannDeserializer::~NlohmannDeserializer() {
|
||||
if (ownsJson) {
|
||||
delete json;
|
||||
}
|
||||
}
|
||||
|
||||
bool NlohmannDeserializer::deserialize(dap::boolean* v) const {
|
||||
if (!json->is_boolean()) {
|
||||
return false;
|
||||
}
|
||||
*v = json->get<bool>();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool NlohmannDeserializer::deserialize(dap::integer* v) const {
|
||||
if (!json->is_number_integer()) {
|
||||
return false;
|
||||
}
|
||||
*v = json->get<int64_t>();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool NlohmannDeserializer::deserialize(dap::number* v) const {
|
||||
if (!json->is_number()) {
|
||||
return false;
|
||||
}
|
||||
*v = json->get<double>();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool NlohmannDeserializer::deserialize(dap::string* v) const {
|
||||
if (!json->is_string()) {
|
||||
return false;
|
||||
}
|
||||
*v = json->get<std::string>();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool NlohmannDeserializer::deserialize(dap::object* v) const {
|
||||
v->reserve(json->size());
|
||||
for (auto& el : json->items()) {
|
||||
NlohmannDeserializer d(&el.value());
|
||||
dap::any val;
|
||||
if (!d.deserialize(&val)) {
|
||||
return false;
|
||||
}
|
||||
(*v)[el.key()] = val;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool NlohmannDeserializer::deserialize(dap::any* v) const {
|
||||
if (json->is_boolean()) {
|
||||
*v = dap::boolean(json->get<bool>());
|
||||
} else if (json->is_number_float()) {
|
||||
*v = dap::number(json->get<double>());
|
||||
} else if (json->is_number_integer()) {
|
||||
*v = dap::integer(json->get<int64_t>());
|
||||
} else if (json->is_string()) {
|
||||
*v = json->get<std::string>();
|
||||
} else if (json->is_object()) {
|
||||
dap::object obj;
|
||||
if (!deserialize(&obj)) {
|
||||
return false;
|
||||
}
|
||||
*v = obj;
|
||||
} else if (json->is_array()) {
|
||||
dap::array<any> arr;
|
||||
if (!deserialize(&arr)) {
|
||||
return false;
|
||||
}
|
||||
*v = arr;
|
||||
} else if (json->is_null()) {
|
||||
*v = null();
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
size_t NlohmannDeserializer::count() const {
|
||||
return json->size();
|
||||
}
|
||||
|
||||
bool NlohmannDeserializer::array(
|
||||
const std::function<bool(dap::Deserializer*)>& cb) const {
|
||||
if (!json->is_array()) {
|
||||
return false;
|
||||
}
|
||||
for (size_t i = 0; i < json->size(); i++) {
|
||||
NlohmannDeserializer d(&(*json)[i]);
|
||||
if (!cb(&d)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool NlohmannDeserializer::field(
|
||||
const std::string& name,
|
||||
const std::function<bool(dap::Deserializer*)>& cb) const {
|
||||
if (!json->is_structured()) {
|
||||
return false;
|
||||
}
|
||||
auto it = json->find(name);
|
||||
if (it == json->end()) {
|
||||
return cb(&NullDeserializer::instance);
|
||||
}
|
||||
auto obj = *it;
|
||||
NlohmannDeserializer d(&obj);
|
||||
return cb(&d);
|
||||
}
|
||||
|
||||
NlohmannSerializer::NlohmannSerializer()
|
||||
: json(new nlohmann::json()), ownsJson(true) {}
|
||||
|
||||
NlohmannSerializer::NlohmannSerializer(nlohmann::json* json)
|
||||
: json(json), ownsJson(false) {}
|
||||
|
||||
NlohmannSerializer::~NlohmannSerializer() {
|
||||
if (ownsJson) {
|
||||
delete json;
|
||||
}
|
||||
}
|
||||
|
||||
std::string NlohmannSerializer::dump() const {
|
||||
return json->dump();
|
||||
}
|
||||
|
||||
bool NlohmannSerializer::serialize(dap::boolean v) {
|
||||
*json = (bool)v;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool NlohmannSerializer::serialize(dap::integer v) {
|
||||
*json = (int64_t)v;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool NlohmannSerializer::serialize(dap::number v) {
|
||||
*json = (double)v;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool NlohmannSerializer::serialize(const dap::string& v) {
|
||||
*json = v;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool NlohmannSerializer::serialize(const dap::object& v) {
|
||||
if (!json->is_object()) {
|
||||
*json = nlohmann::json::object();
|
||||
}
|
||||
for (auto& it : v) {
|
||||
NlohmannSerializer s(&(*json)[it.first]);
|
||||
if (!s.serialize(it.second)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool NlohmannSerializer::serialize(const dap::any& v) {
|
||||
if (v.is<dap::boolean>()) {
|
||||
*json = (bool)v.get<dap::boolean>();
|
||||
} else if (v.is<dap::integer>()) {
|
||||
*json = (int64_t)v.get<dap::integer>();
|
||||
} else if (v.is<dap::number>()) {
|
||||
*json = (double)v.get<dap::number>();
|
||||
} else if (v.is<dap::string>()) {
|
||||
*json = v.get<dap::string>();
|
||||
} else if (v.is<dap::object>()) {
|
||||
// reachable if dap::object nested is inside other dap::object
|
||||
return serialize(v.get<dap::object>());
|
||||
} else if (v.is<dap::null>()) {
|
||||
} else {
|
||||
// reachable if array or custom serialized type is nested inside other
|
||||
auto type = get_any_type(v);
|
||||
auto value = get_any_val(v);
|
||||
if (type && value) {
|
||||
return type->serialize(this, value);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool NlohmannSerializer::array(
|
||||
size_t count,
|
||||
const std::function<bool(dap::Serializer*)>& cb) {
|
||||
*json = std::vector<int>();
|
||||
for (size_t i = 0; i < count; i++) {
|
||||
NlohmannSerializer s(&(*json)[i]);
|
||||
if (!cb(&s)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool NlohmannSerializer::object(
|
||||
const std::function<bool(dap::FieldSerializer*)>& cb) {
|
||||
struct FS : public FieldSerializer {
|
||||
nlohmann::json* const json;
|
||||
|
||||
FS(nlohmann::json* json) : json(json) {}
|
||||
bool field(const std::string& name, const SerializeFunc& cb) override {
|
||||
NlohmannSerializer s(&(*json)[name]);
|
||||
auto res = cb(&s);
|
||||
if (s.removed) {
|
||||
json->erase(name);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
};
|
||||
|
||||
*json = nlohmann::json({}, false, nlohmann::json::value_t::object);
|
||||
FS fs{json};
|
||||
return cb(&fs);
|
||||
}
|
||||
|
||||
void NlohmannSerializer::remove() {
|
||||
removed = true;
|
||||
}
|
||||
|
||||
} // namespace json
|
||||
} // namespace dap
|
||||
133
libraries/cppdap/src/nlohmann_json_serializer.h
Normal file
133
libraries/cppdap/src/nlohmann_json_serializer.h
Normal file
|
|
@ -0,0 +1,133 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifndef dap_nlohmann_json_serializer_h
|
||||
#define dap_nlohmann_json_serializer_h
|
||||
|
||||
#include "dap/protocol.h"
|
||||
#include "dap/serialization.h"
|
||||
#include "dap/types.h"
|
||||
|
||||
#include <nlohmann/json_fwd.hpp>
|
||||
|
||||
namespace dap {
|
||||
namespace json {
|
||||
|
||||
struct NlohmannDeserializer : public dap::Deserializer {
|
||||
explicit NlohmannDeserializer(const std::string&);
|
||||
~NlohmannDeserializer();
|
||||
|
||||
// dap::Deserializer compliance
|
||||
bool deserialize(boolean* v) const override;
|
||||
bool deserialize(integer* v) const override;
|
||||
bool deserialize(number* v) const override;
|
||||
bool deserialize(string* v) const override;
|
||||
bool deserialize(object* v) const override;
|
||||
bool deserialize(any* v) const override;
|
||||
size_t count() const override;
|
||||
bool array(const std::function<bool(dap::Deserializer*)>&) const override;
|
||||
bool field(const std::string& name,
|
||||
const std::function<bool(dap::Deserializer*)>&) const override;
|
||||
|
||||
// Unhide base overloads
|
||||
template <typename T>
|
||||
inline bool field(const std::string& name, T* v) {
|
||||
return dap::Deserializer::field(name, v);
|
||||
}
|
||||
|
||||
template <typename T,
|
||||
typename = std::enable_if<TypeOf<T>::has_custom_serialization>>
|
||||
inline bool deserialize(T* v) const {
|
||||
return dap::Deserializer::deserialize(v);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline bool deserialize(dap::array<T>* v) const {
|
||||
return dap::Deserializer::deserialize(v);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline bool deserialize(dap::optional<T>* v) const {
|
||||
return dap::Deserializer::deserialize(v);
|
||||
}
|
||||
|
||||
template <typename T0, typename... Types>
|
||||
inline bool deserialize(dap::variant<T0, Types...>* v) const {
|
||||
return dap::Deserializer::deserialize(v);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline bool field(const std::string& name, T* v) const {
|
||||
return dap::Deserializer::deserialize(name, v);
|
||||
}
|
||||
|
||||
private:
|
||||
NlohmannDeserializer(const nlohmann::json*);
|
||||
const nlohmann::json* const json;
|
||||
const bool ownsJson;
|
||||
};
|
||||
|
||||
struct NlohmannSerializer : public dap::Serializer {
|
||||
NlohmannSerializer();
|
||||
~NlohmannSerializer();
|
||||
|
||||
std::string dump() const;
|
||||
|
||||
// dap::Serializer compliance
|
||||
bool serialize(boolean v) override;
|
||||
bool serialize(integer v) override;
|
||||
bool serialize(number v) override;
|
||||
bool serialize(const string& v) override;
|
||||
bool serialize(const dap::object& v) override;
|
||||
bool serialize(const any& v) override;
|
||||
bool array(size_t count,
|
||||
const std::function<bool(dap::Serializer*)>&) override;
|
||||
bool object(const std::function<bool(dap::FieldSerializer*)>&) override;
|
||||
void remove() override;
|
||||
|
||||
// Unhide base overloads
|
||||
template <typename T,
|
||||
typename = std::enable_if<TypeOf<T>::has_custom_serialization>>
|
||||
inline bool serialize(const T& v) {
|
||||
return dap::Serializer::serialize(v);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline bool serialize(const dap::array<T>& v) {
|
||||
return dap::Serializer::serialize(v);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline bool serialize(const dap::optional<T>& v) {
|
||||
return dap::Serializer::serialize(v);
|
||||
}
|
||||
|
||||
template <typename T0, typename... Types>
|
||||
inline bool serialize(const dap::variant<T0, Types...>& v) {
|
||||
return dap::Serializer::serialize(v);
|
||||
}
|
||||
|
||||
inline bool serialize(const char* v) { return dap::Serializer::serialize(v); }
|
||||
|
||||
private:
|
||||
NlohmannSerializer(nlohmann::json*);
|
||||
nlohmann::json* const json;
|
||||
const bool ownsJson;
|
||||
bool removed = false;
|
||||
};
|
||||
|
||||
} // namespace json
|
||||
} // namespace dap
|
||||
|
||||
#endif // dap_nlohmann_json_serializer_h
|
||||
23
libraries/cppdap/src/null_json_serializer.cpp
Normal file
23
libraries/cppdap/src/null_json_serializer.cpp
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
// Copyright 2020 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "null_json_serializer.h"
|
||||
|
||||
namespace dap {
|
||||
namespace json {
|
||||
|
||||
NullDeserializer NullDeserializer::instance;
|
||||
|
||||
} // namespace json
|
||||
} // namespace dap
|
||||
47
libraries/cppdap/src/null_json_serializer.h
Normal file
47
libraries/cppdap/src/null_json_serializer.h
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
// Copyright 2020 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifndef dap_null_json_serializer_h
|
||||
#define dap_null_json_serializer_h
|
||||
|
||||
#include "dap/protocol.h"
|
||||
#include "dap/serialization.h"
|
||||
#include "dap/types.h"
|
||||
|
||||
namespace dap {
|
||||
namespace json {
|
||||
|
||||
struct NullDeserializer : public dap::Deserializer {
|
||||
static NullDeserializer instance;
|
||||
|
||||
bool deserialize(dap::boolean*) const override { return false; }
|
||||
bool deserialize(dap::integer*) const override { return false; }
|
||||
bool deserialize(dap::number*) const override { return false; }
|
||||
bool deserialize(dap::string*) const override { return false; }
|
||||
bool deserialize(dap::object*) const override { return false; }
|
||||
bool deserialize(dap::any*) const override { return false; }
|
||||
size_t count() const override { return 0; }
|
||||
bool array(const std::function<bool(dap::Deserializer*)>&) const override {
|
||||
return false;
|
||||
}
|
||||
bool field(const std::string&,
|
||||
const std::function<bool(dap::Deserializer*)>&) const override {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace json
|
||||
} // namespace dap
|
||||
|
||||
#endif // dap_null_json_serializer_h
|
||||
169
libraries/cppdap/src/optional_test.cpp
Normal file
169
libraries/cppdap/src/optional_test.cpp
Normal file
|
|
@ -0,0 +1,169 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "dap/optional.h"
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include <string>
|
||||
|
||||
TEST(Optional, EmptyConstruct) {
|
||||
dap::optional<std::string> opt;
|
||||
ASSERT_FALSE(opt);
|
||||
ASSERT_FALSE(opt.has_value());
|
||||
}
|
||||
|
||||
TEST(Optional, ValueConstruct) {
|
||||
dap::optional<int> opt(10);
|
||||
ASSERT_TRUE(opt);
|
||||
ASSERT_TRUE(opt.has_value());
|
||||
ASSERT_EQ(opt.value(), 10);
|
||||
}
|
||||
|
||||
TEST(Optional, CopyConstruct) {
|
||||
dap::optional<std::string> a("meow");
|
||||
dap::optional<std::string> b(a);
|
||||
ASSERT_EQ(a, b);
|
||||
ASSERT_EQ(a.value(), "meow");
|
||||
ASSERT_EQ(b.value(), "meow");
|
||||
}
|
||||
|
||||
TEST(Optional, CopyCastConstruct) {
|
||||
dap::optional<int> a(10);
|
||||
dap::optional<uint16_t> b(a);
|
||||
ASSERT_EQ(a, b);
|
||||
ASSERT_EQ(b.value(), (uint16_t)10);
|
||||
}
|
||||
|
||||
TEST(Optional, MoveConstruct) {
|
||||
dap::optional<std::string> a("meow");
|
||||
dap::optional<std::string> b(std::move(a));
|
||||
ASSERT_EQ(b.value(), "meow");
|
||||
}
|
||||
|
||||
TEST(Optional, MoveCastConstruct) {
|
||||
dap::optional<int> a(10);
|
||||
dap::optional<uint16_t> b(std::move(a));
|
||||
ASSERT_EQ(b.value(), (uint16_t)10);
|
||||
}
|
||||
|
||||
TEST(Optional, AssignValue) {
|
||||
dap::optional<std::string> a;
|
||||
std::string b = "meow";
|
||||
a = b;
|
||||
ASSERT_EQ(a.value(), "meow");
|
||||
ASSERT_EQ(b, "meow");
|
||||
}
|
||||
|
||||
TEST(Optional, AssignOptional) {
|
||||
dap::optional<std::string> a;
|
||||
dap::optional<std::string> b("meow");
|
||||
a = b;
|
||||
ASSERT_EQ(a.value(), "meow");
|
||||
ASSERT_EQ(b.value(), "meow");
|
||||
}
|
||||
|
||||
TEST(Optional, MoveAssignOptional) {
|
||||
dap::optional<std::string> a;
|
||||
dap::optional<std::string> b("meow");
|
||||
a = std::move(b);
|
||||
ASSERT_EQ(a.value(), "meow");
|
||||
}
|
||||
|
||||
TEST(Optional, StarDeref) {
|
||||
dap::optional<std::string> a("meow");
|
||||
ASSERT_EQ(*a, "meow");
|
||||
}
|
||||
|
||||
TEST(Optional, StarDerefConst) {
|
||||
const dap::optional<std::string> a("meow");
|
||||
ASSERT_EQ(*a, "meow");
|
||||
}
|
||||
|
||||
TEST(Optional, ArrowDeref) {
|
||||
struct S {
|
||||
int i;
|
||||
};
|
||||
dap::optional<S> a(S{10});
|
||||
ASSERT_EQ(a->i, 10);
|
||||
}
|
||||
|
||||
TEST(Optional, ArrowDerefConst) {
|
||||
struct S {
|
||||
int i;
|
||||
};
|
||||
const dap::optional<S> a(S{10});
|
||||
ASSERT_EQ(a->i, 10);
|
||||
}
|
||||
|
||||
TEST(Optional, Value) {
|
||||
const dap::optional<std::string> a("meow");
|
||||
ASSERT_EQ(a.value(), "meow");
|
||||
}
|
||||
|
||||
TEST(Optional, ValueDefault) {
|
||||
const dap::optional<std::string> a;
|
||||
const dap::optional<std::string> b("woof");
|
||||
ASSERT_EQ(a.value("meow"), "meow");
|
||||
ASSERT_EQ(b.value("meow"), "woof");
|
||||
}
|
||||
|
||||
TEST(Optional, CompareLT) {
|
||||
ASSERT_FALSE(dap::optional<int>(5) < dap::optional<int>(3));
|
||||
ASSERT_FALSE(dap::optional<int>(5) < dap::optional<int>(5));
|
||||
ASSERT_TRUE(dap::optional<int>(5) < dap::optional<int>(10));
|
||||
ASSERT_TRUE(dap::optional<int>() < dap::optional<int>(10));
|
||||
ASSERT_FALSE(dap::optional<int>() < dap::optional<int>());
|
||||
}
|
||||
|
||||
TEST(Optional, CompareLE) {
|
||||
ASSERT_FALSE(dap::optional<int>(5) <= dap::optional<int>(3));
|
||||
ASSERT_TRUE(dap::optional<int>(5) <= dap::optional<int>(5));
|
||||
ASSERT_TRUE(dap::optional<int>(5) <= dap::optional<int>(10));
|
||||
ASSERT_TRUE(dap::optional<int>() <= dap::optional<int>(10));
|
||||
ASSERT_TRUE(dap::optional<int>() <= dap::optional<int>());
|
||||
}
|
||||
|
||||
TEST(Optional, CompareGT) {
|
||||
ASSERT_TRUE(dap::optional<int>(5) > dap::optional<int>(3));
|
||||
ASSERT_FALSE(dap::optional<int>(5) > dap::optional<int>(5));
|
||||
ASSERT_FALSE(dap::optional<int>(5) > dap::optional<int>(10));
|
||||
ASSERT_FALSE(dap::optional<int>() > dap::optional<int>(10));
|
||||
ASSERT_FALSE(dap::optional<int>() > dap::optional<int>());
|
||||
}
|
||||
|
||||
TEST(Optional, CompareGE) {
|
||||
ASSERT_TRUE(dap::optional<int>(5) >= dap::optional<int>(3));
|
||||
ASSERT_TRUE(dap::optional<int>(5) >= dap::optional<int>(5));
|
||||
ASSERT_FALSE(dap::optional<int>(5) >= dap::optional<int>(10));
|
||||
ASSERT_FALSE(dap::optional<int>() >= dap::optional<int>(10));
|
||||
ASSERT_TRUE(dap::optional<int>() >= dap::optional<int>());
|
||||
}
|
||||
|
||||
TEST(Optional, CompareEQ) {
|
||||
ASSERT_FALSE(dap::optional<int>(5) == dap::optional<int>(3));
|
||||
ASSERT_TRUE(dap::optional<int>(5) == dap::optional<int>(5));
|
||||
ASSERT_FALSE(dap::optional<int>(5) == dap::optional<int>(10));
|
||||
ASSERT_FALSE(dap::optional<int>() == dap::optional<int>(10));
|
||||
ASSERT_TRUE(dap::optional<int>() == dap::optional<int>());
|
||||
}
|
||||
|
||||
TEST(Optional, CompareNEQ) {
|
||||
ASSERT_TRUE(dap::optional<int>(5) != dap::optional<int>(3));
|
||||
ASSERT_FALSE(dap::optional<int>(5) != dap::optional<int>(5));
|
||||
ASSERT_TRUE(dap::optional<int>(5) != dap::optional<int>(10));
|
||||
ASSERT_TRUE(dap::optional<int>() != dap::optional<int>(10));
|
||||
ASSERT_FALSE(dap::optional<int>() != dap::optional<int>());
|
||||
}
|
||||
127
libraries/cppdap/src/protocol_events.cpp
Normal file
127
libraries/cppdap/src/protocol_events.cpp
Normal file
|
|
@ -0,0 +1,127 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// Generated with protocol_gen.go -- do not edit this file.
|
||||
// go run scripts/protocol_gen/protocol_gen.go
|
||||
//
|
||||
// DAP version 1.68.0
|
||||
|
||||
#include "dap/protocol.h"
|
||||
|
||||
namespace dap {
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(BreakpointEvent,
|
||||
"breakpoint",
|
||||
DAP_FIELD(breakpoint, "breakpoint"),
|
||||
DAP_FIELD(reason, "reason"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(CapabilitiesEvent,
|
||||
"capabilities",
|
||||
DAP_FIELD(capabilities, "capabilities"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ContinuedEvent,
|
||||
"continued",
|
||||
DAP_FIELD(allThreadsContinued,
|
||||
"allThreadsContinued"),
|
||||
DAP_FIELD(threadId, "threadId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ExitedEvent,
|
||||
"exited",
|
||||
DAP_FIELD(exitCode, "exitCode"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(InitializedEvent, "initialized");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(InvalidatedEvent,
|
||||
"invalidated",
|
||||
DAP_FIELD(areas, "areas"),
|
||||
DAP_FIELD(stackFrameId, "stackFrameId"),
|
||||
DAP_FIELD(threadId, "threadId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(LoadedSourceEvent,
|
||||
"loadedSource",
|
||||
DAP_FIELD(reason, "reason"),
|
||||
DAP_FIELD(source, "source"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(MemoryEvent,
|
||||
"memory",
|
||||
DAP_FIELD(count, "count"),
|
||||
DAP_FIELD(memoryReference, "memoryReference"),
|
||||
DAP_FIELD(offset, "offset"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ModuleEvent,
|
||||
"module",
|
||||
DAP_FIELD(module, "module"),
|
||||
DAP_FIELD(reason, "reason"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(OutputEvent,
|
||||
"output",
|
||||
DAP_FIELD(category, "category"),
|
||||
DAP_FIELD(column, "column"),
|
||||
DAP_FIELD(data, "data"),
|
||||
DAP_FIELD(group, "group"),
|
||||
DAP_FIELD(line, "line"),
|
||||
DAP_FIELD(locationReference, "locationReference"),
|
||||
DAP_FIELD(output, "output"),
|
||||
DAP_FIELD(source, "source"),
|
||||
DAP_FIELD(variablesReference,
|
||||
"variablesReference"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ProcessEvent,
|
||||
"process",
|
||||
DAP_FIELD(isLocalProcess, "isLocalProcess"),
|
||||
DAP_FIELD(name, "name"),
|
||||
DAP_FIELD(pointerSize, "pointerSize"),
|
||||
DAP_FIELD(startMethod, "startMethod"),
|
||||
DAP_FIELD(systemProcessId, "systemProcessId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ProgressEndEvent,
|
||||
"progressEnd",
|
||||
DAP_FIELD(message, "message"),
|
||||
DAP_FIELD(progressId, "progressId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ProgressStartEvent,
|
||||
"progressStart",
|
||||
DAP_FIELD(cancellable, "cancellable"),
|
||||
DAP_FIELD(message, "message"),
|
||||
DAP_FIELD(percentage, "percentage"),
|
||||
DAP_FIELD(progressId, "progressId"),
|
||||
DAP_FIELD(requestId, "requestId"),
|
||||
DAP_FIELD(title, "title"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ProgressUpdateEvent,
|
||||
"progressUpdate",
|
||||
DAP_FIELD(message, "message"),
|
||||
DAP_FIELD(percentage, "percentage"),
|
||||
DAP_FIELD(progressId, "progressId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(StoppedEvent,
|
||||
"stopped",
|
||||
DAP_FIELD(allThreadsStopped, "allThreadsStopped"),
|
||||
DAP_FIELD(description, "description"),
|
||||
DAP_FIELD(hitBreakpointIds, "hitBreakpointIds"),
|
||||
DAP_FIELD(preserveFocusHint, "preserveFocusHint"),
|
||||
DAP_FIELD(reason, "reason"),
|
||||
DAP_FIELD(text, "text"),
|
||||
DAP_FIELD(threadId, "threadId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(TerminatedEvent,
|
||||
"terminated",
|
||||
DAP_FIELD(restart, "restart"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ThreadEvent,
|
||||
"thread",
|
||||
DAP_FIELD(reason, "reason"),
|
||||
DAP_FIELD(threadId, "threadId"));
|
||||
|
||||
} // namespace dap
|
||||
293
libraries/cppdap/src/protocol_requests.cpp
Normal file
293
libraries/cppdap/src/protocol_requests.cpp
Normal file
|
|
@ -0,0 +1,293 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// Generated with protocol_gen.go -- do not edit this file.
|
||||
// go run scripts/protocol_gen/protocol_gen.go
|
||||
//
|
||||
// DAP version 1.68.0
|
||||
|
||||
#include "dap/protocol.h"
|
||||
|
||||
namespace dap {
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(AttachRequest,
|
||||
"attach",
|
||||
DAP_FIELD(restart, "__restart"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(BreakpointLocationsRequest,
|
||||
"breakpointLocations",
|
||||
DAP_FIELD(column, "column"),
|
||||
DAP_FIELD(endColumn, "endColumn"),
|
||||
DAP_FIELD(endLine, "endLine"),
|
||||
DAP_FIELD(line, "line"),
|
||||
DAP_FIELD(source, "source"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(CancelRequest,
|
||||
"cancel",
|
||||
DAP_FIELD(progressId, "progressId"),
|
||||
DAP_FIELD(requestId, "requestId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(CompletionsRequest,
|
||||
"completions",
|
||||
DAP_FIELD(column, "column"),
|
||||
DAP_FIELD(frameId, "frameId"),
|
||||
DAP_FIELD(line, "line"),
|
||||
DAP_FIELD(text, "text"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ConfigurationDoneRequest, "configurationDone");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ContinueRequest,
|
||||
"continue",
|
||||
DAP_FIELD(singleThread, "singleThread"),
|
||||
DAP_FIELD(threadId, "threadId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(DataBreakpointInfoRequest,
|
||||
"dataBreakpointInfo",
|
||||
DAP_FIELD(asAddress, "asAddress"),
|
||||
DAP_FIELD(bytes, "bytes"),
|
||||
DAP_FIELD(frameId, "frameId"),
|
||||
DAP_FIELD(mode, "mode"),
|
||||
DAP_FIELD(name, "name"),
|
||||
DAP_FIELD(variablesReference,
|
||||
"variablesReference"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(DisassembleRequest,
|
||||
"disassemble",
|
||||
DAP_FIELD(instructionCount, "instructionCount"),
|
||||
DAP_FIELD(instructionOffset, "instructionOffset"),
|
||||
DAP_FIELD(memoryReference, "memoryReference"),
|
||||
DAP_FIELD(offset, "offset"),
|
||||
DAP_FIELD(resolveSymbols, "resolveSymbols"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(DisconnectRequest,
|
||||
"disconnect",
|
||||
DAP_FIELD(restart, "restart"),
|
||||
DAP_FIELD(suspendDebuggee, "suspendDebuggee"),
|
||||
DAP_FIELD(terminateDebuggee,
|
||||
"terminateDebuggee"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(EvaluateRequest,
|
||||
"evaluate",
|
||||
DAP_FIELD(column, "column"),
|
||||
DAP_FIELD(context, "context"),
|
||||
DAP_FIELD(expression, "expression"),
|
||||
DAP_FIELD(format, "format"),
|
||||
DAP_FIELD(frameId, "frameId"),
|
||||
DAP_FIELD(line, "line"),
|
||||
DAP_FIELD(source, "source"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ExceptionInfoRequest,
|
||||
"exceptionInfo",
|
||||
DAP_FIELD(threadId, "threadId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(GotoRequest,
|
||||
"goto",
|
||||
DAP_FIELD(targetId, "targetId"),
|
||||
DAP_FIELD(threadId, "threadId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(GotoTargetsRequest,
|
||||
"gotoTargets",
|
||||
DAP_FIELD(column, "column"),
|
||||
DAP_FIELD(line, "line"),
|
||||
DAP_FIELD(source, "source"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(
|
||||
InitializeRequest,
|
||||
"initialize",
|
||||
DAP_FIELD(adapterID, "adapterID"),
|
||||
DAP_FIELD(clientID, "clientID"),
|
||||
DAP_FIELD(clientName, "clientName"),
|
||||
DAP_FIELD(columnsStartAt1, "columnsStartAt1"),
|
||||
DAP_FIELD(linesStartAt1, "linesStartAt1"),
|
||||
DAP_FIELD(locale, "locale"),
|
||||
DAP_FIELD(pathFormat, "pathFormat"),
|
||||
DAP_FIELD(supportsANSIStyling, "supportsANSIStyling"),
|
||||
DAP_FIELD(supportsArgsCanBeInterpretedByShell,
|
||||
"supportsArgsCanBeInterpretedByShell"),
|
||||
DAP_FIELD(supportsInvalidatedEvent, "supportsInvalidatedEvent"),
|
||||
DAP_FIELD(supportsMemoryEvent, "supportsMemoryEvent"),
|
||||
DAP_FIELD(supportsMemoryReferences, "supportsMemoryReferences"),
|
||||
DAP_FIELD(supportsProgressReporting, "supportsProgressReporting"),
|
||||
DAP_FIELD(supportsRunInTerminalRequest, "supportsRunInTerminalRequest"),
|
||||
DAP_FIELD(supportsStartDebuggingRequest, "supportsStartDebuggingRequest"),
|
||||
DAP_FIELD(supportsVariablePaging, "supportsVariablePaging"),
|
||||
DAP_FIELD(supportsVariableType, "supportsVariableType"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(LaunchRequest,
|
||||
"launch",
|
||||
DAP_FIELD(restart, "__restart"),
|
||||
DAP_FIELD(noDebug, "noDebug"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(LoadedSourcesRequest, "loadedSources");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(LocationsRequest,
|
||||
"locations",
|
||||
DAP_FIELD(locationReference,
|
||||
"locationReference"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ModulesRequest,
|
||||
"modules",
|
||||
DAP_FIELD(moduleCount, "moduleCount"),
|
||||
DAP_FIELD(startModule, "startModule"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(NextRequest,
|
||||
"next",
|
||||
DAP_FIELD(granularity, "granularity"),
|
||||
DAP_FIELD(singleThread, "singleThread"),
|
||||
DAP_FIELD(threadId, "threadId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(PauseRequest,
|
||||
"pause",
|
||||
DAP_FIELD(threadId, "threadId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ReadMemoryRequest,
|
||||
"readMemory",
|
||||
DAP_FIELD(count, "count"),
|
||||
DAP_FIELD(memoryReference, "memoryReference"),
|
||||
DAP_FIELD(offset, "offset"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(RestartFrameRequest,
|
||||
"restartFrame",
|
||||
DAP_FIELD(frameId, "frameId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(RestartRequest,
|
||||
"restart",
|
||||
DAP_FIELD(arguments, "arguments"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ReverseContinueRequest,
|
||||
"reverseContinue",
|
||||
DAP_FIELD(singleThread, "singleThread"),
|
||||
DAP_FIELD(threadId, "threadId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(RunInTerminalRequest,
|
||||
"runInTerminal",
|
||||
DAP_FIELD(args, "args"),
|
||||
DAP_FIELD(argsCanBeInterpretedByShell,
|
||||
"argsCanBeInterpretedByShell"),
|
||||
DAP_FIELD(cwd, "cwd"),
|
||||
DAP_FIELD(env, "env"),
|
||||
DAP_FIELD(kind, "kind"),
|
||||
DAP_FIELD(title, "title"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ScopesRequest,
|
||||
"scopes",
|
||||
DAP_FIELD(frameId, "frameId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(SetBreakpointsRequest,
|
||||
"setBreakpoints",
|
||||
DAP_FIELD(breakpoints, "breakpoints"),
|
||||
DAP_FIELD(lines, "lines"),
|
||||
DAP_FIELD(source, "source"),
|
||||
DAP_FIELD(sourceModified, "sourceModified"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(SetDataBreakpointsRequest,
|
||||
"setDataBreakpoints",
|
||||
DAP_FIELD(breakpoints, "breakpoints"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(SetExceptionBreakpointsRequest,
|
||||
"setExceptionBreakpoints",
|
||||
DAP_FIELD(exceptionOptions, "exceptionOptions"),
|
||||
DAP_FIELD(filterOptions, "filterOptions"),
|
||||
DAP_FIELD(filters, "filters"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(SetExpressionRequest,
|
||||
"setExpression",
|
||||
DAP_FIELD(expression, "expression"),
|
||||
DAP_FIELD(format, "format"),
|
||||
DAP_FIELD(frameId, "frameId"),
|
||||
DAP_FIELD(value, "value"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(SetFunctionBreakpointsRequest,
|
||||
"setFunctionBreakpoints",
|
||||
DAP_FIELD(breakpoints, "breakpoints"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(SetInstructionBreakpointsRequest,
|
||||
"setInstructionBreakpoints",
|
||||
DAP_FIELD(breakpoints, "breakpoints"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(SetVariableRequest,
|
||||
"setVariable",
|
||||
DAP_FIELD(format, "format"),
|
||||
DAP_FIELD(name, "name"),
|
||||
DAP_FIELD(value, "value"),
|
||||
DAP_FIELD(variablesReference,
|
||||
"variablesReference"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(SourceRequest,
|
||||
"source",
|
||||
DAP_FIELD(source, "source"),
|
||||
DAP_FIELD(sourceReference, "sourceReference"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(StackTraceRequest,
|
||||
"stackTrace",
|
||||
DAP_FIELD(format, "format"),
|
||||
DAP_FIELD(levels, "levels"),
|
||||
DAP_FIELD(startFrame, "startFrame"),
|
||||
DAP_FIELD(threadId, "threadId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(StartDebuggingRequest,
|
||||
"startDebugging",
|
||||
DAP_FIELD(configuration, "configuration"),
|
||||
DAP_FIELD(request, "request"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(StepBackRequest,
|
||||
"stepBack",
|
||||
DAP_FIELD(granularity, "granularity"),
|
||||
DAP_FIELD(singleThread, "singleThread"),
|
||||
DAP_FIELD(threadId, "threadId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(StepInRequest,
|
||||
"stepIn",
|
||||
DAP_FIELD(granularity, "granularity"),
|
||||
DAP_FIELD(singleThread, "singleThread"),
|
||||
DAP_FIELD(targetId, "targetId"),
|
||||
DAP_FIELD(threadId, "threadId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(StepInTargetsRequest,
|
||||
"stepInTargets",
|
||||
DAP_FIELD(frameId, "frameId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(StepOutRequest,
|
||||
"stepOut",
|
||||
DAP_FIELD(granularity, "granularity"),
|
||||
DAP_FIELD(singleThread, "singleThread"),
|
||||
DAP_FIELD(threadId, "threadId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(TerminateRequest,
|
||||
"terminate",
|
||||
DAP_FIELD(restart, "restart"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(TerminateThreadsRequest,
|
||||
"terminateThreads",
|
||||
DAP_FIELD(threadIds, "threadIds"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ThreadsRequest, "threads");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(VariablesRequest,
|
||||
"variables",
|
||||
DAP_FIELD(count, "count"),
|
||||
DAP_FIELD(filter, "filter"),
|
||||
DAP_FIELD(format, "format"),
|
||||
DAP_FIELD(start, "start"),
|
||||
DAP_FIELD(variablesReference,
|
||||
"variablesReference"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(WriteMemoryRequest,
|
||||
"writeMemory",
|
||||
DAP_FIELD(allowPartial, "allowPartial"),
|
||||
DAP_FIELD(data, "data"),
|
||||
DAP_FIELD(memoryReference, "memoryReference"),
|
||||
DAP_FIELD(offset, "offset"));
|
||||
|
||||
} // namespace dap
|
||||
262
libraries/cppdap/src/protocol_response.cpp
Normal file
262
libraries/cppdap/src/protocol_response.cpp
Normal file
|
|
@ -0,0 +1,262 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// Generated with protocol_gen.go -- do not edit this file.
|
||||
// go run scripts/protocol_gen/protocol_gen.go
|
||||
//
|
||||
// DAP version 1.68.0
|
||||
|
||||
#include "dap/protocol.h"
|
||||
|
||||
namespace dap {
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(AttachResponse, "");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(BreakpointLocationsResponse,
|
||||
"",
|
||||
DAP_FIELD(breakpoints, "breakpoints"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(CancelResponse, "");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(CompletionsResponse,
|
||||
"",
|
||||
DAP_FIELD(targets, "targets"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ConfigurationDoneResponse, "");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ContinueResponse,
|
||||
"",
|
||||
DAP_FIELD(allThreadsContinued,
|
||||
"allThreadsContinued"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(DataBreakpointInfoResponse,
|
||||
"",
|
||||
DAP_FIELD(accessTypes, "accessTypes"),
|
||||
DAP_FIELD(canPersist, "canPersist"),
|
||||
DAP_FIELD(dataId, "dataId"),
|
||||
DAP_FIELD(description, "description"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(DisassembleResponse,
|
||||
"",
|
||||
DAP_FIELD(instructions, "instructions"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(DisconnectResponse, "");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ErrorResponse, "", DAP_FIELD(error, "error"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(EvaluateResponse,
|
||||
"",
|
||||
DAP_FIELD(indexedVariables, "indexedVariables"),
|
||||
DAP_FIELD(memoryReference, "memoryReference"),
|
||||
DAP_FIELD(namedVariables, "namedVariables"),
|
||||
DAP_FIELD(presentationHint, "presentationHint"),
|
||||
DAP_FIELD(result, "result"),
|
||||
DAP_FIELD(type, "type"),
|
||||
DAP_FIELD(valueLocationReference,
|
||||
"valueLocationReference"),
|
||||
DAP_FIELD(variablesReference,
|
||||
"variablesReference"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ExceptionInfoResponse,
|
||||
"",
|
||||
DAP_FIELD(breakMode, "breakMode"),
|
||||
DAP_FIELD(description, "description"),
|
||||
DAP_FIELD(details, "details"),
|
||||
DAP_FIELD(exceptionId, "exceptionId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(GotoResponse, "");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(GotoTargetsResponse,
|
||||
"",
|
||||
DAP_FIELD(targets, "targets"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(
|
||||
InitializeResponse,
|
||||
"",
|
||||
DAP_FIELD(additionalModuleColumns, "additionalModuleColumns"),
|
||||
DAP_FIELD(breakpointModes, "breakpointModes"),
|
||||
DAP_FIELD(completionTriggerCharacters, "completionTriggerCharacters"),
|
||||
DAP_FIELD(exceptionBreakpointFilters, "exceptionBreakpointFilters"),
|
||||
DAP_FIELD(supportSuspendDebuggee, "supportSuspendDebuggee"),
|
||||
DAP_FIELD(supportTerminateDebuggee, "supportTerminateDebuggee"),
|
||||
DAP_FIELD(supportedChecksumAlgorithms, "supportedChecksumAlgorithms"),
|
||||
DAP_FIELD(supportsANSIStyling, "supportsANSIStyling"),
|
||||
DAP_FIELD(supportsBreakpointLocationsRequest,
|
||||
"supportsBreakpointLocationsRequest"),
|
||||
DAP_FIELD(supportsCancelRequest, "supportsCancelRequest"),
|
||||
DAP_FIELD(supportsClipboardContext, "supportsClipboardContext"),
|
||||
DAP_FIELD(supportsCompletionsRequest, "supportsCompletionsRequest"),
|
||||
DAP_FIELD(supportsConditionalBreakpoints, "supportsConditionalBreakpoints"),
|
||||
DAP_FIELD(supportsConfigurationDoneRequest,
|
||||
"supportsConfigurationDoneRequest"),
|
||||
DAP_FIELD(supportsDataBreakpointBytes, "supportsDataBreakpointBytes"),
|
||||
DAP_FIELD(supportsDataBreakpoints, "supportsDataBreakpoints"),
|
||||
DAP_FIELD(supportsDelayedStackTraceLoading,
|
||||
"supportsDelayedStackTraceLoading"),
|
||||
DAP_FIELD(supportsDisassembleRequest, "supportsDisassembleRequest"),
|
||||
DAP_FIELD(supportsEvaluateForHovers, "supportsEvaluateForHovers"),
|
||||
DAP_FIELD(supportsExceptionFilterOptions, "supportsExceptionFilterOptions"),
|
||||
DAP_FIELD(supportsExceptionInfoRequest, "supportsExceptionInfoRequest"),
|
||||
DAP_FIELD(supportsExceptionOptions, "supportsExceptionOptions"),
|
||||
DAP_FIELD(supportsFunctionBreakpoints, "supportsFunctionBreakpoints"),
|
||||
DAP_FIELD(supportsGotoTargetsRequest, "supportsGotoTargetsRequest"),
|
||||
DAP_FIELD(supportsHitConditionalBreakpoints,
|
||||
"supportsHitConditionalBreakpoints"),
|
||||
DAP_FIELD(supportsInstructionBreakpoints, "supportsInstructionBreakpoints"),
|
||||
DAP_FIELD(supportsLoadedSourcesRequest, "supportsLoadedSourcesRequest"),
|
||||
DAP_FIELD(supportsLogPoints, "supportsLogPoints"),
|
||||
DAP_FIELD(supportsModulesRequest, "supportsModulesRequest"),
|
||||
DAP_FIELD(supportsReadMemoryRequest, "supportsReadMemoryRequest"),
|
||||
DAP_FIELD(supportsRestartFrame, "supportsRestartFrame"),
|
||||
DAP_FIELD(supportsRestartRequest, "supportsRestartRequest"),
|
||||
DAP_FIELD(supportsSetExpression, "supportsSetExpression"),
|
||||
DAP_FIELD(supportsSetVariable, "supportsSetVariable"),
|
||||
DAP_FIELD(supportsSingleThreadExecutionRequests,
|
||||
"supportsSingleThreadExecutionRequests"),
|
||||
DAP_FIELD(supportsStepBack, "supportsStepBack"),
|
||||
DAP_FIELD(supportsStepInTargetsRequest, "supportsStepInTargetsRequest"),
|
||||
DAP_FIELD(supportsSteppingGranularity, "supportsSteppingGranularity"),
|
||||
DAP_FIELD(supportsTerminateRequest, "supportsTerminateRequest"),
|
||||
DAP_FIELD(supportsTerminateThreadsRequest,
|
||||
"supportsTerminateThreadsRequest"),
|
||||
DAP_FIELD(supportsValueFormattingOptions, "supportsValueFormattingOptions"),
|
||||
DAP_FIELD(supportsWriteMemoryRequest, "supportsWriteMemoryRequest"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(LaunchResponse, "");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(LoadedSourcesResponse,
|
||||
"",
|
||||
DAP_FIELD(sources, "sources"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(LocationsResponse,
|
||||
"",
|
||||
DAP_FIELD(column, "column"),
|
||||
DAP_FIELD(endColumn, "endColumn"),
|
||||
DAP_FIELD(endLine, "endLine"),
|
||||
DAP_FIELD(line, "line"),
|
||||
DAP_FIELD(source, "source"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ModulesResponse,
|
||||
"",
|
||||
DAP_FIELD(modules, "modules"),
|
||||
DAP_FIELD(totalModules, "totalModules"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(NextResponse, "");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(PauseResponse, "");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ReadMemoryResponse,
|
||||
"",
|
||||
DAP_FIELD(address, "address"),
|
||||
DAP_FIELD(data, "data"),
|
||||
DAP_FIELD(unreadableBytes, "unreadableBytes"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(RestartFrameResponse, "");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(RestartResponse, "");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ReverseContinueResponse, "");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(RunInTerminalResponse,
|
||||
"",
|
||||
DAP_FIELD(processId, "processId"),
|
||||
DAP_FIELD(shellProcessId, "shellProcessId"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ScopesResponse, "", DAP_FIELD(scopes, "scopes"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(SetBreakpointsResponse,
|
||||
"",
|
||||
DAP_FIELD(breakpoints, "breakpoints"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(SetDataBreakpointsResponse,
|
||||
"",
|
||||
DAP_FIELD(breakpoints, "breakpoints"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(SetExceptionBreakpointsResponse,
|
||||
"",
|
||||
DAP_FIELD(breakpoints, "breakpoints"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(SetExpressionResponse,
|
||||
"",
|
||||
DAP_FIELD(indexedVariables, "indexedVariables"),
|
||||
DAP_FIELD(memoryReference, "memoryReference"),
|
||||
DAP_FIELD(namedVariables, "namedVariables"),
|
||||
DAP_FIELD(presentationHint, "presentationHint"),
|
||||
DAP_FIELD(type, "type"),
|
||||
DAP_FIELD(value, "value"),
|
||||
DAP_FIELD(valueLocationReference,
|
||||
"valueLocationReference"),
|
||||
DAP_FIELD(variablesReference,
|
||||
"variablesReference"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(SetFunctionBreakpointsResponse,
|
||||
"",
|
||||
DAP_FIELD(breakpoints, "breakpoints"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(SetInstructionBreakpointsResponse,
|
||||
"",
|
||||
DAP_FIELD(breakpoints, "breakpoints"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(SetVariableResponse,
|
||||
"",
|
||||
DAP_FIELD(indexedVariables, "indexedVariables"),
|
||||
DAP_FIELD(memoryReference, "memoryReference"),
|
||||
DAP_FIELD(namedVariables, "namedVariables"),
|
||||
DAP_FIELD(type, "type"),
|
||||
DAP_FIELD(value, "value"),
|
||||
DAP_FIELD(valueLocationReference,
|
||||
"valueLocationReference"),
|
||||
DAP_FIELD(variablesReference,
|
||||
"variablesReference"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(SourceResponse,
|
||||
"",
|
||||
DAP_FIELD(content, "content"),
|
||||
DAP_FIELD(mimeType, "mimeType"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(StackTraceResponse,
|
||||
"",
|
||||
DAP_FIELD(stackFrames, "stackFrames"),
|
||||
DAP_FIELD(totalFrames, "totalFrames"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(StartDebuggingResponse, "");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(StepBackResponse, "");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(StepInResponse, "");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(StepInTargetsResponse,
|
||||
"",
|
||||
DAP_FIELD(targets, "targets"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(StepOutResponse, "");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(TerminateResponse, "");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(TerminateThreadsResponse, "");
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ThreadsResponse,
|
||||
"",
|
||||
DAP_FIELD(threads, "threads"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(VariablesResponse,
|
||||
"",
|
||||
DAP_FIELD(variables, "variables"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(WriteMemoryResponse,
|
||||
"",
|
||||
DAP_FIELD(bytesWritten, "bytesWritten"),
|
||||
DAP_FIELD(offset, "offset"));
|
||||
|
||||
} // namespace dap
|
||||
333
libraries/cppdap/src/protocol_types.cpp
Normal file
333
libraries/cppdap/src/protocol_types.cpp
Normal file
|
|
@ -0,0 +1,333 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// Generated with protocol_gen.go -- do not edit this file.
|
||||
// go run scripts/protocol_gen/protocol_gen.go
|
||||
//
|
||||
// DAP version 1.68.0
|
||||
|
||||
#include "dap/protocol.h"
|
||||
|
||||
namespace dap {
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(Checksum,
|
||||
"",
|
||||
DAP_FIELD(algorithm, "algorithm"),
|
||||
DAP_FIELD(checksum, "checksum"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(Source,
|
||||
"",
|
||||
DAP_FIELD(adapterData, "adapterData"),
|
||||
DAP_FIELD(checksums, "checksums"),
|
||||
DAP_FIELD(name, "name"),
|
||||
DAP_FIELD(origin, "origin"),
|
||||
DAP_FIELD(path, "path"),
|
||||
DAP_FIELD(presentationHint, "presentationHint"),
|
||||
DAP_FIELD(sourceReference, "sourceReference"),
|
||||
DAP_FIELD(sources, "sources"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(Breakpoint,
|
||||
"",
|
||||
DAP_FIELD(column, "column"),
|
||||
DAP_FIELD(endColumn, "endColumn"),
|
||||
DAP_FIELD(endLine, "endLine"),
|
||||
DAP_FIELD(id, "id"),
|
||||
DAP_FIELD(instructionReference,
|
||||
"instructionReference"),
|
||||
DAP_FIELD(line, "line"),
|
||||
DAP_FIELD(message, "message"),
|
||||
DAP_FIELD(offset, "offset"),
|
||||
DAP_FIELD(reason, "reason"),
|
||||
DAP_FIELD(source, "source"),
|
||||
DAP_FIELD(verified, "verified"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(BreakpointLocation,
|
||||
"",
|
||||
DAP_FIELD(column, "column"),
|
||||
DAP_FIELD(endColumn, "endColumn"),
|
||||
DAP_FIELD(endLine, "endLine"),
|
||||
DAP_FIELD(line, "line"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ColumnDescriptor,
|
||||
"",
|
||||
DAP_FIELD(attributeName, "attributeName"),
|
||||
DAP_FIELD(format, "format"),
|
||||
DAP_FIELD(label, "label"),
|
||||
DAP_FIELD(type, "type"),
|
||||
DAP_FIELD(width, "width"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(BreakpointMode,
|
||||
"",
|
||||
DAP_FIELD(appliesTo, "appliesTo"),
|
||||
DAP_FIELD(description, "description"),
|
||||
DAP_FIELD(label, "label"),
|
||||
DAP_FIELD(mode, "mode"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ExceptionBreakpointsFilter,
|
||||
"",
|
||||
DAP_FIELD(conditionDescription,
|
||||
"conditionDescription"),
|
||||
DAP_FIELD(def, "default"),
|
||||
DAP_FIELD(description, "description"),
|
||||
DAP_FIELD(filter, "filter"),
|
||||
DAP_FIELD(label, "label"),
|
||||
DAP_FIELD(supportsCondition,
|
||||
"supportsCondition"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(
|
||||
Capabilities,
|
||||
"",
|
||||
DAP_FIELD(additionalModuleColumns, "additionalModuleColumns"),
|
||||
DAP_FIELD(breakpointModes, "breakpointModes"),
|
||||
DAP_FIELD(completionTriggerCharacters, "completionTriggerCharacters"),
|
||||
DAP_FIELD(exceptionBreakpointFilters, "exceptionBreakpointFilters"),
|
||||
DAP_FIELD(supportSuspendDebuggee, "supportSuspendDebuggee"),
|
||||
DAP_FIELD(supportTerminateDebuggee, "supportTerminateDebuggee"),
|
||||
DAP_FIELD(supportedChecksumAlgorithms, "supportedChecksumAlgorithms"),
|
||||
DAP_FIELD(supportsANSIStyling, "supportsANSIStyling"),
|
||||
DAP_FIELD(supportsBreakpointLocationsRequest,
|
||||
"supportsBreakpointLocationsRequest"),
|
||||
DAP_FIELD(supportsCancelRequest, "supportsCancelRequest"),
|
||||
DAP_FIELD(supportsClipboardContext, "supportsClipboardContext"),
|
||||
DAP_FIELD(supportsCompletionsRequest, "supportsCompletionsRequest"),
|
||||
DAP_FIELD(supportsConditionalBreakpoints, "supportsConditionalBreakpoints"),
|
||||
DAP_FIELD(supportsConfigurationDoneRequest,
|
||||
"supportsConfigurationDoneRequest"),
|
||||
DAP_FIELD(supportsDataBreakpointBytes, "supportsDataBreakpointBytes"),
|
||||
DAP_FIELD(supportsDataBreakpoints, "supportsDataBreakpoints"),
|
||||
DAP_FIELD(supportsDelayedStackTraceLoading,
|
||||
"supportsDelayedStackTraceLoading"),
|
||||
DAP_FIELD(supportsDisassembleRequest, "supportsDisassembleRequest"),
|
||||
DAP_FIELD(supportsEvaluateForHovers, "supportsEvaluateForHovers"),
|
||||
DAP_FIELD(supportsExceptionFilterOptions, "supportsExceptionFilterOptions"),
|
||||
DAP_FIELD(supportsExceptionInfoRequest, "supportsExceptionInfoRequest"),
|
||||
DAP_FIELD(supportsExceptionOptions, "supportsExceptionOptions"),
|
||||
DAP_FIELD(supportsFunctionBreakpoints, "supportsFunctionBreakpoints"),
|
||||
DAP_FIELD(supportsGotoTargetsRequest, "supportsGotoTargetsRequest"),
|
||||
DAP_FIELD(supportsHitConditionalBreakpoints,
|
||||
"supportsHitConditionalBreakpoints"),
|
||||
DAP_FIELD(supportsInstructionBreakpoints, "supportsInstructionBreakpoints"),
|
||||
DAP_FIELD(supportsLoadedSourcesRequest, "supportsLoadedSourcesRequest"),
|
||||
DAP_FIELD(supportsLogPoints, "supportsLogPoints"),
|
||||
DAP_FIELD(supportsModulesRequest, "supportsModulesRequest"),
|
||||
DAP_FIELD(supportsReadMemoryRequest, "supportsReadMemoryRequest"),
|
||||
DAP_FIELD(supportsRestartFrame, "supportsRestartFrame"),
|
||||
DAP_FIELD(supportsRestartRequest, "supportsRestartRequest"),
|
||||
DAP_FIELD(supportsSetExpression, "supportsSetExpression"),
|
||||
DAP_FIELD(supportsSetVariable, "supportsSetVariable"),
|
||||
DAP_FIELD(supportsSingleThreadExecutionRequests,
|
||||
"supportsSingleThreadExecutionRequests"),
|
||||
DAP_FIELD(supportsStepBack, "supportsStepBack"),
|
||||
DAP_FIELD(supportsStepInTargetsRequest, "supportsStepInTargetsRequest"),
|
||||
DAP_FIELD(supportsSteppingGranularity, "supportsSteppingGranularity"),
|
||||
DAP_FIELD(supportsTerminateRequest, "supportsTerminateRequest"),
|
||||
DAP_FIELD(supportsTerminateThreadsRequest,
|
||||
"supportsTerminateThreadsRequest"),
|
||||
DAP_FIELD(supportsValueFormattingOptions, "supportsValueFormattingOptions"),
|
||||
DAP_FIELD(supportsWriteMemoryRequest, "supportsWriteMemoryRequest"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(CompletionItem,
|
||||
"",
|
||||
DAP_FIELD(detail, "detail"),
|
||||
DAP_FIELD(label, "label"),
|
||||
DAP_FIELD(length, "length"),
|
||||
DAP_FIELD(selectionLength, "selectionLength"),
|
||||
DAP_FIELD(selectionStart, "selectionStart"),
|
||||
DAP_FIELD(sortText, "sortText"),
|
||||
DAP_FIELD(start, "start"),
|
||||
DAP_FIELD(text, "text"),
|
||||
DAP_FIELD(type, "type"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(DisassembledInstruction,
|
||||
"",
|
||||
DAP_FIELD(address, "address"),
|
||||
DAP_FIELD(column, "column"),
|
||||
DAP_FIELD(endColumn, "endColumn"),
|
||||
DAP_FIELD(endLine, "endLine"),
|
||||
DAP_FIELD(instruction, "instruction"),
|
||||
DAP_FIELD(instructionBytes, "instructionBytes"),
|
||||
DAP_FIELD(line, "line"),
|
||||
DAP_FIELD(location, "location"),
|
||||
DAP_FIELD(presentationHint, "presentationHint"),
|
||||
DAP_FIELD(symbol, "symbol"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(Message,
|
||||
"",
|
||||
DAP_FIELD(format, "format"),
|
||||
DAP_FIELD(id, "id"),
|
||||
DAP_FIELD(sendTelemetry, "sendTelemetry"),
|
||||
DAP_FIELD(showUser, "showUser"),
|
||||
DAP_FIELD(url, "url"),
|
||||
DAP_FIELD(urlLabel, "urlLabel"),
|
||||
DAP_FIELD(variables, "variables"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(VariablePresentationHint,
|
||||
"",
|
||||
DAP_FIELD(attributes, "attributes"),
|
||||
DAP_FIELD(kind, "kind"),
|
||||
DAP_FIELD(lazy, "lazy"),
|
||||
DAP_FIELD(visibility, "visibility"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ValueFormat, "", DAP_FIELD(hex, "hex"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ExceptionDetails,
|
||||
"",
|
||||
DAP_FIELD(evaluateName, "evaluateName"),
|
||||
DAP_FIELD(fullTypeName, "fullTypeName"),
|
||||
DAP_FIELD(innerException, "innerException"),
|
||||
DAP_FIELD(message, "message"),
|
||||
DAP_FIELD(stackTrace, "stackTrace"),
|
||||
DAP_FIELD(typeName, "typeName"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(GotoTarget,
|
||||
"",
|
||||
DAP_FIELD(column, "column"),
|
||||
DAP_FIELD(endColumn, "endColumn"),
|
||||
DAP_FIELD(endLine, "endLine"),
|
||||
DAP_FIELD(id, "id"),
|
||||
DAP_FIELD(instructionPointerReference,
|
||||
"instructionPointerReference"),
|
||||
DAP_FIELD(label, "label"),
|
||||
DAP_FIELD(line, "line"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(Module,
|
||||
"",
|
||||
DAP_FIELD(addressRange, "addressRange"),
|
||||
DAP_FIELD(dateTimeStamp, "dateTimeStamp"),
|
||||
DAP_FIELD(id, "id"),
|
||||
DAP_FIELD(isOptimized, "isOptimized"),
|
||||
DAP_FIELD(isUserCode, "isUserCode"),
|
||||
DAP_FIELD(name, "name"),
|
||||
DAP_FIELD(path, "path"),
|
||||
DAP_FIELD(symbolFilePath, "symbolFilePath"),
|
||||
DAP_FIELD(symbolStatus, "symbolStatus"),
|
||||
DAP_FIELD(version, "version"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(Scope,
|
||||
"",
|
||||
DAP_FIELD(column, "column"),
|
||||
DAP_FIELD(endColumn, "endColumn"),
|
||||
DAP_FIELD(endLine, "endLine"),
|
||||
DAP_FIELD(expensive, "expensive"),
|
||||
DAP_FIELD(indexedVariables, "indexedVariables"),
|
||||
DAP_FIELD(line, "line"),
|
||||
DAP_FIELD(name, "name"),
|
||||
DAP_FIELD(namedVariables, "namedVariables"),
|
||||
DAP_FIELD(presentationHint, "presentationHint"),
|
||||
DAP_FIELD(source, "source"),
|
||||
DAP_FIELD(variablesReference,
|
||||
"variablesReference"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(SourceBreakpoint,
|
||||
"",
|
||||
DAP_FIELD(column, "column"),
|
||||
DAP_FIELD(condition, "condition"),
|
||||
DAP_FIELD(hitCondition, "hitCondition"),
|
||||
DAP_FIELD(line, "line"),
|
||||
DAP_FIELD(logMessage, "logMessage"),
|
||||
DAP_FIELD(mode, "mode"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(DataBreakpoint,
|
||||
"",
|
||||
DAP_FIELD(accessType, "accessType"),
|
||||
DAP_FIELD(condition, "condition"),
|
||||
DAP_FIELD(dataId, "dataId"),
|
||||
DAP_FIELD(hitCondition, "hitCondition"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ExceptionPathSegment,
|
||||
"",
|
||||
DAP_FIELD(names, "names"),
|
||||
DAP_FIELD(negate, "negate"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ExceptionOptions,
|
||||
"",
|
||||
DAP_FIELD(breakMode, "breakMode"),
|
||||
DAP_FIELD(path, "path"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(ExceptionFilterOptions,
|
||||
"",
|
||||
DAP_FIELD(condition, "condition"),
|
||||
DAP_FIELD(filterId, "filterId"),
|
||||
DAP_FIELD(mode, "mode"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(FunctionBreakpoint,
|
||||
"",
|
||||
DAP_FIELD(condition, "condition"),
|
||||
DAP_FIELD(hitCondition, "hitCondition"),
|
||||
DAP_FIELD(name, "name"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(InstructionBreakpoint,
|
||||
"",
|
||||
DAP_FIELD(condition, "condition"),
|
||||
DAP_FIELD(hitCondition, "hitCondition"),
|
||||
DAP_FIELD(instructionReference,
|
||||
"instructionReference"),
|
||||
DAP_FIELD(mode, "mode"),
|
||||
DAP_FIELD(offset, "offset"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(StackFrame,
|
||||
"",
|
||||
DAP_FIELD(canRestart, "canRestart"),
|
||||
DAP_FIELD(column, "column"),
|
||||
DAP_FIELD(endColumn, "endColumn"),
|
||||
DAP_FIELD(endLine, "endLine"),
|
||||
DAP_FIELD(id, "id"),
|
||||
DAP_FIELD(instructionPointerReference,
|
||||
"instructionPointerReference"),
|
||||
DAP_FIELD(line, "line"),
|
||||
DAP_FIELD(moduleId, "moduleId"),
|
||||
DAP_FIELD(name, "name"),
|
||||
DAP_FIELD(presentationHint, "presentationHint"),
|
||||
DAP_FIELD(source, "source"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(StackFrameFormat,
|
||||
"",
|
||||
DAP_FIELD(includeAll, "includeAll"),
|
||||
DAP_FIELD(line, "line"),
|
||||
DAP_FIELD(module, "module"),
|
||||
DAP_FIELD(parameterNames, "parameterNames"),
|
||||
DAP_FIELD(parameterTypes, "parameterTypes"),
|
||||
DAP_FIELD(parameterValues, "parameterValues"),
|
||||
DAP_FIELD(parameters, "parameters"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(StepInTarget,
|
||||
"",
|
||||
DAP_FIELD(column, "column"),
|
||||
DAP_FIELD(endColumn, "endColumn"),
|
||||
DAP_FIELD(endLine, "endLine"),
|
||||
DAP_FIELD(id, "id"),
|
||||
DAP_FIELD(label, "label"),
|
||||
DAP_FIELD(line, "line"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(Thread,
|
||||
"",
|
||||
DAP_FIELD(id, "id"),
|
||||
DAP_FIELD(name, "name"));
|
||||
|
||||
DAP_IMPLEMENT_STRUCT_TYPEINFO(
|
||||
Variable,
|
||||
"",
|
||||
DAP_FIELD(declarationLocationReference, "declarationLocationReference"),
|
||||
DAP_FIELD(evaluateName, "evaluateName"),
|
||||
DAP_FIELD(indexedVariables, "indexedVariables"),
|
||||
DAP_FIELD(memoryReference, "memoryReference"),
|
||||
DAP_FIELD(name, "name"),
|
||||
DAP_FIELD(namedVariables, "namedVariables"),
|
||||
DAP_FIELD(presentationHint, "presentationHint"),
|
||||
DAP_FIELD(type, "type"),
|
||||
DAP_FIELD(value, "value"),
|
||||
DAP_FIELD(valueLocationReference, "valueLocationReference"),
|
||||
DAP_FIELD(variablesReference, "variablesReference"));
|
||||
|
||||
} // namespace dap
|
||||
290
libraries/cppdap/src/rapid_json_serializer.cpp
Normal file
290
libraries/cppdap/src/rapid_json_serializer.cpp
Normal file
|
|
@ -0,0 +1,290 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "rapid_json_serializer.h"
|
||||
|
||||
#include "null_json_serializer.h"
|
||||
|
||||
#include <rapidjson/document.h>
|
||||
#include <rapidjson/prettywriter.h>
|
||||
|
||||
namespace dap {
|
||||
namespace json {
|
||||
|
||||
RapidDeserializer::RapidDeserializer(const std::string& str)
|
||||
: doc(new rapidjson::Document()) {
|
||||
doc->Parse(str.c_str());
|
||||
}
|
||||
|
||||
RapidDeserializer::RapidDeserializer(rapidjson::Value* json) : val(json) {}
|
||||
|
||||
RapidDeserializer::~RapidDeserializer() {
|
||||
delete doc;
|
||||
}
|
||||
|
||||
bool RapidDeserializer::deserialize(dap::boolean* v) const {
|
||||
if (!json()->IsBool()) {
|
||||
return false;
|
||||
}
|
||||
*v = json()->GetBool();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool RapidDeserializer::deserialize(dap::integer* v) const {
|
||||
if (json()->IsInt()) {
|
||||
*v = json()->GetInt();
|
||||
return true;
|
||||
} else if (json()->IsUint()) {
|
||||
*v = static_cast<int64_t>(json()->GetUint());
|
||||
return true;
|
||||
} else if (json()->IsInt64()) {
|
||||
*v = json()->GetInt64();
|
||||
return true;
|
||||
} else if (json()->IsUint64()) {
|
||||
*v = static_cast<int64_t>(json()->GetUint64());
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool RapidDeserializer::deserialize(dap::number* v) const {
|
||||
if (!json()->IsNumber()) {
|
||||
return false;
|
||||
}
|
||||
*v = json()->GetDouble();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool RapidDeserializer::deserialize(dap::string* v) const {
|
||||
if (!json()->IsString()) {
|
||||
return false;
|
||||
}
|
||||
*v = json()->GetString();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool RapidDeserializer::deserialize(dap::object* v) const {
|
||||
v->reserve(json()->MemberCount());
|
||||
for (auto el = json()->MemberBegin(); el != json()->MemberEnd(); el++) {
|
||||
dap::any el_val;
|
||||
RapidDeserializer d(&(el->value));
|
||||
if (!d.deserialize(&el_val)) {
|
||||
return false;
|
||||
}
|
||||
(*v)[el->name.GetString()] = el_val;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool RapidDeserializer::deserialize(dap::any* v) const {
|
||||
if (json()->IsBool()) {
|
||||
*v = dap::boolean(json()->GetBool());
|
||||
} else if (json()->IsDouble()) {
|
||||
*v = dap::number(json()->GetDouble());
|
||||
} else if (json()->IsInt()) {
|
||||
*v = dap::integer(json()->GetInt());
|
||||
} else if (json()->IsString()) {
|
||||
*v = dap::string(json()->GetString());
|
||||
} else if (json()->IsNull()) {
|
||||
*v = null();
|
||||
} else if (json()->IsObject()) {
|
||||
dap::object obj;
|
||||
if (!deserialize(&obj)) {
|
||||
return false;
|
||||
}
|
||||
*v = obj;
|
||||
} else if (json()->IsArray()) {
|
||||
dap::array<any> arr;
|
||||
if (!deserialize(&arr)) {
|
||||
return false;
|
||||
}
|
||||
*v = arr;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
size_t RapidDeserializer::count() const {
|
||||
return json()->Size();
|
||||
}
|
||||
|
||||
bool RapidDeserializer::array(
|
||||
const std::function<bool(dap::Deserializer*)>& cb) const {
|
||||
if (!json()->IsArray()) {
|
||||
return false;
|
||||
}
|
||||
for (uint32_t i = 0; i < json()->Size(); i++) {
|
||||
RapidDeserializer d(&(*json())[i]);
|
||||
if (!cb(&d)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool RapidDeserializer::field(
|
||||
const std::string& name,
|
||||
const std::function<bool(dap::Deserializer*)>& cb) const {
|
||||
if (!json()->IsObject()) {
|
||||
return false;
|
||||
}
|
||||
auto it = json()->FindMember(name.c_str());
|
||||
if (it == json()->MemberEnd()) {
|
||||
return cb(&NullDeserializer::instance);
|
||||
}
|
||||
RapidDeserializer d(&(it->value));
|
||||
return cb(&d);
|
||||
}
|
||||
|
||||
RapidSerializer::RapidSerializer()
|
||||
: doc(new rapidjson::Document(rapidjson::kObjectType)),
|
||||
allocator(doc->GetAllocator()) {}
|
||||
|
||||
RapidSerializer::RapidSerializer(rapidjson::Value* json,
|
||||
rapidjson::Document::AllocatorType& allocator)
|
||||
: val(json), allocator(allocator) {}
|
||||
|
||||
RapidSerializer::~RapidSerializer() {
|
||||
delete doc;
|
||||
}
|
||||
|
||||
std::string RapidSerializer::dump() const {
|
||||
rapidjson::StringBuffer sb;
|
||||
rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(sb);
|
||||
json()->Accept(writer);
|
||||
return sb.GetString();
|
||||
}
|
||||
|
||||
bool RapidSerializer::serialize(dap::boolean v) {
|
||||
json()->SetBool(v);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool RapidSerializer::serialize(dap::integer v) {
|
||||
json()->SetInt64(v);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool RapidSerializer::serialize(dap::number v) {
|
||||
json()->SetDouble(v);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool RapidSerializer::serialize(const dap::string& v) {
|
||||
json()->SetString(v.data(), static_cast<uint32_t>(v.length()), allocator);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool RapidSerializer::serialize(const dap::object& v) {
|
||||
if (!json()->IsObject()) {
|
||||
json()->SetObject();
|
||||
}
|
||||
for (auto& it : v) {
|
||||
if (!json()->HasMember(it.first.c_str())) {
|
||||
rapidjson::Value name_value{it.first.c_str(), allocator};
|
||||
json()->AddMember(name_value, rapidjson::Value(), allocator);
|
||||
}
|
||||
rapidjson::Value& member = (*json())[it.first.c_str()];
|
||||
RapidSerializer s(&member, allocator);
|
||||
if (!s.serialize(it.second)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool RapidSerializer::serialize(const dap::any& v) {
|
||||
if (v.is<dap::boolean>()) {
|
||||
json()->SetBool((bool)v.get<dap::boolean>());
|
||||
} else if (v.is<dap::integer>()) {
|
||||
json()->SetInt64(v.get<dap::integer>());
|
||||
} else if (v.is<dap::number>()) {
|
||||
json()->SetDouble((double)v.get<dap::number>());
|
||||
} else if (v.is<dap::string>()) {
|
||||
auto s = v.get<dap::string>();
|
||||
json()->SetString(s.data(), static_cast<uint32_t>(s.length()), allocator);
|
||||
} else if (v.is<dap::object>()) {
|
||||
// reachable if dap::object nested is inside other dap::object
|
||||
return serialize(v.get<dap::object>());
|
||||
} else if (v.is<dap::null>()) {
|
||||
} else {
|
||||
// reachable if array or custom serialized type is nested inside other
|
||||
// dap::object
|
||||
auto type = get_any_type(v);
|
||||
auto value = get_any_val(v);
|
||||
if (type && value) {
|
||||
return type->serialize(this, value);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool RapidSerializer::array(size_t count,
|
||||
const std::function<bool(dap::Serializer*)>& cb) {
|
||||
if (!json()->IsArray()) {
|
||||
json()->SetArray();
|
||||
}
|
||||
|
||||
while (count > json()->Size()) {
|
||||
json()->PushBack(rapidjson::Value(), allocator);
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < count; i++) {
|
||||
RapidSerializer s(&(*json())[i], allocator);
|
||||
if (!cb(&s)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool RapidSerializer::object(
|
||||
const std::function<bool(dap::FieldSerializer*)>& cb) {
|
||||
struct FS : public FieldSerializer {
|
||||
rapidjson::Value* const json;
|
||||
rapidjson::Document::AllocatorType& allocator;
|
||||
|
||||
FS(rapidjson::Value* json, rapidjson::Document::AllocatorType& allocator)
|
||||
: json(json), allocator(allocator) {}
|
||||
bool field(const std::string& name, const SerializeFunc& cb) override {
|
||||
if (!json->HasMember(name.c_str())) {
|
||||
rapidjson::Value name_value{name.c_str(), allocator};
|
||||
json->AddMember(name_value, rapidjson::Value(), allocator);
|
||||
}
|
||||
rapidjson::Value& member = (*json)[name.c_str()];
|
||||
RapidSerializer s(&member, allocator);
|
||||
auto res = cb(&s);
|
||||
if (s.removed) {
|
||||
json->RemoveMember(name.c_str());
|
||||
}
|
||||
return res;
|
||||
}
|
||||
};
|
||||
|
||||
if (!json()->IsObject()) {
|
||||
json()->SetObject();
|
||||
}
|
||||
FS fs{json(), allocator};
|
||||
return cb(&fs);
|
||||
}
|
||||
|
||||
void RapidSerializer::remove() {
|
||||
removed = true;
|
||||
}
|
||||
|
||||
} // namespace json
|
||||
} // namespace dap
|
||||
138
libraries/cppdap/src/rapid_json_serializer.h
Normal file
138
libraries/cppdap/src/rapid_json_serializer.h
Normal file
|
|
@ -0,0 +1,138 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifndef dap_rapid_json_serializer_h
|
||||
#define dap_rapid_json_serializer_h
|
||||
|
||||
#include "dap/protocol.h"
|
||||
#include "dap/serialization.h"
|
||||
#include "dap/types.h"
|
||||
|
||||
#include <rapidjson/document.h>
|
||||
|
||||
namespace dap {
|
||||
namespace json {
|
||||
|
||||
struct RapidDeserializer : public dap::Deserializer {
|
||||
explicit RapidDeserializer(const std::string&);
|
||||
~RapidDeserializer();
|
||||
|
||||
// dap::Deserializer compliance
|
||||
bool deserialize(boolean* v) const override;
|
||||
bool deserialize(integer* v) const override;
|
||||
bool deserialize(number* v) const override;
|
||||
bool deserialize(string* v) const override;
|
||||
bool deserialize(object* v) const override;
|
||||
bool deserialize(any* v) const override;
|
||||
size_t count() const override;
|
||||
bool array(const std::function<bool(dap::Deserializer*)>&) const override;
|
||||
bool field(const std::string& name,
|
||||
const std::function<bool(dap::Deserializer*)>&) const override;
|
||||
|
||||
// Unhide base overloads
|
||||
template <typename T>
|
||||
inline bool field(const std::string& name, T* v) {
|
||||
return dap::Deserializer::field(name, v);
|
||||
}
|
||||
|
||||
template <typename T,
|
||||
typename = std::enable_if<TypeOf<T>::has_custom_serialization>>
|
||||
inline bool deserialize(T* v) const {
|
||||
return dap::Deserializer::deserialize(v);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline bool deserialize(dap::array<T>* v) const {
|
||||
return dap::Deserializer::deserialize(v);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline bool deserialize(dap::optional<T>* v) const {
|
||||
return dap::Deserializer::deserialize(v);
|
||||
}
|
||||
|
||||
template <typename T0, typename... Types>
|
||||
inline bool deserialize(dap::variant<T0, Types...>* v) const {
|
||||
return dap::Deserializer::deserialize(v);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline bool field(const std::string& name, T* v) const {
|
||||
return dap::Deserializer::deserialize(name, v);
|
||||
}
|
||||
|
||||
inline rapidjson::Value* json() const { return (val == nullptr) ? doc : val; }
|
||||
|
||||
private:
|
||||
RapidDeserializer(rapidjson::Value*);
|
||||
rapidjson::Document* const doc = nullptr;
|
||||
rapidjson::Value* const val = nullptr;
|
||||
};
|
||||
|
||||
struct RapidSerializer : public dap::Serializer {
|
||||
RapidSerializer();
|
||||
~RapidSerializer();
|
||||
|
||||
std::string dump() const;
|
||||
|
||||
// dap::Serializer compliance
|
||||
bool serialize(boolean v) override;
|
||||
bool serialize(integer v) override;
|
||||
bool serialize(number v) override;
|
||||
bool serialize(const string& v) override;
|
||||
bool serialize(const dap::object& v) override;
|
||||
bool serialize(const any& v) override;
|
||||
bool array(size_t count,
|
||||
const std::function<bool(dap::Serializer*)>&) override;
|
||||
bool object(const std::function<bool(dap::FieldSerializer*)>&) override;
|
||||
void remove() override;
|
||||
|
||||
// Unhide base overloads
|
||||
template <typename T,
|
||||
typename = std::enable_if<TypeOf<T>::has_custom_serialization>>
|
||||
inline bool serialize(const T& v) {
|
||||
return dap::Serializer::serialize(v);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline bool serialize(const dap::array<T>& v) {
|
||||
return dap::Serializer::serialize(v);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline bool serialize(const dap::optional<T>& v) {
|
||||
return dap::Serializer::serialize(v);
|
||||
}
|
||||
|
||||
template <typename T0, typename... Types>
|
||||
inline bool serialize(const dap::variant<T0, Types...>& v) {
|
||||
return dap::Serializer::serialize(v);
|
||||
}
|
||||
|
||||
inline bool serialize(const char* v) { return dap::Serializer::serialize(v); }
|
||||
|
||||
inline rapidjson::Value* json() const { return (val == nullptr) ? doc : val; }
|
||||
|
||||
private:
|
||||
RapidSerializer(rapidjson::Value*, rapidjson::Document::AllocatorType&);
|
||||
rapidjson::Document* const doc = nullptr;
|
||||
rapidjson::Value* const val = nullptr;
|
||||
rapidjson::Document::AllocatorType& allocator;
|
||||
bool removed = false;
|
||||
};
|
||||
|
||||
} // namespace json
|
||||
} // namespace dap
|
||||
|
||||
#endif // dap_rapid_json_serializer_h
|
||||
172
libraries/cppdap/src/rwmutex.h
Normal file
172
libraries/cppdap/src/rwmutex.h
Normal file
|
|
@ -0,0 +1,172 @@
|
|||
// Copyright 2020 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifndef dap_rwmutex_h
|
||||
#define dap_rwmutex_h
|
||||
|
||||
#include <condition_variable>
|
||||
#include <mutex>
|
||||
|
||||
namespace dap {
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// RWMutex
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// A RWMutex is a reader/writer mutual exclusion lock.
|
||||
// The lock can be held by an arbitrary number of readers or a single writer.
|
||||
// Also known as a shared mutex.
|
||||
class RWMutex {
|
||||
public:
|
||||
inline RWMutex() = default;
|
||||
|
||||
// lockReader() locks the mutex for reading.
|
||||
// Multiple read locks can be held while there are no writer locks.
|
||||
inline void lockReader();
|
||||
|
||||
// unlockReader() unlocks the mutex for reading.
|
||||
inline void unlockReader();
|
||||
|
||||
// lockWriter() locks the mutex for writing.
|
||||
// If the lock is already locked for reading or writing, lockWriter blocks
|
||||
// until the lock is available.
|
||||
inline void lockWriter();
|
||||
|
||||
// unlockWriter() unlocks the mutex for writing.
|
||||
inline void unlockWriter();
|
||||
|
||||
private:
|
||||
RWMutex(const RWMutex&) = delete;
|
||||
RWMutex& operator=(const RWMutex&) = delete;
|
||||
|
||||
int readLocks = 0;
|
||||
int pendingWriteLocks = 0;
|
||||
std::mutex mutex;
|
||||
std::condition_variable cv;
|
||||
};
|
||||
|
||||
void RWMutex::lockReader() {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
readLocks++;
|
||||
}
|
||||
|
||||
void RWMutex::unlockReader() {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
readLocks--;
|
||||
if (readLocks == 0 && pendingWriteLocks > 0) {
|
||||
cv.notify_one();
|
||||
}
|
||||
}
|
||||
|
||||
void RWMutex::lockWriter() {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
if (readLocks > 0) {
|
||||
pendingWriteLocks++;
|
||||
cv.wait(lock, [&] { return readLocks == 0; });
|
||||
pendingWriteLocks--;
|
||||
}
|
||||
lock.release(); // Keep lock held
|
||||
}
|
||||
|
||||
void RWMutex::unlockWriter() {
|
||||
if (pendingWriteLocks > 0) {
|
||||
cv.notify_one();
|
||||
}
|
||||
mutex.unlock();
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// RLock
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// RLock is a RAII read lock helper for a RWMutex.
|
||||
class RLock {
|
||||
public:
|
||||
inline RLock(RWMutex& mutex);
|
||||
inline ~RLock();
|
||||
|
||||
inline RLock(RLock&&);
|
||||
inline RLock& operator=(RLock&&);
|
||||
|
||||
private:
|
||||
RLock(const RLock&) = delete;
|
||||
RLock& operator=(const RLock&) = delete;
|
||||
|
||||
RWMutex* m;
|
||||
};
|
||||
|
||||
RLock::RLock(RWMutex& mutex) : m(&mutex) {
|
||||
m->lockReader();
|
||||
}
|
||||
|
||||
RLock::~RLock() {
|
||||
if (m != nullptr) {
|
||||
m->unlockReader();
|
||||
}
|
||||
}
|
||||
|
||||
RLock::RLock(RLock&& other) {
|
||||
m = other.m;
|
||||
other.m = nullptr;
|
||||
}
|
||||
|
||||
RLock& RLock::operator=(RLock&& other) {
|
||||
m = other.m;
|
||||
other.m = nullptr;
|
||||
return *this;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// WLock
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// WLock is a RAII write lock helper for a RWMutex.
|
||||
class WLock {
|
||||
public:
|
||||
inline WLock(RWMutex& mutex);
|
||||
inline ~WLock();
|
||||
|
||||
inline WLock(WLock&&);
|
||||
inline WLock& operator=(WLock&&);
|
||||
|
||||
private:
|
||||
WLock(const WLock&) = delete;
|
||||
WLock& operator=(const WLock&) = delete;
|
||||
|
||||
RWMutex* m;
|
||||
};
|
||||
|
||||
WLock::WLock(RWMutex& mutex) : m(&mutex) {
|
||||
m->lockWriter();
|
||||
}
|
||||
|
||||
WLock::~WLock() {
|
||||
if (m != nullptr) {
|
||||
m->unlockWriter();
|
||||
}
|
||||
}
|
||||
|
||||
WLock::WLock(WLock&& other) {
|
||||
m = other.m;
|
||||
other.m = nullptr;
|
||||
}
|
||||
|
||||
WLock& WLock::operator=(WLock&& other) {
|
||||
m = other.m;
|
||||
other.m = nullptr;
|
||||
return *this;
|
||||
}
|
||||
} // namespace dap
|
||||
|
||||
#endif
|
||||
113
libraries/cppdap/src/rwmutex_test.cpp
Normal file
113
libraries/cppdap/src/rwmutex_test.cpp
Normal file
|
|
@ -0,0 +1,113 @@
|
|||
// Copyright 2020 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "rwmutex.h"
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include <array>
|
||||
#include <thread>
|
||||
#include <vector>
|
||||
|
||||
namespace {
|
||||
constexpr const size_t NumThreads = 8;
|
||||
}
|
||||
|
||||
// Check that WLock behaves like regular mutex.
|
||||
TEST(RWMutex, WLock) {
|
||||
dap::RWMutex rwmutex;
|
||||
int counter = 0;
|
||||
|
||||
std::vector<std::thread> threads;
|
||||
for (size_t i = 0; i < NumThreads; i++) {
|
||||
threads.emplace_back([&] {
|
||||
for (int j = 0; j < 1000; j++) {
|
||||
dap::WLock lock(rwmutex);
|
||||
counter++;
|
||||
EXPECT_EQ(counter, 1);
|
||||
counter--;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
for (auto& thread : threads) {
|
||||
thread.join();
|
||||
}
|
||||
|
||||
EXPECT_EQ(counter, 0);
|
||||
}
|
||||
|
||||
TEST(RWMutex, NoRLockWithWLock) {
|
||||
dap::RWMutex rwmutex;
|
||||
|
||||
std::vector<std::thread> threads;
|
||||
std::array<int, NumThreads> counters = {};
|
||||
|
||||
{ // With WLock held...
|
||||
dap::WLock wlock(rwmutex);
|
||||
|
||||
for (size_t i = 0; i < counters.size(); i++) {
|
||||
int* counter = &counters[i];
|
||||
threads.emplace_back([&rwmutex, counter] {
|
||||
dap::RLock lock(rwmutex);
|
||||
for (int j = 0; j < 1000; j++) {
|
||||
(*counter)++;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// RLocks should block
|
||||
for (int counter : counters) {
|
||||
EXPECT_EQ(counter, 0);
|
||||
}
|
||||
}
|
||||
|
||||
for (auto& thread : threads) {
|
||||
thread.join();
|
||||
}
|
||||
|
||||
for (int counter : counters) {
|
||||
EXPECT_EQ(counter, 1000);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(RWMutex, NoWLockWithRLock) {
|
||||
dap::RWMutex rwmutex;
|
||||
|
||||
std::vector<std::thread> threads;
|
||||
size_t counter = 0;
|
||||
|
||||
{ // With RLocks held...
|
||||
dap::RLock rlockA(rwmutex);
|
||||
dap::RLock rlockB(rwmutex);
|
||||
dap::RLock rlockC(rwmutex);
|
||||
|
||||
for (size_t i = 0; i < NumThreads; i++) {
|
||||
threads.emplace_back(std::thread([&] {
|
||||
dap::WLock lock(rwmutex);
|
||||
counter++;
|
||||
}));
|
||||
}
|
||||
|
||||
// ... WLocks should block
|
||||
EXPECT_EQ(counter, 0U);
|
||||
}
|
||||
|
||||
for (auto& thread : threads) {
|
||||
thread.join();
|
||||
}
|
||||
|
||||
EXPECT_EQ(counter, NumThreads);
|
||||
}
|
||||
521
libraries/cppdap/src/session.cpp
Normal file
521
libraries/cppdap/src/session.cpp
Normal file
|
|
@ -0,0 +1,521 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "content_stream.h"
|
||||
|
||||
#include "dap/any.h"
|
||||
#include "dap/session.h"
|
||||
|
||||
#include "chan.h"
|
||||
#include "json_serializer.h"
|
||||
#include "socket.h"
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <atomic>
|
||||
#include <deque>
|
||||
#include <memory>
|
||||
#include <mutex>
|
||||
#include <thread>
|
||||
#include <unordered_map>
|
||||
#include <vector>
|
||||
|
||||
namespace {
|
||||
|
||||
class Impl : public dap::Session {
|
||||
public:
|
||||
void setOnInvalidData(dap::OnInvalidData onInvalidData_) override {
|
||||
this->onInvalidData = onInvalidData_;
|
||||
}
|
||||
|
||||
void onError(const ErrorHandler& handler) override { handlers.put(handler); }
|
||||
|
||||
void registerHandler(const dap::TypeInfo* typeinfo,
|
||||
const GenericRequestHandler& handler) override {
|
||||
handlers.put(typeinfo, handler);
|
||||
}
|
||||
|
||||
void registerHandler(const dap::TypeInfo* typeinfo,
|
||||
const GenericEventHandler& handler) override {
|
||||
handlers.put(typeinfo, handler);
|
||||
}
|
||||
|
||||
void registerHandler(const dap::TypeInfo* typeinfo,
|
||||
const GenericResponseSentHandler& handler) override {
|
||||
handlers.put(typeinfo, handler);
|
||||
}
|
||||
|
||||
std::function<void()> getPayload() override {
|
||||
auto request = reader.read();
|
||||
if (request.size() > 0) {
|
||||
if (auto payload = processMessage(request)) {
|
||||
return payload;
|
||||
}
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
void connect(const std::shared_ptr<dap::Reader>& r,
|
||||
const std::shared_ptr<dap::Writer>& w) override {
|
||||
if (isBound.exchange(true)) {
|
||||
handlers.error("Session::connect called twice");
|
||||
return;
|
||||
}
|
||||
|
||||
reader = dap::ContentReader(r, this->onInvalidData);
|
||||
writer = dap::ContentWriter(w);
|
||||
}
|
||||
|
||||
void startProcessingMessages(
|
||||
const ClosedHandler& onClose /* = {} */) override {
|
||||
if (isProcessingMessages.exchange(true)) {
|
||||
handlers.error("Session::startProcessingMessages() called twice");
|
||||
return;
|
||||
}
|
||||
recvThread = std::thread([this, onClose] {
|
||||
while (reader.isOpen()) {
|
||||
if (auto payload = getPayload()) {
|
||||
inbox.put(std::move(payload));
|
||||
}
|
||||
}
|
||||
if (onClose) {
|
||||
onClose();
|
||||
}
|
||||
});
|
||||
|
||||
dispatchThread = std::thread([this] {
|
||||
while (auto payload = inbox.take()) {
|
||||
payload.value()();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
bool send(const dap::TypeInfo* requestTypeInfo,
|
||||
const dap::TypeInfo* responseTypeInfo,
|
||||
const void* request,
|
||||
const GenericResponseHandler& responseHandler) override {
|
||||
int seq = nextSeq++;
|
||||
|
||||
handlers.put(seq, responseTypeInfo, responseHandler);
|
||||
|
||||
dap::json::Serializer s;
|
||||
if (!s.object([&](dap::FieldSerializer* fs) {
|
||||
return fs->field("seq", dap::integer(seq)) &&
|
||||
fs->field("type", "request") &&
|
||||
fs->field("command", requestTypeInfo->name()) &&
|
||||
fs->field("arguments", [&](dap::Serializer* s) {
|
||||
return requestTypeInfo->serialize(s, request);
|
||||
});
|
||||
})) {
|
||||
return false;
|
||||
}
|
||||
return send(s.dump());
|
||||
}
|
||||
|
||||
bool send(const dap::TypeInfo* typeinfo, const void* event) override {
|
||||
dap::json::Serializer s;
|
||||
if (!s.object([&](dap::FieldSerializer* fs) {
|
||||
return fs->field("seq", dap::integer(nextSeq++)) &&
|
||||
fs->field("type", "event") &&
|
||||
fs->field("event", typeinfo->name()) &&
|
||||
fs->field("body", [&](dap::Serializer* s) {
|
||||
return typeinfo->serialize(s, event);
|
||||
});
|
||||
})) {
|
||||
return false;
|
||||
}
|
||||
return send(s.dump());
|
||||
}
|
||||
|
||||
~Impl() override {
|
||||
inbox.close();
|
||||
reader.close();
|
||||
writer.close();
|
||||
if (recvThread.joinable()) {
|
||||
recvThread.join();
|
||||
}
|
||||
if (dispatchThread.joinable()) {
|
||||
dispatchThread.join();
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
using Payload = std::function<void()>;
|
||||
|
||||
class EventHandlers {
|
||||
public:
|
||||
void put(const ErrorHandler& handler) {
|
||||
std::unique_lock<std::mutex> lock(errorMutex);
|
||||
errorHandler = handler;
|
||||
}
|
||||
|
||||
void error(const char* format, ...) {
|
||||
va_list vararg;
|
||||
va_start(vararg, format);
|
||||
std::unique_lock<std::mutex> lock(errorMutex);
|
||||
errorLocked(format, vararg);
|
||||
va_end(vararg);
|
||||
}
|
||||
|
||||
std::pair<const dap::TypeInfo*, GenericRequestHandler> request(
|
||||
const std::string& name) {
|
||||
std::unique_lock<std::mutex> lock(requestMutex);
|
||||
auto it = requestMap.find(name);
|
||||
return (it != requestMap.end()) ? it->second : decltype(it->second){};
|
||||
}
|
||||
|
||||
void put(const dap::TypeInfo* typeinfo,
|
||||
const GenericRequestHandler& handler) {
|
||||
std::unique_lock<std::mutex> lock(requestMutex);
|
||||
auto added =
|
||||
requestMap
|
||||
.emplace(typeinfo->name(), std::make_pair(typeinfo, handler))
|
||||
.second;
|
||||
if (!added) {
|
||||
errorfLocked("Request handler for '%s' already registered",
|
||||
typeinfo->name().c_str());
|
||||
}
|
||||
}
|
||||
|
||||
std::pair<const dap::TypeInfo*, GenericResponseHandler> response(
|
||||
int64_t seq) {
|
||||
std::unique_lock<std::mutex> lock(responseMutex);
|
||||
auto responseIt = responseMap.find(seq);
|
||||
if (responseIt == responseMap.end()) {
|
||||
errorfLocked("Unknown response with sequence %d", seq);
|
||||
return {};
|
||||
}
|
||||
auto out = std::move(responseIt->second);
|
||||
responseMap.erase(seq);
|
||||
return out;
|
||||
}
|
||||
|
||||
void put(int seq,
|
||||
const dap::TypeInfo* typeinfo,
|
||||
const GenericResponseHandler& handler) {
|
||||
std::unique_lock<std::mutex> lock(responseMutex);
|
||||
auto added =
|
||||
responseMap.emplace(seq, std::make_pair(typeinfo, handler)).second;
|
||||
if (!added) {
|
||||
errorfLocked("Response handler for sequence %d already registered",
|
||||
seq);
|
||||
}
|
||||
}
|
||||
|
||||
std::pair<const dap::TypeInfo*, GenericEventHandler> event(
|
||||
const std::string& name) {
|
||||
std::unique_lock<std::mutex> lock(eventMutex);
|
||||
auto it = eventMap.find(name);
|
||||
return (it != eventMap.end()) ? it->second : decltype(it->second){};
|
||||
}
|
||||
|
||||
void put(const dap::TypeInfo* typeinfo,
|
||||
const GenericEventHandler& handler) {
|
||||
std::unique_lock<std::mutex> lock(eventMutex);
|
||||
auto added =
|
||||
eventMap.emplace(typeinfo->name(), std::make_pair(typeinfo, handler))
|
||||
.second;
|
||||
if (!added) {
|
||||
errorfLocked("Event handler for '%s' already registered",
|
||||
typeinfo->name().c_str());
|
||||
}
|
||||
}
|
||||
|
||||
GenericResponseSentHandler responseSent(const dap::TypeInfo* typeinfo) {
|
||||
std::unique_lock<std::mutex> lock(responseSentMutex);
|
||||
auto it = responseSentMap.find(typeinfo);
|
||||
return (it != responseSentMap.end()) ? it->second
|
||||
: decltype(it->second){};
|
||||
}
|
||||
|
||||
void put(const dap::TypeInfo* typeinfo,
|
||||
const GenericResponseSentHandler& handler) {
|
||||
std::unique_lock<std::mutex> lock(responseSentMutex);
|
||||
auto added = responseSentMap.emplace(typeinfo, handler).second;
|
||||
if (!added) {
|
||||
errorfLocked("Response sent handler for '%s' already registered",
|
||||
typeinfo->name().c_str());
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
void errorfLocked(const char* format, ...) {
|
||||
va_list vararg;
|
||||
va_start(vararg, format);
|
||||
errorLocked(format, vararg);
|
||||
va_end(vararg);
|
||||
}
|
||||
|
||||
void errorLocked(const char* format, va_list args) {
|
||||
char buf[2048];
|
||||
vsnprintf(buf, sizeof(buf), format, args);
|
||||
if (errorHandler) {
|
||||
errorHandler(buf);
|
||||
}
|
||||
}
|
||||
|
||||
std::mutex errorMutex;
|
||||
ErrorHandler errorHandler;
|
||||
|
||||
std::mutex requestMutex;
|
||||
std::unordered_map<std::string,
|
||||
std::pair<const dap::TypeInfo*, GenericRequestHandler>>
|
||||
requestMap;
|
||||
|
||||
std::mutex responseMutex;
|
||||
std::unordered_map<int64_t,
|
||||
std::pair<const dap::TypeInfo*, GenericResponseHandler>>
|
||||
responseMap;
|
||||
|
||||
std::mutex eventMutex;
|
||||
std::unordered_map<std::string,
|
||||
std::pair<const dap::TypeInfo*, GenericEventHandler>>
|
||||
eventMap;
|
||||
|
||||
std::mutex responseSentMutex;
|
||||
std::unordered_map<const dap::TypeInfo*, GenericResponseSentHandler>
|
||||
responseSentMap;
|
||||
}; // EventHandlers
|
||||
|
||||
Payload processMessage(const std::string& str) {
|
||||
auto d = dap::json::Deserializer(str);
|
||||
dap::string type;
|
||||
if (!d.field("type", &type)) {
|
||||
handlers.error("Message missing string 'type' field");
|
||||
return {};
|
||||
}
|
||||
|
||||
dap::integer sequence = 0;
|
||||
if (!d.field("seq", &sequence)) {
|
||||
handlers.error("Message missing number 'seq' field");
|
||||
return {};
|
||||
}
|
||||
|
||||
if (type == "request") {
|
||||
return processRequest(&d, sequence);
|
||||
} else if (type == "event") {
|
||||
return processEvent(&d);
|
||||
} else if (type == "response") {
|
||||
processResponse(&d);
|
||||
return {};
|
||||
} else {
|
||||
handlers.error("Unknown message type '%s'", type.c_str());
|
||||
}
|
||||
|
||||
return {};
|
||||
}
|
||||
|
||||
Payload processRequest(dap::json::Deserializer* d, dap::integer sequence) {
|
||||
dap::string command;
|
||||
if (!d->field("command", &command)) {
|
||||
handlers.error("Request missing string 'command' field");
|
||||
return {};
|
||||
}
|
||||
|
||||
const dap::TypeInfo* typeinfo;
|
||||
GenericRequestHandler handler;
|
||||
std::tie(typeinfo, handler) = handlers.request(command);
|
||||
if (!typeinfo) {
|
||||
handlers.error("No request handler registered for command '%s'",
|
||||
command.c_str());
|
||||
return {};
|
||||
}
|
||||
|
||||
auto data = new uint8_t[typeinfo->size()];
|
||||
typeinfo->construct(data);
|
||||
|
||||
if (!d->field("arguments", [&](dap::Deserializer* d) {
|
||||
return typeinfo->deserialize(d, data);
|
||||
})) {
|
||||
handlers.error("Failed to deserialize request");
|
||||
typeinfo->destruct(data);
|
||||
delete[] data;
|
||||
return {};
|
||||
}
|
||||
|
||||
return [=] {
|
||||
handler(
|
||||
data,
|
||||
[=](const dap::TypeInfo* typeinfo, const void* data) {
|
||||
// onSuccess
|
||||
dap::json::Serializer s;
|
||||
s.object([&](dap::FieldSerializer* fs) {
|
||||
return fs->field("seq", dap::integer(nextSeq++)) &&
|
||||
fs->field("type", "response") &&
|
||||
fs->field("request_seq", sequence) &&
|
||||
fs->field("success", dap::boolean(true)) &&
|
||||
fs->field("command", command) &&
|
||||
fs->field("body", [&](dap::Serializer* s) {
|
||||
return typeinfo->serialize(s, data);
|
||||
});
|
||||
});
|
||||
send(s.dump());
|
||||
|
||||
if (auto handler = handlers.responseSent(typeinfo)) {
|
||||
handler(data, nullptr);
|
||||
}
|
||||
},
|
||||
[=](const dap::TypeInfo* typeinfo, const dap::Error& error) {
|
||||
// onError
|
||||
dap::json::Serializer s;
|
||||
s.object([&](dap::FieldSerializer* fs) {
|
||||
return fs->field("seq", dap::integer(nextSeq++)) &&
|
||||
fs->field("type", "response") &&
|
||||
fs->field("request_seq", sequence) &&
|
||||
fs->field("success", dap::boolean(false)) &&
|
||||
fs->field("command", command) &&
|
||||
fs->field("message", error.message);
|
||||
});
|
||||
send(s.dump());
|
||||
|
||||
if (auto handler = handlers.responseSent(typeinfo)) {
|
||||
handler(nullptr, &error);
|
||||
}
|
||||
});
|
||||
typeinfo->destruct(data);
|
||||
delete[] data;
|
||||
};
|
||||
}
|
||||
|
||||
Payload processEvent(dap::json::Deserializer* d) {
|
||||
dap::string event;
|
||||
if (!d->field("event", &event)) {
|
||||
handlers.error("Event missing string 'event' field");
|
||||
return {};
|
||||
}
|
||||
|
||||
const dap::TypeInfo* typeinfo;
|
||||
GenericEventHandler handler;
|
||||
std::tie(typeinfo, handler) = handlers.event(event);
|
||||
if (!typeinfo) {
|
||||
handlers.error("No event handler registered for event '%s'",
|
||||
event.c_str());
|
||||
return {};
|
||||
}
|
||||
|
||||
auto data = new uint8_t[typeinfo->size()];
|
||||
typeinfo->construct(data);
|
||||
|
||||
// "body" is an optional field for some events, such as "Terminated Event".
|
||||
bool body_ok = true;
|
||||
d->field("body", [&](dap::Deserializer* d) {
|
||||
if (!typeinfo->deserialize(d, data)) {
|
||||
body_ok = false;
|
||||
}
|
||||
return true;
|
||||
});
|
||||
|
||||
if (!body_ok) {
|
||||
handlers.error("Failed to deserialize event '%s' body", event.c_str());
|
||||
typeinfo->destruct(data);
|
||||
delete[] data;
|
||||
return {};
|
||||
}
|
||||
|
||||
return [=] {
|
||||
handler(data);
|
||||
typeinfo->destruct(data);
|
||||
delete[] data;
|
||||
};
|
||||
}
|
||||
|
||||
void processResponse(const dap::Deserializer* d) {
|
||||
dap::integer requestSeq = 0;
|
||||
if (!d->field("request_seq", &requestSeq)) {
|
||||
handlers.error("Response missing int 'request_seq' field");
|
||||
return;
|
||||
}
|
||||
|
||||
const dap::TypeInfo* typeinfo;
|
||||
GenericResponseHandler handler;
|
||||
std::tie(typeinfo, handler) = handlers.response(requestSeq);
|
||||
if (!typeinfo) {
|
||||
handlers.error("Unknown response with sequence %d", requestSeq);
|
||||
return;
|
||||
}
|
||||
|
||||
dap::boolean success = false;
|
||||
if (!d->field("success", &success)) {
|
||||
handlers.error("Response missing int 'success' field");
|
||||
return;
|
||||
}
|
||||
|
||||
if (success) {
|
||||
auto data = std::unique_ptr<uint8_t[]>(new uint8_t[typeinfo->size()]);
|
||||
typeinfo->construct(data.get());
|
||||
|
||||
// "body" field in Response is an optional field.
|
||||
d->field("body", [&](const dap::Deserializer* d) {
|
||||
return typeinfo->deserialize(d, data.get());
|
||||
});
|
||||
|
||||
handler(data.get(), nullptr);
|
||||
typeinfo->destruct(data.get());
|
||||
} else {
|
||||
std::string message;
|
||||
if (!d->field("message", &message)) {
|
||||
handlers.error("Failed to deserialize message");
|
||||
return;
|
||||
}
|
||||
auto error = dap::Error("%s", message.c_str());
|
||||
handler(nullptr, &error);
|
||||
}
|
||||
}
|
||||
|
||||
bool send(const std::string& s) {
|
||||
std::unique_lock<std::mutex> lock(sendMutex);
|
||||
if (!writer.isOpen()) {
|
||||
handlers.error("Send failed as the writer is closed");
|
||||
return false;
|
||||
}
|
||||
return writer.write(s);
|
||||
}
|
||||
|
||||
std::atomic<bool> isBound = {false};
|
||||
std::atomic<bool> isProcessingMessages = {false};
|
||||
dap::ContentReader reader;
|
||||
dap::ContentWriter writer;
|
||||
|
||||
std::atomic<bool> shutdown = {false};
|
||||
EventHandlers handlers;
|
||||
std::thread recvThread;
|
||||
std::thread dispatchThread;
|
||||
dap::Chan<Payload> inbox;
|
||||
std::atomic<uint32_t> nextSeq = {1};
|
||||
std::mutex sendMutex;
|
||||
dap::OnInvalidData onInvalidData = dap::kIgnore;
|
||||
};
|
||||
|
||||
} // anonymous namespace
|
||||
|
||||
namespace dap {
|
||||
|
||||
Error::Error(const std::string& message) : message(message) {}
|
||||
|
||||
Error::Error(const char* msg, ...) {
|
||||
char buf[2048];
|
||||
va_list vararg;
|
||||
va_start(vararg, msg);
|
||||
vsnprintf(buf, sizeof(buf), msg, vararg);
|
||||
va_end(vararg);
|
||||
message = buf;
|
||||
}
|
||||
|
||||
Session::~Session() = default;
|
||||
|
||||
std::unique_ptr<Session> Session::create() {
|
||||
return std::unique_ptr<Session>(new Impl());
|
||||
}
|
||||
|
||||
} // namespace dap
|
||||
625
libraries/cppdap/src/session_test.cpp
Normal file
625
libraries/cppdap/src/session_test.cpp
Normal file
|
|
@ -0,0 +1,625 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "dap/session.h"
|
||||
#include "dap/io.h"
|
||||
#include "dap/protocol.h"
|
||||
|
||||
#include "chan.h"
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include <array>
|
||||
#include <atomic>
|
||||
#include <condition_variable>
|
||||
#include <mutex>
|
||||
#include <thread>
|
||||
|
||||
namespace dap {
|
||||
|
||||
struct TestResponse : public Response {
|
||||
boolean b;
|
||||
integer i;
|
||||
number n;
|
||||
array<integer> a;
|
||||
object o;
|
||||
string s;
|
||||
optional<integer> o1;
|
||||
optional<integer> o2;
|
||||
};
|
||||
|
||||
DAP_STRUCT_TYPEINFO(TestResponse,
|
||||
"test-response",
|
||||
DAP_FIELD(b, "res_b"),
|
||||
DAP_FIELD(i, "res_i"),
|
||||
DAP_FIELD(n, "res_n"),
|
||||
DAP_FIELD(a, "res_a"),
|
||||
DAP_FIELD(o, "res_o"),
|
||||
DAP_FIELD(s, "res_s"),
|
||||
DAP_FIELD(o1, "res_o1"),
|
||||
DAP_FIELD(o2, "res_o2"));
|
||||
|
||||
struct TestRequest : public Request {
|
||||
using Response = TestResponse;
|
||||
|
||||
boolean b;
|
||||
integer i;
|
||||
number n;
|
||||
array<integer> a;
|
||||
object o;
|
||||
string s;
|
||||
optional<integer> o1;
|
||||
optional<integer> o2;
|
||||
};
|
||||
|
||||
DAP_STRUCT_TYPEINFO(TestRequest,
|
||||
"test-request",
|
||||
DAP_FIELD(b, "req_b"),
|
||||
DAP_FIELD(i, "req_i"),
|
||||
DAP_FIELD(n, "req_n"),
|
||||
DAP_FIELD(a, "req_a"),
|
||||
DAP_FIELD(o, "req_o"),
|
||||
DAP_FIELD(s, "req_s"),
|
||||
DAP_FIELD(o1, "req_o1"),
|
||||
DAP_FIELD(o2, "req_o2"));
|
||||
|
||||
struct TestEvent : public Event {
|
||||
boolean b;
|
||||
integer i;
|
||||
number n;
|
||||
array<integer> a;
|
||||
object o;
|
||||
string s;
|
||||
optional<integer> o1;
|
||||
optional<integer> o2;
|
||||
};
|
||||
|
||||
DAP_STRUCT_TYPEINFO(TestEvent,
|
||||
"test-event",
|
||||
DAP_FIELD(b, "evt_b"),
|
||||
DAP_FIELD(i, "evt_i"),
|
||||
DAP_FIELD(n, "evt_n"),
|
||||
DAP_FIELD(a, "evt_a"),
|
||||
DAP_FIELD(o, "evt_o"),
|
||||
DAP_FIELD(s, "evt_s"),
|
||||
DAP_FIELD(o1, "evt_o1"),
|
||||
DAP_FIELD(o2, "evt_o2"));
|
||||
|
||||
}; // namespace dap
|
||||
|
||||
namespace {
|
||||
|
||||
dap::TestRequest createRequest() {
|
||||
dap::TestRequest request;
|
||||
request.b = false;
|
||||
request.i = 72;
|
||||
request.n = 9.87;
|
||||
request.a = {2, 5, 7, 8};
|
||||
request.o = {
|
||||
std::make_pair("a", dap::integer(1)),
|
||||
std::make_pair("b", dap::number(2)),
|
||||
std::make_pair("c", dap::string("3")),
|
||||
};
|
||||
request.s = "request";
|
||||
request.o2 = 42;
|
||||
return request;
|
||||
}
|
||||
|
||||
dap::TestResponse createResponse() {
|
||||
dap::TestResponse response;
|
||||
response.b = true;
|
||||
response.i = 99;
|
||||
response.n = 123.456;
|
||||
response.a = {5, 4, 3, 2, 1};
|
||||
response.o = {
|
||||
std::make_pair("one", dap::integer(1)),
|
||||
std::make_pair("two", dap::number(2)),
|
||||
std::make_pair("three", dap::string("3")),
|
||||
};
|
||||
response.s = "ROGER";
|
||||
response.o1 = 50;
|
||||
return response;
|
||||
}
|
||||
|
||||
dap::TestEvent createEvent() {
|
||||
dap::TestEvent event;
|
||||
event.b = false;
|
||||
event.i = 72;
|
||||
event.n = 9.87;
|
||||
event.a = {2, 5, 7, 8};
|
||||
event.o = {
|
||||
std::make_pair("a", dap::integer(1)),
|
||||
std::make_pair("b", dap::number(2)),
|
||||
std::make_pair("c", dap::string("3")),
|
||||
};
|
||||
event.s = "event";
|
||||
event.o2 = 42;
|
||||
return event;
|
||||
}
|
||||
|
||||
} // anonymous namespace
|
||||
|
||||
class SessionTest : public testing::Test {
|
||||
public:
|
||||
void bind() {
|
||||
auto client2server = dap::pipe();
|
||||
auto server2client = dap::pipe();
|
||||
client->bind(server2client, client2server);
|
||||
server->bind(client2server, server2client);
|
||||
}
|
||||
|
||||
std::unique_ptr<dap::Session> client = dap::Session::create();
|
||||
std::unique_ptr<dap::Session> server = dap::Session::create();
|
||||
};
|
||||
|
||||
TEST_F(SessionTest, Request) {
|
||||
dap::TestRequest received;
|
||||
server->registerHandler([&](const dap::TestRequest& req) {
|
||||
received = req;
|
||||
return createResponse();
|
||||
});
|
||||
|
||||
bind();
|
||||
|
||||
auto request = createRequest();
|
||||
client->send(request).get();
|
||||
|
||||
// Check request was received correctly.
|
||||
ASSERT_EQ(received.b, request.b);
|
||||
ASSERT_EQ(received.i, request.i);
|
||||
ASSERT_EQ(received.n, request.n);
|
||||
ASSERT_EQ(received.a, request.a);
|
||||
ASSERT_EQ(received.o.size(), 3U);
|
||||
ASSERT_EQ(received.o["a"].get<dap::integer>(),
|
||||
request.o["a"].get<dap::integer>());
|
||||
ASSERT_EQ(received.o["b"].get<dap::number>(),
|
||||
request.o["b"].get<dap::number>());
|
||||
ASSERT_EQ(received.o["c"].get<dap::string>(),
|
||||
request.o["c"].get<dap::string>());
|
||||
ASSERT_EQ(received.s, request.s);
|
||||
ASSERT_EQ(received.o1, request.o1);
|
||||
ASSERT_EQ(received.o2, request.o2);
|
||||
}
|
||||
|
||||
TEST_F(SessionTest, RequestResponseSuccess) {
|
||||
server->registerHandler(
|
||||
[&](const dap::TestRequest&) { return createResponse(); });
|
||||
|
||||
bind();
|
||||
|
||||
auto request = createRequest();
|
||||
auto response = client->send(request);
|
||||
|
||||
auto got = response.get();
|
||||
|
||||
// Check response was received correctly.
|
||||
ASSERT_EQ(got.error, false);
|
||||
ASSERT_EQ(got.response.b, dap::boolean(true));
|
||||
ASSERT_EQ(got.response.i, dap::integer(99));
|
||||
ASSERT_EQ(got.response.n, dap::number(123.456));
|
||||
ASSERT_EQ(got.response.a, dap::array<dap::integer>({5, 4, 3, 2, 1}));
|
||||
ASSERT_EQ(got.response.o.size(), 3U);
|
||||
ASSERT_EQ(got.response.o["one"].get<dap::integer>(), dap::integer(1));
|
||||
ASSERT_EQ(got.response.o["two"].get<dap::number>(), dap::number(2));
|
||||
ASSERT_EQ(got.response.o["three"].get<dap::string>(), dap::string("3"));
|
||||
ASSERT_EQ(got.response.s, "ROGER");
|
||||
ASSERT_EQ(got.response.o1, dap::optional<dap::integer>(50));
|
||||
ASSERT_FALSE(got.response.o2.has_value());
|
||||
}
|
||||
|
||||
TEST_F(SessionTest, BreakPointRequestResponseSuccess) {
|
||||
server->registerHandler([&](const dap::SetBreakpointsRequest&) {
|
||||
dap::SetBreakpointsResponse response;
|
||||
dap::Breakpoint bp;
|
||||
bp.line = 2;
|
||||
response.breakpoints.emplace_back(std::move(bp));
|
||||
return response;
|
||||
});
|
||||
|
||||
bind();
|
||||
|
||||
auto got = client->send(dap::SetBreakpointsRequest{}).get();
|
||||
|
||||
// Check response was received correctly.
|
||||
ASSERT_EQ(got.error, false);
|
||||
ASSERT_EQ(got.response.breakpoints.size(), 1U);
|
||||
}
|
||||
|
||||
TEST_F(SessionTest, RequestResponseOrError) {
|
||||
server->registerHandler(
|
||||
[&](const dap::TestRequest&) -> dap::ResponseOrError<dap::TestResponse> {
|
||||
return dap::Error("Oh noes!");
|
||||
});
|
||||
|
||||
bind();
|
||||
|
||||
auto response = client->send(createRequest());
|
||||
|
||||
auto got = response.get();
|
||||
|
||||
// Check response was received correctly.
|
||||
ASSERT_EQ(got.error, true);
|
||||
ASSERT_EQ(got.error.message, "Oh noes!");
|
||||
}
|
||||
|
||||
TEST_F(SessionTest, RequestResponseError) {
|
||||
server->registerHandler(
|
||||
[&](const dap::TestRequest&) { return dap::Error("Oh noes!"); });
|
||||
|
||||
bind();
|
||||
|
||||
auto response = client->send(createRequest());
|
||||
|
||||
auto got = response.get();
|
||||
|
||||
// Check response was received correctly.
|
||||
ASSERT_EQ(got.error, true);
|
||||
ASSERT_EQ(got.error.message, "Oh noes!");
|
||||
}
|
||||
|
||||
TEST_F(SessionTest, RequestCallbackResponse) {
|
||||
using ResponseCallback = std::function<void(dap::SetBreakpointsResponse)>;
|
||||
|
||||
server->registerHandler(
|
||||
[&](const dap::SetBreakpointsRequest&, const ResponseCallback& callback) {
|
||||
dap::SetBreakpointsResponse response;
|
||||
dap::Breakpoint bp;
|
||||
bp.line = 2;
|
||||
response.breakpoints.emplace_back(std::move(bp));
|
||||
callback(response);
|
||||
});
|
||||
|
||||
bind();
|
||||
|
||||
auto got = client->send(dap::SetBreakpointsRequest{}).get();
|
||||
|
||||
// Check response was received correctly.
|
||||
ASSERT_EQ(got.error, false);
|
||||
ASSERT_EQ(got.response.breakpoints.size(), 1U);
|
||||
}
|
||||
|
||||
TEST_F(SessionTest, RequestCallbackResponseOrError) {
|
||||
using ResponseCallback =
|
||||
std::function<void(dap::ResponseOrError<dap::SetBreakpointsResponse>)>;
|
||||
|
||||
server->registerHandler(
|
||||
[&](const dap::SetBreakpointsRequest&, const ResponseCallback& callback) {
|
||||
dap::SetBreakpointsResponse response;
|
||||
dap::Breakpoint bp;
|
||||
bp.line = 2;
|
||||
response.breakpoints.emplace_back(std::move(bp));
|
||||
callback(response);
|
||||
});
|
||||
|
||||
bind();
|
||||
|
||||
auto got = client->send(dap::SetBreakpointsRequest{}).get();
|
||||
|
||||
// Check response was received correctly.
|
||||
ASSERT_EQ(got.error, false);
|
||||
ASSERT_EQ(got.response.breakpoints.size(), 1U);
|
||||
}
|
||||
|
||||
TEST_F(SessionTest, RequestCallbackError) {
|
||||
using ResponseCallback =
|
||||
std::function<void(dap::ResponseOrError<dap::SetBreakpointsResponse>)>;
|
||||
|
||||
server->registerHandler(
|
||||
[&](const dap::SetBreakpointsRequest&, const ResponseCallback& callback) {
|
||||
callback(dap::Error("Oh noes!"));
|
||||
});
|
||||
|
||||
bind();
|
||||
|
||||
auto got = client->send(dap::SetBreakpointsRequest{}).get();
|
||||
|
||||
// Check response was received correctly.
|
||||
ASSERT_EQ(got.error, true);
|
||||
ASSERT_EQ(got.error.message, "Oh noes!");
|
||||
}
|
||||
|
||||
TEST_F(SessionTest, RequestCallbackSuccessAfterReturn) {
|
||||
using ResponseCallback =
|
||||
std::function<void(dap::ResponseOrError<dap::SetBreakpointsResponse>)>;
|
||||
|
||||
ResponseCallback callback;
|
||||
std::mutex mutex;
|
||||
std::condition_variable cv;
|
||||
|
||||
server->registerHandler(
|
||||
[&](const dap::SetBreakpointsRequest&, const ResponseCallback& cb) {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
callback = cb;
|
||||
cv.notify_all();
|
||||
});
|
||||
|
||||
bind();
|
||||
|
||||
auto future = client->send(dap::SetBreakpointsRequest{});
|
||||
|
||||
{
|
||||
dap::SetBreakpointsResponse response;
|
||||
dap::Breakpoint bp;
|
||||
bp.line = 2;
|
||||
response.breakpoints.emplace_back(std::move(bp));
|
||||
|
||||
// Wait for the handler to be called.
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
cv.wait(lock, [&] { return static_cast<bool>(callback); });
|
||||
|
||||
// Issue the callback
|
||||
callback(response);
|
||||
}
|
||||
|
||||
auto got = future.get();
|
||||
|
||||
// Check response was received correctly.
|
||||
ASSERT_EQ(got.error, false);
|
||||
ASSERT_EQ(got.response.breakpoints.size(), 1U);
|
||||
}
|
||||
|
||||
TEST_F(SessionTest, RequestCallbackErrorAfterReturn) {
|
||||
using ResponseCallback =
|
||||
std::function<void(dap::ResponseOrError<dap::SetBreakpointsResponse>)>;
|
||||
|
||||
ResponseCallback callback;
|
||||
std::mutex mutex;
|
||||
std::condition_variable cv;
|
||||
|
||||
server->registerHandler(
|
||||
[&](const dap::SetBreakpointsRequest&, const ResponseCallback& cb) {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
callback = cb;
|
||||
cv.notify_all();
|
||||
});
|
||||
|
||||
bind();
|
||||
|
||||
auto future = client->send(dap::SetBreakpointsRequest{});
|
||||
|
||||
{
|
||||
// Wait for the handler to be called.
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
cv.wait(lock, [&] { return static_cast<bool>(callback); });
|
||||
|
||||
// Issue the callback
|
||||
callback(dap::Error("Oh noes!"));
|
||||
}
|
||||
|
||||
auto got = future.get();
|
||||
|
||||
// Check response was received correctly.
|
||||
ASSERT_EQ(got.error, true);
|
||||
ASSERT_EQ(got.error.message, "Oh noes!");
|
||||
}
|
||||
|
||||
TEST_F(SessionTest, ResponseSentHandlerSuccess) {
|
||||
const auto response = createResponse();
|
||||
|
||||
dap::Chan<dap::ResponseOrError<dap::TestResponse>> chan;
|
||||
server->registerHandler([&](const dap::TestRequest&) { return response; });
|
||||
server->registerSentHandler(
|
||||
[&](const dap::ResponseOrError<dap::TestResponse> r) { chan.put(r); });
|
||||
|
||||
bind();
|
||||
|
||||
client->send(createRequest());
|
||||
|
||||
auto got = chan.take().value();
|
||||
ASSERT_EQ(got.error, false);
|
||||
ASSERT_EQ(got.response.b, dap::boolean(true));
|
||||
ASSERT_EQ(got.response.i, dap::integer(99));
|
||||
ASSERT_EQ(got.response.n, dap::number(123.456));
|
||||
ASSERT_EQ(got.response.a, dap::array<dap::integer>({5, 4, 3, 2, 1}));
|
||||
ASSERT_EQ(got.response.o.size(), 3U);
|
||||
ASSERT_EQ(got.response.o["one"].get<dap::integer>(), dap::integer(1));
|
||||
ASSERT_EQ(got.response.o["two"].get<dap::number>(), dap::number(2));
|
||||
ASSERT_EQ(got.response.o["three"].get<dap::string>(), dap::string("3"));
|
||||
ASSERT_EQ(got.response.s, "ROGER");
|
||||
ASSERT_EQ(got.response.o1, dap::optional<dap::integer>(50));
|
||||
ASSERT_FALSE(got.response.o2.has_value());
|
||||
}
|
||||
|
||||
TEST_F(SessionTest, ResponseSentHandlerError) {
|
||||
dap::Chan<dap::ResponseOrError<dap::TestResponse>> chan;
|
||||
server->registerHandler(
|
||||
[&](const dap::TestRequest&) { return dap::Error("Oh noes!"); });
|
||||
server->registerSentHandler(
|
||||
[&](const dap::ResponseOrError<dap::TestResponse> r) { chan.put(r); });
|
||||
|
||||
bind();
|
||||
|
||||
client->send(createRequest());
|
||||
|
||||
auto got = chan.take().value();
|
||||
ASSERT_EQ(got.error, true);
|
||||
ASSERT_EQ(got.error.message, "Oh noes!");
|
||||
}
|
||||
|
||||
TEST_F(SessionTest, Event) {
|
||||
dap::Chan<dap::TestEvent> received;
|
||||
server->registerHandler([&](const dap::TestEvent& e) { received.put(e); });
|
||||
|
||||
bind();
|
||||
|
||||
auto event = createEvent();
|
||||
client->send(event);
|
||||
|
||||
// Check event was received correctly.
|
||||
auto got = received.take().value();
|
||||
|
||||
ASSERT_EQ(got.b, event.b);
|
||||
ASSERT_EQ(got.i, event.i);
|
||||
ASSERT_EQ(got.n, event.n);
|
||||
ASSERT_EQ(got.a, event.a);
|
||||
ASSERT_EQ(got.o.size(), 3U);
|
||||
ASSERT_EQ(got.o["a"].get<dap::integer>(), event.o["a"].get<dap::integer>());
|
||||
ASSERT_EQ(got.o["b"].get<dap::number>(), event.o["b"].get<dap::number>());
|
||||
ASSERT_EQ(got.o["c"].get<dap::string>(), event.o["c"].get<dap::string>());
|
||||
ASSERT_EQ(got.s, event.s);
|
||||
ASSERT_EQ(got.o1, event.o1);
|
||||
ASSERT_EQ(got.o2, event.o2);
|
||||
}
|
||||
|
||||
TEST_F(SessionTest, RegisterHandlerFunction) {
|
||||
struct S {
|
||||
static dap::TestResponse requestA(const dap::TestRequest&) { return {}; }
|
||||
static dap::Error requestB(const dap::TestRequest&) { return {}; }
|
||||
static dap::ResponseOrError<dap::TestResponse> requestC(
|
||||
const dap::TestRequest&) {
|
||||
return dap::Error();
|
||||
}
|
||||
static void event(const dap::TestEvent&) {}
|
||||
static void sent(const dap::ResponseOrError<dap::TestResponse>&) {}
|
||||
};
|
||||
client->registerHandler(&S::requestA);
|
||||
client->registerHandler(&S::requestB);
|
||||
client->registerHandler(&S::requestC);
|
||||
client->registerHandler(&S::event);
|
||||
client->registerSentHandler(&S::sent);
|
||||
}
|
||||
|
||||
TEST_F(SessionTest, SendRequestNoBind) {
|
||||
bool errored = false;
|
||||
client->onError([&](const std::string&) { errored = true; });
|
||||
auto res = client->send(createRequest()).get();
|
||||
ASSERT_TRUE(errored);
|
||||
ASSERT_TRUE(res.error);
|
||||
}
|
||||
|
||||
TEST_F(SessionTest, SendEventNoBind) {
|
||||
bool errored = false;
|
||||
client->onError([&](const std::string&) { errored = true; });
|
||||
client->send(createEvent());
|
||||
ASSERT_TRUE(errored);
|
||||
}
|
||||
|
||||
TEST_F(SessionTest, SingleThread) {
|
||||
server->registerHandler(
|
||||
[&](const dap::TestRequest&) { return createResponse(); });
|
||||
|
||||
// Explicitly connect and process request on this test thread instead of
|
||||
// calling bind() which inturn starts processing messages immediately on a new
|
||||
// thread.
|
||||
auto client2server = dap::pipe();
|
||||
auto server2client = dap::pipe();
|
||||
client->connect(server2client, client2server);
|
||||
server->connect(client2server, server2client);
|
||||
|
||||
auto request = createRequest();
|
||||
auto response = client->send(request);
|
||||
|
||||
// Process request and response on this thread
|
||||
if (auto payload = server->getPayload()) {
|
||||
payload();
|
||||
}
|
||||
if (auto payload = client->getPayload()) {
|
||||
payload();
|
||||
}
|
||||
|
||||
auto got = response.get();
|
||||
// Check response was received correctly.
|
||||
ASSERT_EQ(got.error, false);
|
||||
ASSERT_EQ(got.response.b, dap::boolean(true));
|
||||
ASSERT_EQ(got.response.i, dap::integer(99));
|
||||
ASSERT_EQ(got.response.n, dap::number(123.456));
|
||||
ASSERT_EQ(got.response.a, dap::array<dap::integer>({5, 4, 3, 2, 1}));
|
||||
ASSERT_EQ(got.response.o.size(), 3U);
|
||||
ASSERT_EQ(got.response.o["one"].get<dap::integer>(), dap::integer(1));
|
||||
ASSERT_EQ(got.response.o["two"].get<dap::number>(), dap::number(2));
|
||||
ASSERT_EQ(got.response.o["three"].get<dap::string>(), dap::string("3"));
|
||||
ASSERT_EQ(got.response.s, "ROGER");
|
||||
ASSERT_EQ(got.response.o1, dap::optional<dap::integer>(50));
|
||||
ASSERT_FALSE(got.response.o2.has_value());
|
||||
}
|
||||
|
||||
TEST_F(SessionTest, Concurrency) {
|
||||
std::atomic<int> numEventsHandled = {0};
|
||||
std::atomic<bool> done = {false};
|
||||
|
||||
server->registerHandler(
|
||||
[](const dap::TestRequest&) { return dap::TestResponse(); });
|
||||
|
||||
server->registerHandler([&](const dap::TestEvent&) {
|
||||
if (numEventsHandled++ > 10000) {
|
||||
done = true;
|
||||
}
|
||||
});
|
||||
|
||||
bind();
|
||||
|
||||
constexpr int numThreads = 32;
|
||||
std::array<std::thread, numThreads> threads;
|
||||
|
||||
for (int i = 0; i < numThreads; i++) {
|
||||
threads[i] = std::thread([&] {
|
||||
while (!done) {
|
||||
client->send(createEvent());
|
||||
client->send(createRequest());
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
for (int i = 0; i < numThreads; i++) {
|
||||
threads[i].join();
|
||||
}
|
||||
|
||||
client.reset();
|
||||
server.reset();
|
||||
}
|
||||
|
||||
TEST_F(SessionTest, OnClientClosed) {
|
||||
std::mutex mutex;
|
||||
std::condition_variable cv;
|
||||
bool clientClosed = false;
|
||||
|
||||
auto client2server = dap::pipe();
|
||||
auto server2client = dap::pipe();
|
||||
|
||||
client->bind(server2client, client2server);
|
||||
server->bind(client2server, server2client, [&] {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
clientClosed = true;
|
||||
cv.notify_all();
|
||||
});
|
||||
|
||||
client.reset();
|
||||
|
||||
// Wait for the client closed handler to be called.
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
cv.wait(lock, [&] { return static_cast<bool>(clientClosed); });
|
||||
}
|
||||
|
||||
TEST_F(SessionTest, OnServerClosed) {
|
||||
std::mutex mutex;
|
||||
std::condition_variable cv;
|
||||
bool serverClosed = false;
|
||||
|
||||
auto client2server = dap::pipe();
|
||||
auto server2client = dap::pipe();
|
||||
|
||||
client->bind(server2client, client2server, [&] {
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
serverClosed = true;
|
||||
cv.notify_all();
|
||||
});
|
||||
server->bind(client2server, server2client);
|
||||
|
||||
server.reset();
|
||||
|
||||
// Wait for the client closed handler to be called.
|
||||
std::unique_lock<std::mutex> lock(mutex);
|
||||
cv.wait(lock, [&] { return static_cast<bool>(serverClosed); });
|
||||
}
|
||||
337
libraries/cppdap/src/socket.cpp
Normal file
337
libraries/cppdap/src/socket.cpp
Normal file
|
|
@ -0,0 +1,337 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "socket.h"
|
||||
|
||||
#include "rwmutex.h"
|
||||
|
||||
#if defined(_WIN32)
|
||||
#include <winsock2.h>
|
||||
#include <ws2tcpip.h>
|
||||
#else
|
||||
#include <netdb.h>
|
||||
#include <netinet/in.h>
|
||||
#include <netinet/tcp.h>
|
||||
#include <sys/select.h>
|
||||
#include <sys/socket.h>
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
#if defined(_WIN32)
|
||||
#include <atomic>
|
||||
namespace {
|
||||
std::atomic<int> wsaInitCount = {0};
|
||||
} // anonymous namespace
|
||||
#else
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
namespace {
|
||||
using SOCKET = int;
|
||||
} // anonymous namespace
|
||||
#endif
|
||||
|
||||
namespace {
|
||||
constexpr SOCKET InvalidSocket = static_cast<SOCKET>(-1);
|
||||
void init() {
|
||||
#if defined(_WIN32)
|
||||
if (wsaInitCount++ == 0) {
|
||||
WSADATA winsockData;
|
||||
(void)WSAStartup(MAKEWORD(2, 2), &winsockData);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
void term() {
|
||||
#if defined(_WIN32)
|
||||
if (--wsaInitCount == 0) {
|
||||
WSACleanup();
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
bool setBlocking(SOCKET s, bool blocking) {
|
||||
#if defined(_WIN32)
|
||||
u_long mode = blocking ? 0 : 1;
|
||||
return ioctlsocket(s, FIONBIO, &mode) == NO_ERROR;
|
||||
#else
|
||||
auto arg = fcntl(s, F_GETFL, nullptr);
|
||||
if (arg < 0) {
|
||||
return false;
|
||||
}
|
||||
arg = blocking ? (arg & ~O_NONBLOCK) : (arg | O_NONBLOCK);
|
||||
return fcntl(s, F_SETFL, arg) >= 0;
|
||||
#endif
|
||||
}
|
||||
|
||||
bool errored(SOCKET s) {
|
||||
if (s == InvalidSocket) {
|
||||
return true;
|
||||
}
|
||||
char error = 0;
|
||||
socklen_t len = sizeof(error);
|
||||
getsockopt(s, SOL_SOCKET, SO_ERROR, &error, &len);
|
||||
return error != 0;
|
||||
}
|
||||
|
||||
} // anonymous namespace
|
||||
|
||||
class dap::Socket::Shared : public dap::ReaderWriter {
|
||||
public:
|
||||
static std::shared_ptr<Shared> create(const char* address, const char* port) {
|
||||
init();
|
||||
|
||||
addrinfo hints = {};
|
||||
hints.ai_family = AF_INET;
|
||||
hints.ai_socktype = SOCK_STREAM;
|
||||
hints.ai_protocol = IPPROTO_TCP;
|
||||
hints.ai_flags = AI_PASSIVE;
|
||||
|
||||
addrinfo* info = nullptr;
|
||||
getaddrinfo(address, port, &hints, &info);
|
||||
|
||||
if (info) {
|
||||
auto socket =
|
||||
::socket(info->ai_family, info->ai_socktype, info->ai_protocol);
|
||||
auto out = std::make_shared<Shared>(info, socket);
|
||||
out->setOptions();
|
||||
return out;
|
||||
}
|
||||
|
||||
term();
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
Shared(SOCKET socket) : info(nullptr), s(socket) {}
|
||||
Shared(addrinfo* info, SOCKET socket) : info(info), s(socket) {}
|
||||
|
||||
~Shared() {
|
||||
if (info) {
|
||||
freeaddrinfo(info);
|
||||
}
|
||||
close();
|
||||
term();
|
||||
}
|
||||
|
||||
template <typename FUNCTION>
|
||||
void lock(FUNCTION&& f) {
|
||||
RLock l(mutex);
|
||||
f(s, info);
|
||||
}
|
||||
|
||||
void setOptions() {
|
||||
RLock l(mutex);
|
||||
if (s == InvalidSocket) {
|
||||
return;
|
||||
}
|
||||
|
||||
int enable = 1;
|
||||
|
||||
#if !defined(_WIN32)
|
||||
// Prevent sockets lingering after process termination, causing
|
||||
// reconnection issues on the same port.
|
||||
setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char*)&enable, sizeof(enable));
|
||||
|
||||
struct {
|
||||
int l_onoff; /* linger active */
|
||||
int l_linger; /* how many seconds to linger for */
|
||||
} linger = {false, 0};
|
||||
setsockopt(s, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(linger));
|
||||
#endif // !defined(_WIN32)
|
||||
|
||||
// Enable TCP_NODELAY.
|
||||
// DAP usually consists of small packet requests, with small packet
|
||||
// responses. When there are many frequent, blocking requests made,
|
||||
// Nagle's algorithm can dramatically limit the request->response rates.
|
||||
setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char*)&enable, sizeof(enable));
|
||||
}
|
||||
|
||||
// dap::ReaderWriter compliance
|
||||
bool isOpen() {
|
||||
{
|
||||
RLock l(mutex);
|
||||
if ((s != InvalidSocket) && !errored(s)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
WLock lock(mutex);
|
||||
s = InvalidSocket;
|
||||
return false;
|
||||
}
|
||||
|
||||
void close() {
|
||||
{
|
||||
RLock l(mutex);
|
||||
if (s != InvalidSocket) {
|
||||
#if defined(_WIN32)
|
||||
closesocket(s);
|
||||
#elif __APPLE__
|
||||
// ::shutdown() *should* be sufficient to unblock ::accept(), but
|
||||
// apparently on macos it can return ENOTCONN and ::accept() continues
|
||||
// to block indefinitely.
|
||||
// Note: There is a race here. Calling ::close() frees the socket ID,
|
||||
// which may be reused before `s` is assigned InvalidSocket.
|
||||
::shutdown(s, SHUT_RDWR);
|
||||
::close(s);
|
||||
#else
|
||||
// ::shutdown() to unblock ::accept(). We'll actually close the socket
|
||||
// under lock below.
|
||||
::shutdown(s, SHUT_RDWR);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
WLock l(mutex);
|
||||
if (s != InvalidSocket) {
|
||||
#if !defined(_WIN32) && !defined(__APPLE__)
|
||||
::close(s);
|
||||
#endif
|
||||
s = InvalidSocket;
|
||||
}
|
||||
}
|
||||
|
||||
size_t read(void* buffer, size_t bytes) {
|
||||
RLock lock(mutex);
|
||||
if (s == InvalidSocket) {
|
||||
return 0;
|
||||
}
|
||||
auto len =
|
||||
recv(s, reinterpret_cast<char*>(buffer), static_cast<int>(bytes), 0);
|
||||
return (len < 0) ? 0 : len;
|
||||
}
|
||||
|
||||
bool write(const void* buffer, size_t bytes) {
|
||||
RLock lock(mutex);
|
||||
if (s == InvalidSocket) {
|
||||
return false;
|
||||
}
|
||||
if (bytes == 0) {
|
||||
return true;
|
||||
}
|
||||
return ::send(s, reinterpret_cast<const char*>(buffer),
|
||||
static_cast<int>(bytes), 0) > 0;
|
||||
}
|
||||
|
||||
private:
|
||||
addrinfo* const info;
|
||||
SOCKET s = InvalidSocket;
|
||||
RWMutex mutex;
|
||||
};
|
||||
|
||||
namespace dap {
|
||||
|
||||
Socket::Socket(const char* address, const char* port)
|
||||
: shared(Shared::create(address, port)) {
|
||||
if (shared) {
|
||||
bool reset = false;
|
||||
shared->lock([&](SOCKET socket, const addrinfo* info) {
|
||||
if (bind(socket, info->ai_addr, (int)info->ai_addrlen) != 0) {
|
||||
reset = true;
|
||||
return;
|
||||
}
|
||||
|
||||
if (listen(socket, 0) != 0) {
|
||||
reset = true;
|
||||
}
|
||||
});
|
||||
if (reset) {
|
||||
shared.reset();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::shared_ptr<ReaderWriter> Socket::accept() const {
|
||||
std::shared_ptr<Shared> out;
|
||||
if (shared) {
|
||||
shared->lock([&](SOCKET socket, const addrinfo*) {
|
||||
if (socket != InvalidSocket && !errored(socket)) {
|
||||
init();
|
||||
auto accepted = ::accept(socket, 0, 0);
|
||||
if (accepted != InvalidSocket) {
|
||||
out = std::make_shared<Shared>(accepted);
|
||||
out->setOptions();
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
bool Socket::isOpen() const {
|
||||
if (shared) {
|
||||
return shared->isOpen();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void Socket::close() const {
|
||||
if (shared) {
|
||||
shared->close();
|
||||
}
|
||||
}
|
||||
|
||||
std::shared_ptr<ReaderWriter> Socket::connect(const char* address,
|
||||
const char* port,
|
||||
uint32_t timeoutMillis) {
|
||||
auto shared = Shared::create(address, port);
|
||||
if (!shared) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
std::shared_ptr<ReaderWriter> out;
|
||||
shared->lock([&](SOCKET socket, const addrinfo* info) {
|
||||
if (socket == InvalidSocket) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (timeoutMillis == 0) {
|
||||
if (::connect(socket, info->ai_addr, (int)info->ai_addrlen) == 0) {
|
||||
out = shared;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (!setBlocking(socket, false)) {
|
||||
return;
|
||||
}
|
||||
|
||||
auto res = ::connect(socket, info->ai_addr, (int)info->ai_addrlen);
|
||||
if (res == 0) {
|
||||
if (setBlocking(socket, true)) {
|
||||
out = shared;
|
||||
}
|
||||
} else {
|
||||
const auto microseconds = timeoutMillis * 1000;
|
||||
|
||||
fd_set fdset;
|
||||
FD_ZERO(&fdset);
|
||||
FD_SET(socket, &fdset);
|
||||
|
||||
timeval tv;
|
||||
tv.tv_sec = microseconds / 1000000;
|
||||
tv.tv_usec = microseconds - static_cast<uint32_t>(tv.tv_sec * 1000000);
|
||||
res = select(static_cast<int>(socket + 1), nullptr, &fdset, nullptr, &tv);
|
||||
if (res > 0 && !errored(socket) && setBlocking(socket, true)) {
|
||||
out = shared;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
if (!out) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
return out->isOpen() ? out : nullptr;
|
||||
}
|
||||
|
||||
} // namespace dap
|
||||
47
libraries/cppdap/src/socket.h
Normal file
47
libraries/cppdap/src/socket.h
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifndef dap_socket_h
|
||||
#define dap_socket_h
|
||||
|
||||
#include "dap/io.h"
|
||||
|
||||
#include <atomic>
|
||||
#include <memory>
|
||||
|
||||
namespace dap {
|
||||
|
||||
class Socket {
|
||||
public:
|
||||
class Shared;
|
||||
|
||||
// connect() connects to the given TCP address and port.
|
||||
// If timeoutMillis is non-zero and no connection was made before
|
||||
// timeoutMillis milliseconds, then nullptr is returned.
|
||||
static std::shared_ptr<ReaderWriter> connect(const char* address,
|
||||
const char* port,
|
||||
uint32_t timeoutMillis);
|
||||
|
||||
Socket(const char* address, const char* port);
|
||||
bool isOpen() const;
|
||||
std::shared_ptr<ReaderWriter> accept() const;
|
||||
void close() const;
|
||||
|
||||
private:
|
||||
std::shared_ptr<Shared> shared;
|
||||
};
|
||||
|
||||
} // namespace dap
|
||||
|
||||
#endif // dap_socket_h
|
||||
104
libraries/cppdap/src/socket_test.cpp
Normal file
104
libraries/cppdap/src/socket_test.cpp
Normal file
|
|
@ -0,0 +1,104 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "socket.h"
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
#include <chrono>
|
||||
#include <thread>
|
||||
#include <vector>
|
||||
|
||||
// Basic socket send & receive test
|
||||
TEST(Socket, SendRecv) {
|
||||
const char* port = "19021";
|
||||
|
||||
auto server = dap::Socket("localhost", port);
|
||||
|
||||
auto client = dap::Socket::connect("localhost", port, 0);
|
||||
ASSERT_TRUE(client != nullptr);
|
||||
|
||||
const std::string expect = "Hello World!";
|
||||
std::string read;
|
||||
|
||||
auto thread = std::thread([&] {
|
||||
auto conn = server.accept();
|
||||
ASSERT_TRUE(conn != nullptr);
|
||||
char c;
|
||||
while (conn->read(&c, 1) != 0) {
|
||||
read += c;
|
||||
}
|
||||
});
|
||||
|
||||
ASSERT_TRUE(client->write(expect.data(), expect.size()));
|
||||
|
||||
client->close();
|
||||
thread.join();
|
||||
|
||||
ASSERT_EQ(read, expect);
|
||||
}
|
||||
|
||||
// See https://github.com/google/cppdap/issues/37
|
||||
TEST(Socket, CloseOnDifferentThread) {
|
||||
const char* port = "19021";
|
||||
|
||||
auto server = dap::Socket("localhost", port);
|
||||
|
||||
auto client = dap::Socket::connect("localhost", port, 0);
|
||||
ASSERT_TRUE(client != nullptr);
|
||||
|
||||
auto conn = server.accept();
|
||||
|
||||
auto thread = std::thread([&] {
|
||||
// Closing client on different thread should unblock client->read().
|
||||
client->close();
|
||||
});
|
||||
|
||||
char c;
|
||||
while (client->read(&c, 1) != 0) {
|
||||
}
|
||||
|
||||
thread.join();
|
||||
}
|
||||
|
||||
TEST(Socket, ConnectTimeout) {
|
||||
const char* port = "19021";
|
||||
const int timeoutMillis = 200;
|
||||
const int maxAttempts = 1024;
|
||||
|
||||
using namespace std::chrono;
|
||||
|
||||
auto server = dap::Socket("localhost", port);
|
||||
|
||||
std::vector<std::shared_ptr<dap::ReaderWriter>> connections;
|
||||
|
||||
for (int i = 0; i < maxAttempts; i++) {
|
||||
auto start = system_clock::now();
|
||||
auto connection = dap::Socket::connect("localhost", port, timeoutMillis);
|
||||
auto end = system_clock::now();
|
||||
|
||||
if (!connection) {
|
||||
auto timeTakenMillis = duration_cast<milliseconds>(end - start).count();
|
||||
ASSERT_GE(timeTakenMillis + 20, // +20ms for a bit of timing wiggle room
|
||||
timeoutMillis);
|
||||
return;
|
||||
}
|
||||
|
||||
// Keep hold of the connections to saturate any incoming socket buffers.
|
||||
connections.emplace_back(std::move(connection));
|
||||
}
|
||||
|
||||
FAIL() << "Failed to test timeout after " << maxAttempts << " attempts";
|
||||
}
|
||||
95
libraries/cppdap/src/string_buffer.h
Normal file
95
libraries/cppdap/src/string_buffer.h
Normal file
|
|
@ -0,0 +1,95 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#ifndef dap_string_buffer_h
|
||||
#define dap_string_buffer_h
|
||||
|
||||
#include "dap/io.h"
|
||||
|
||||
#include <algorithm> // std::min
|
||||
#include <cstring> // memcpy
|
||||
#include <deque>
|
||||
#include <memory> // std::unique_ptr
|
||||
#include <string>
|
||||
|
||||
namespace dap {
|
||||
|
||||
class StringBuffer : public virtual Reader, public virtual Writer {
|
||||
public:
|
||||
static inline std::unique_ptr<StringBuffer> create();
|
||||
|
||||
inline bool write(const std::string& s);
|
||||
inline std::string string() const;
|
||||
|
||||
// Reader / Writer compilance
|
||||
inline bool isOpen() override;
|
||||
inline void close() override;
|
||||
inline size_t read(void* buffer, size_t bytes) override;
|
||||
inline bool write(const void* buffer, size_t bytes) override;
|
||||
|
||||
private:
|
||||
std::string str;
|
||||
std::deque<size_t> chunk_lengths;
|
||||
bool closed = false;
|
||||
};
|
||||
|
||||
bool StringBuffer::isOpen() {
|
||||
return !closed;
|
||||
}
|
||||
void StringBuffer::close() {
|
||||
closed = true;
|
||||
}
|
||||
|
||||
std::unique_ptr<StringBuffer> StringBuffer::create() {
|
||||
return std::unique_ptr<StringBuffer>(new StringBuffer());
|
||||
}
|
||||
|
||||
bool StringBuffer::write(const std::string& s) {
|
||||
return write(s.data(), s.size());
|
||||
}
|
||||
|
||||
std::string StringBuffer::string() const {
|
||||
return str;
|
||||
}
|
||||
|
||||
size_t StringBuffer::read(void* buffer, size_t bytes) {
|
||||
if (closed || bytes == 0 || str.size() == 0 || chunk_lengths.size() == 0) {
|
||||
return 0;
|
||||
}
|
||||
size_t& chunk_length = chunk_lengths.front();
|
||||
|
||||
auto len = std::min(bytes, chunk_length);
|
||||
memcpy(buffer, str.data(), len);
|
||||
str = std::string(str.begin() + len, str.end());
|
||||
if (bytes < chunk_length) {
|
||||
chunk_length -= bytes;
|
||||
} else {
|
||||
chunk_lengths.pop_front();
|
||||
}
|
||||
return len;
|
||||
}
|
||||
|
||||
bool StringBuffer::write(const void* buffer, size_t bytes) {
|
||||
if (closed) {
|
||||
return false;
|
||||
}
|
||||
auto chars = reinterpret_cast<const char*>(buffer);
|
||||
str.append(chars, chars + bytes);
|
||||
chunk_lengths.push_back(bytes);
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace dap
|
||||
|
||||
#endif // dap_string_buffer_h
|
||||
387
libraries/cppdap/src/traits_test.cpp
Normal file
387
libraries/cppdap/src/traits_test.cpp
Normal file
|
|
@ -0,0 +1,387 @@
|
|||
// Copyright 2021 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "dap/traits.h"
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
namespace dap {
|
||||
namespace traits {
|
||||
|
||||
namespace {
|
||||
struct S {};
|
||||
struct E : S {};
|
||||
void F1(S) {}
|
||||
void F3(int, S, float) {}
|
||||
void E1(E) {}
|
||||
void E3(int, E, float) {}
|
||||
} // namespace
|
||||
|
||||
TEST(ParameterType, Function) {
|
||||
F1({}); // Avoid unused method warning
|
||||
F3(0, {}, 0); // Avoid unused method warning
|
||||
static_assert(std::is_same<ParameterType<decltype(&F1), 0>, S>::value, "");
|
||||
static_assert(std::is_same<ParameterType<decltype(&F3), 0>, int>::value, "");
|
||||
static_assert(std::is_same<ParameterType<decltype(&F3), 1>, S>::value, "");
|
||||
static_assert(std::is_same<ParameterType<decltype(&F3), 2>, float>::value,
|
||||
"");
|
||||
}
|
||||
|
||||
TEST(ParameterType, Method) {
|
||||
class C {
|
||||
public:
|
||||
void F1(S) {}
|
||||
void F3(int, S, float) {}
|
||||
};
|
||||
C().F1({}); // Avoid unused method warning
|
||||
C().F3(0, {}, 0); // Avoid unused method warning
|
||||
static_assert(std::is_same<ParameterType<decltype(&C::F1), 0>, S>::value, "");
|
||||
static_assert(std::is_same<ParameterType<decltype(&C::F3), 0>, int>::value,
|
||||
"");
|
||||
static_assert(std::is_same<ParameterType<decltype(&C::F3), 1>, S>::value, "");
|
||||
static_assert(std::is_same<ParameterType<decltype(&C::F3), 2>, float>::value,
|
||||
"");
|
||||
}
|
||||
|
||||
TEST(ParameterType, ConstMethod) {
|
||||
class C {
|
||||
public:
|
||||
void F1(S) const {}
|
||||
void F3(int, S, float) const {}
|
||||
};
|
||||
C().F1({}); // Avoid unused method warning
|
||||
C().F3(0, {}, 0); // Avoid unused method warning
|
||||
static_assert(std::is_same<ParameterType<decltype(&C::F1), 0>, S>::value, "");
|
||||
static_assert(std::is_same<ParameterType<decltype(&C::F3), 0>, int>::value,
|
||||
"");
|
||||
static_assert(std::is_same<ParameterType<decltype(&C::F3), 1>, S>::value, "");
|
||||
static_assert(std::is_same<ParameterType<decltype(&C::F3), 2>, float>::value,
|
||||
"");
|
||||
}
|
||||
|
||||
TEST(ParameterType, StaticMethod) {
|
||||
class C {
|
||||
public:
|
||||
static void F1(S) {}
|
||||
static void F3(int, S, float) {}
|
||||
};
|
||||
C::F1({}); // Avoid unused method warning
|
||||
C::F3(0, {}, 0); // Avoid unused method warning
|
||||
static_assert(std::is_same<ParameterType<decltype(&C::F1), 0>, S>::value, "");
|
||||
static_assert(std::is_same<ParameterType<decltype(&C::F3), 0>, int>::value,
|
||||
"");
|
||||
static_assert(std::is_same<ParameterType<decltype(&C::F3), 1>, S>::value, "");
|
||||
static_assert(std::is_same<ParameterType<decltype(&C::F3), 2>, float>::value,
|
||||
"");
|
||||
}
|
||||
|
||||
TEST(ParameterType, FunctionLike) {
|
||||
using F1 = std::function<void(S)>;
|
||||
using F3 = std::function<void(int, S, float)>;
|
||||
static_assert(std::is_same<ParameterType<F1, 0>, S>::value, "");
|
||||
static_assert(std::is_same<ParameterType<F3, 0>, int>::value, "");
|
||||
static_assert(std::is_same<ParameterType<F3, 1>, S>::value, "");
|
||||
static_assert(std::is_same<ParameterType<F3, 2>, float>::value, "");
|
||||
}
|
||||
|
||||
TEST(ParameterType, Lambda) {
|
||||
auto l1 = [](S) {};
|
||||
auto l3 = [](int, S, float) {};
|
||||
static_assert(std::is_same<ParameterType<decltype(l1), 0>, S>::value, "");
|
||||
static_assert(std::is_same<ParameterType<decltype(l3), 0>, int>::value, "");
|
||||
static_assert(std::is_same<ParameterType<decltype(l3), 1>, S>::value, "");
|
||||
static_assert(std::is_same<ParameterType<decltype(l3), 2>, float>::value, "");
|
||||
}
|
||||
|
||||
TEST(HasSignature, Function) {
|
||||
F1({}); // Avoid unused method warning
|
||||
F3(0, {}, 0); // Avoid unused method warning
|
||||
static_assert(HasSignature<decltype(&F1), decltype(&F1)>::value, "");
|
||||
static_assert(HasSignature<decltype(&F3), decltype(&F3)>::value, "");
|
||||
static_assert(HasSignature<decltype(&F3), decltype(&F3)>::value, "");
|
||||
static_assert(HasSignature<decltype(&F3), decltype(&F3)>::value, "");
|
||||
static_assert(!HasSignature<decltype(&F1), decltype(&F3)>::value, "");
|
||||
static_assert(!HasSignature<decltype(&F3), decltype(&F1)>::value, "");
|
||||
static_assert(!HasSignature<decltype(&F3), decltype(&F1)>::value, "");
|
||||
static_assert(!HasSignature<decltype(&F3), decltype(&F1)>::value, "");
|
||||
}
|
||||
|
||||
TEST(HasSignature, Method) {
|
||||
class C {
|
||||
public:
|
||||
void F1(S) {}
|
||||
void F3(int, S, float) {}
|
||||
};
|
||||
C().F1({}); // Avoid unused method warning
|
||||
C().F3(0, {}, 0); // Avoid unused method warning
|
||||
|
||||
static_assert(HasSignature<decltype(&C::F1), decltype(&F1)>::value, "");
|
||||
static_assert(HasSignature<decltype(&C::F3), decltype(&F3)>::value, "");
|
||||
static_assert(HasSignature<decltype(&C::F3), decltype(&F3)>::value, "");
|
||||
static_assert(HasSignature<decltype(&C::F3), decltype(&F3)>::value, "");
|
||||
static_assert(!HasSignature<decltype(&C::F1), decltype(&F3)>::value, "");
|
||||
static_assert(!HasSignature<decltype(&C::F3), decltype(&F1)>::value, "");
|
||||
static_assert(!HasSignature<decltype(&C::F3), decltype(&F1)>::value, "");
|
||||
static_assert(!HasSignature<decltype(&C::F3), decltype(&F1)>::value, "");
|
||||
}
|
||||
|
||||
TEST(HasSignature, ConstMethod) {
|
||||
class C {
|
||||
public:
|
||||
void F1(S) const {}
|
||||
void F3(int, S, float) const {}
|
||||
};
|
||||
C().F1({}); // Avoid unused method warning
|
||||
C().F3(0, {}, 0); // Avoid unused method warning
|
||||
|
||||
static_assert(HasSignature<decltype(&C::F1), decltype(&F1)>::value, "");
|
||||
static_assert(HasSignature<decltype(&C::F3), decltype(&F3)>::value, "");
|
||||
static_assert(HasSignature<decltype(&C::F3), decltype(&F3)>::value, "");
|
||||
static_assert(HasSignature<decltype(&C::F3), decltype(&F3)>::value, "");
|
||||
static_assert(!HasSignature<decltype(&C::F1), decltype(&F3)>::value, "");
|
||||
static_assert(!HasSignature<decltype(&C::F3), decltype(&F1)>::value, "");
|
||||
static_assert(!HasSignature<decltype(&C::F3), decltype(&F1)>::value, "");
|
||||
static_assert(!HasSignature<decltype(&C::F3), decltype(&F1)>::value, "");
|
||||
}
|
||||
|
||||
TEST(HasSignature, StaticMethod) {
|
||||
class C {
|
||||
public:
|
||||
static void F1(S) {}
|
||||
static void F3(int, S, float) {}
|
||||
};
|
||||
C::F1({}); // Avoid unused method warning
|
||||
C::F3(0, {}, 0); // Avoid unused method warning
|
||||
|
||||
static_assert(HasSignature<decltype(&C::F1), decltype(&F1)>::value, "");
|
||||
static_assert(HasSignature<decltype(&C::F3), decltype(&F3)>::value, "");
|
||||
static_assert(HasSignature<decltype(&C::F3), decltype(&F3)>::value, "");
|
||||
static_assert(HasSignature<decltype(&C::F3), decltype(&F3)>::value, "");
|
||||
static_assert(!HasSignature<decltype(&C::F1), decltype(&F3)>::value, "");
|
||||
static_assert(!HasSignature<decltype(&C::F3), decltype(&F1)>::value, "");
|
||||
static_assert(!HasSignature<decltype(&C::F3), decltype(&F1)>::value, "");
|
||||
static_assert(!HasSignature<decltype(&C::F3), decltype(&F1)>::value, "");
|
||||
}
|
||||
|
||||
TEST(HasSignature, FunctionLike) {
|
||||
using f1 = std::function<void(S)>;
|
||||
using f3 = std::function<void(int, S, float)>;
|
||||
static_assert(HasSignature<f1, decltype(&F1)>::value, "");
|
||||
static_assert(HasSignature<f3, decltype(&F3)>::value, "");
|
||||
static_assert(HasSignature<f3, decltype(&F3)>::value, "");
|
||||
static_assert(HasSignature<f3, decltype(&F3)>::value, "");
|
||||
static_assert(!HasSignature<f1, decltype(&F3)>::value, "");
|
||||
static_assert(!HasSignature<f3, decltype(&F1)>::value, "");
|
||||
static_assert(!HasSignature<f3, decltype(&F1)>::value, "");
|
||||
static_assert(!HasSignature<f3, decltype(&F1)>::value, "");
|
||||
}
|
||||
|
||||
TEST(HasSignature, Lambda) {
|
||||
auto l1 = [](S) {};
|
||||
auto l3 = [](int, S, float) {};
|
||||
static_assert(HasSignature<decltype(l1), decltype(&F1)>::value, "");
|
||||
static_assert(HasSignature<decltype(l3), decltype(&F3)>::value, "");
|
||||
static_assert(HasSignature<decltype(l3), decltype(&F3)>::value, "");
|
||||
static_assert(HasSignature<decltype(l3), decltype(&F3)>::value, "");
|
||||
static_assert(!HasSignature<decltype(l1), decltype(&F3)>::value, "");
|
||||
static_assert(!HasSignature<decltype(l3), decltype(&F1)>::value, "");
|
||||
static_assert(!HasSignature<decltype(l3), decltype(&F1)>::value, "");
|
||||
static_assert(!HasSignature<decltype(l3), decltype(&F1)>::value, "");
|
||||
}
|
||||
|
||||
////
|
||||
|
||||
TEST(CompatibleWith, Function) {
|
||||
F1({}); // Avoid unused method warning
|
||||
F3(0, {}, 0); // Avoid unused method warning
|
||||
E1({}); // Avoid unused method warning
|
||||
E3(0, {}, 0); // Avoid unused method warning
|
||||
static_assert(CompatibleWith<decltype(&F1), decltype(&F1)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&F3), decltype(&F3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&F3), decltype(&F3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&F3), decltype(&F3)>::value, "");
|
||||
|
||||
static_assert(!CompatibleWith<decltype(&F1), decltype(&F3)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&F3), decltype(&F1)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&F3), decltype(&F1)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&F3), decltype(&F1)>::value, "");
|
||||
|
||||
static_assert(CompatibleWith<decltype(&E1), decltype(&F1)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&E3), decltype(&F3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&E3), decltype(&F3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&E3), decltype(&F3)>::value, "");
|
||||
|
||||
static_assert(!CompatibleWith<decltype(&F1), decltype(&E1)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&F3), decltype(&E3)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&F3), decltype(&E3)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&F3), decltype(&E3)>::value, "");
|
||||
}
|
||||
|
||||
TEST(CompatibleWith, Method) {
|
||||
class C {
|
||||
public:
|
||||
void F1(S) {}
|
||||
void F3(int, S, float) {}
|
||||
void E1(E) {}
|
||||
void E3(int, E, float) {}
|
||||
};
|
||||
C().F1({}); // Avoid unused method warning
|
||||
C().F3(0, {}, 0); // Avoid unused method warning
|
||||
C().E1({}); // Avoid unused method warning
|
||||
C().E3(0, {}, 0); // Avoid unused method warning
|
||||
|
||||
static_assert(CompatibleWith<decltype(&C::F1), decltype(&F1)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&C::F3), decltype(&F3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&C::F3), decltype(&F3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&C::F3), decltype(&F3)>::value, "");
|
||||
|
||||
static_assert(!CompatibleWith<decltype(&C::F1), decltype(&F3)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&C::F3), decltype(&F1)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&C::F3), decltype(&F1)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&C::F3), decltype(&F1)>::value, "");
|
||||
|
||||
static_assert(CompatibleWith<decltype(&C::E1), decltype(&C::F1)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&C::E3), decltype(&C::F3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&C::E3), decltype(&C::F3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&C::E3), decltype(&C::F3)>::value, "");
|
||||
|
||||
static_assert(!CompatibleWith<decltype(&C::F1), decltype(&C::E1)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&C::F3), decltype(&C::E3)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&C::F3), decltype(&C::E3)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&C::F3), decltype(&C::E3)>::value, "");
|
||||
}
|
||||
|
||||
TEST(CompatibleWith, ConstMethod) {
|
||||
class C {
|
||||
public:
|
||||
void F1(S) const {}
|
||||
void F3(int, S, float) const {}
|
||||
void E1(E) const {}
|
||||
void E3(int, E, float) const {}
|
||||
};
|
||||
C().F1({}); // Avoid unused method warning
|
||||
C().F3(0, {}, 0); // Avoid unused method warning
|
||||
C().E1({}); // Avoid unused method warning
|
||||
C().E3(0, {}, 0); // Avoid unused method warning
|
||||
|
||||
static_assert(CompatibleWith<decltype(&C::F1), decltype(&F1)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&C::F3), decltype(&F3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&C::F3), decltype(&F3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&C::F3), decltype(&F3)>::value, "");
|
||||
|
||||
static_assert(!CompatibleWith<decltype(&C::F1), decltype(&F3)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&C::F3), decltype(&F1)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&C::F3), decltype(&F1)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&C::F3), decltype(&F1)>::value, "");
|
||||
|
||||
static_assert(CompatibleWith<decltype(&C::E1), decltype(&C::F1)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&C::E3), decltype(&C::F3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&C::E3), decltype(&C::F3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&C::E3), decltype(&C::F3)>::value, "");
|
||||
|
||||
static_assert(!CompatibleWith<decltype(&C::F1), decltype(&C::E1)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&C::F3), decltype(&C::E3)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&C::F3), decltype(&C::E3)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&C::F3), decltype(&C::E3)>::value, "");
|
||||
}
|
||||
|
||||
TEST(CompatibleWith, StaticMethod) {
|
||||
class C {
|
||||
public:
|
||||
static void F1(S) {}
|
||||
static void F3(int, S, float) {}
|
||||
static void E1(E) {}
|
||||
static void E3(int, E, float) {}
|
||||
};
|
||||
C::F1({}); // Avoid unused method warning
|
||||
C::F3(0, {}, 0); // Avoid unused method warning
|
||||
C::E1({}); // Avoid unused method warning
|
||||
C::E3(0, {}, 0); // Avoid unused method warning
|
||||
|
||||
static_assert(CompatibleWith<decltype(&C::F1), decltype(&F1)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&C::F3), decltype(&F3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&C::F3), decltype(&F3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&C::F3), decltype(&F3)>::value, "");
|
||||
|
||||
static_assert(!CompatibleWith<decltype(&C::F1), decltype(&F3)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&C::F3), decltype(&F1)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&C::F3), decltype(&F1)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&C::F3), decltype(&F1)>::value, "");
|
||||
|
||||
static_assert(CompatibleWith<decltype(&C::E1), decltype(&C::F1)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&C::E3), decltype(&C::F3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&C::E3), decltype(&C::F3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(&C::E3), decltype(&C::F3)>::value, "");
|
||||
|
||||
static_assert(!CompatibleWith<decltype(&C::F1), decltype(&C::E1)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&C::F3), decltype(&C::E3)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&C::F3), decltype(&C::E3)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(&C::F3), decltype(&C::E3)>::value, "");
|
||||
}
|
||||
|
||||
TEST(CompatibleWith, FunctionLike) {
|
||||
using f1 = std::function<void(S)>;
|
||||
using f3 = std::function<void(int, S, float)>;
|
||||
using e1 = std::function<void(E)>;
|
||||
using e3 = std::function<void(int, E, float)>;
|
||||
static_assert(CompatibleWith<f1, decltype(&F1)>::value, "");
|
||||
static_assert(CompatibleWith<f3, decltype(&F3)>::value, "");
|
||||
static_assert(CompatibleWith<f3, decltype(&F3)>::value, "");
|
||||
static_assert(CompatibleWith<f3, decltype(&F3)>::value, "");
|
||||
|
||||
static_assert(!CompatibleWith<f1, decltype(&F3)>::value, "");
|
||||
static_assert(!CompatibleWith<f3, decltype(&F1)>::value, "");
|
||||
static_assert(!CompatibleWith<f3, decltype(&F1)>::value, "");
|
||||
static_assert(!CompatibleWith<f3, decltype(&F1)>::value, "");
|
||||
|
||||
static_assert(CompatibleWith<e1, f1>::value, "");
|
||||
static_assert(CompatibleWith<e3, f3>::value, "");
|
||||
static_assert(CompatibleWith<e3, f3>::value, "");
|
||||
static_assert(CompatibleWith<e3, f3>::value, "");
|
||||
|
||||
static_assert(!CompatibleWith<f1, e1>::value, "");
|
||||
static_assert(!CompatibleWith<f3, e3>::value, "");
|
||||
static_assert(!CompatibleWith<f3, e3>::value, "");
|
||||
static_assert(!CompatibleWith<f3, e3>::value, "");
|
||||
}
|
||||
|
||||
TEST(CompatibleWith, Lambda) {
|
||||
auto f1 = [](S) {};
|
||||
auto f3 = [](int, S, float) {};
|
||||
auto e1 = [](E) {};
|
||||
auto e3 = [](int, E, float) {};
|
||||
static_assert(CompatibleWith<decltype(f1), decltype(&F1)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(f3), decltype(&F3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(f3), decltype(&F3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(f3), decltype(&F3)>::value, "");
|
||||
|
||||
static_assert(!CompatibleWith<decltype(f1), decltype(&F3)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(f3), decltype(&F1)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(f3), decltype(&F1)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(f3), decltype(&F1)>::value, "");
|
||||
|
||||
static_assert(CompatibleWith<decltype(e1), decltype(f1)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(e3), decltype(f3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(e3), decltype(f3)>::value, "");
|
||||
static_assert(CompatibleWith<decltype(e3), decltype(f3)>::value, "");
|
||||
|
||||
static_assert(!CompatibleWith<decltype(f1), decltype(e1)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(f3), decltype(e3)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(f3), decltype(e3)>::value, "");
|
||||
static_assert(!CompatibleWith<decltype(f3), decltype(e3)>::value, "");
|
||||
}
|
||||
|
||||
} // namespace traits
|
||||
} // namespace dap
|
||||
21
libraries/cppdap/src/typeinfo.cpp
Normal file
21
libraries/cppdap/src/typeinfo.cpp
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
// Copyright 2020 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "dap/typeinfo.h"
|
||||
|
||||
namespace dap {
|
||||
|
||||
TypeInfo::~TypeInfo() = default;
|
||||
|
||||
} // namespace dap
|
||||
65
libraries/cppdap/src/typeinfo_test.cpp
Normal file
65
libraries/cppdap/src/typeinfo_test.cpp
Normal file
|
|
@ -0,0 +1,65 @@
|
|||
// Copyright 2020 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "dap/typeof.h"
|
||||
#include "dap/types.h"
|
||||
#include "json_serializer.h"
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
namespace dap {
|
||||
|
||||
struct BaseStruct {
|
||||
dap::integer i;
|
||||
dap::number n;
|
||||
};
|
||||
|
||||
DAP_STRUCT_TYPEINFO(BaseStruct,
|
||||
"BaseStruct",
|
||||
DAP_FIELD(i, "i"),
|
||||
DAP_FIELD(n, "n"));
|
||||
|
||||
struct DerivedStruct : public BaseStruct {
|
||||
dap::string s;
|
||||
dap::boolean b;
|
||||
};
|
||||
|
||||
DAP_STRUCT_TYPEINFO_EXT(DerivedStruct,
|
||||
BaseStruct,
|
||||
"DerivedStruct",
|
||||
DAP_FIELD(s, "s"),
|
||||
DAP_FIELD(b, "b"));
|
||||
|
||||
} // namespace dap
|
||||
|
||||
TEST(TypeInfo, Derived) {
|
||||
dap::DerivedStruct in;
|
||||
in.s = "hello world";
|
||||
in.b = true;
|
||||
in.i = 42;
|
||||
in.n = 3.14;
|
||||
|
||||
dap::json::Serializer s;
|
||||
ASSERT_TRUE(s.serialize(in));
|
||||
|
||||
dap::DerivedStruct out;
|
||||
dap::json::Deserializer d(s.dump());
|
||||
ASSERT_TRUE(d.deserialize(&out)) << "Failed to deserialize\n" << s.dump();
|
||||
|
||||
ASSERT_EQ(out.s, "hello world");
|
||||
ASSERT_EQ(out.b, true);
|
||||
ASSERT_EQ(out.i, 42);
|
||||
ASSERT_EQ(out.n, 3.14);
|
||||
}
|
||||
144
libraries/cppdap/src/typeof.cpp
Normal file
144
libraries/cppdap/src/typeof.cpp
Normal file
|
|
@ -0,0 +1,144 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "dap/typeof.h"
|
||||
|
||||
#include <atomic>
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
|
||||
namespace {
|
||||
|
||||
// TypeInfos owns all the dap::TypeInfo instances.
|
||||
struct TypeInfos {
|
||||
// get() returns the TypeInfos singleton pointer.
|
||||
// TypeInfos is constructed with an internal reference count of 1.
|
||||
static TypeInfos* get();
|
||||
|
||||
// reference() increments the TypeInfos reference count.
|
||||
inline void reference() {
|
||||
assert(refcount.load() > 0);
|
||||
refcount++;
|
||||
}
|
||||
|
||||
// release() decrements the TypeInfos reference count.
|
||||
// If the reference count becomes 0, then the TypeInfos is destructed.
|
||||
inline void release() {
|
||||
if (--refcount == 0) {
|
||||
this->~TypeInfos();
|
||||
}
|
||||
}
|
||||
|
||||
struct NullTI : public dap::TypeInfo {
|
||||
using null = dap::null;
|
||||
inline std::string name() const override { return "null"; }
|
||||
inline size_t size() const override { return sizeof(null); }
|
||||
inline size_t alignment() const override { return alignof(null); }
|
||||
inline void construct(void* ptr) const override { new (ptr) null(); }
|
||||
inline void copyConstruct(void* dst, const void* src) const override {
|
||||
new (dst) null(*reinterpret_cast<const null*>(src));
|
||||
}
|
||||
inline void destruct(void* ptr) const override {
|
||||
reinterpret_cast<null*>(ptr)->~null();
|
||||
}
|
||||
inline bool deserialize(const dap::Deserializer*, void*) const override {
|
||||
return true;
|
||||
}
|
||||
inline bool serialize(dap::Serializer*, const void*) const override {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
|
||||
dap::BasicTypeInfo<dap::boolean> boolean = {"boolean"};
|
||||
dap::BasicTypeInfo<dap::string> string = {"string"};
|
||||
dap::BasicTypeInfo<dap::integer> integer = {"integer"};
|
||||
dap::BasicTypeInfo<dap::number> number = {"number"};
|
||||
dap::BasicTypeInfo<dap::object> object = {"object"};
|
||||
dap::BasicTypeInfo<dap::any> any = {"any"};
|
||||
NullTI null;
|
||||
std::vector<std::unique_ptr<dap::TypeInfo>> types;
|
||||
|
||||
private:
|
||||
TypeInfos() = default;
|
||||
~TypeInfos() = default;
|
||||
std::atomic<uint64_t> refcount = {1};
|
||||
};
|
||||
|
||||
// aligned_storage() is a replacement for std::aligned_storage that isn't busted
|
||||
// on older versions of MSVC.
|
||||
template <size_t SIZE, size_t ALIGNMENT>
|
||||
struct aligned_storage {
|
||||
struct alignas(ALIGNMENT) type {
|
||||
unsigned char data[SIZE];
|
||||
};
|
||||
};
|
||||
|
||||
TypeInfos* TypeInfos::get() {
|
||||
static aligned_storage<sizeof(TypeInfos), alignof(TypeInfos)>::type memory;
|
||||
|
||||
struct Instance {
|
||||
TypeInfos* ptr() { return reinterpret_cast<TypeInfos*>(memory.data); }
|
||||
Instance() { new (ptr()) TypeInfos(); }
|
||||
~Instance() { ptr()->release(); }
|
||||
};
|
||||
|
||||
static Instance instance;
|
||||
return instance.ptr();
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
namespace dap {
|
||||
|
||||
const TypeInfo* TypeOf<boolean>::type() {
|
||||
return &TypeInfos::get()->boolean;
|
||||
}
|
||||
|
||||
const TypeInfo* TypeOf<string>::type() {
|
||||
return &TypeInfos::get()->string;
|
||||
}
|
||||
|
||||
const TypeInfo* TypeOf<integer>::type() {
|
||||
return &TypeInfos::get()->integer;
|
||||
}
|
||||
|
||||
const TypeInfo* TypeOf<number>::type() {
|
||||
return &TypeInfos::get()->number;
|
||||
}
|
||||
|
||||
const TypeInfo* TypeOf<object>::type() {
|
||||
return &TypeInfos::get()->object;
|
||||
}
|
||||
|
||||
const TypeInfo* TypeOf<any>::type() {
|
||||
return &TypeInfos::get()->any;
|
||||
}
|
||||
|
||||
const TypeInfo* TypeOf<null>::type() {
|
||||
return &TypeInfos::get()->null;
|
||||
}
|
||||
|
||||
void TypeInfo::deleteOnExit(TypeInfo* ti) {
|
||||
TypeInfos::get()->types.emplace_back(std::unique_ptr<TypeInfo>(ti));
|
||||
}
|
||||
|
||||
void initialize() {
|
||||
TypeInfos::get()->reference();
|
||||
}
|
||||
|
||||
void terminate() {
|
||||
TypeInfos::get()->release();
|
||||
}
|
||||
|
||||
} // namespace dap
|
||||
94
libraries/cppdap/src/variant_test.cpp
Normal file
94
libraries/cppdap/src/variant_test.cpp
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
// Copyright 2019 Google LLC
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// https://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
#include "dap/variant.h"
|
||||
#include "dap/typeof.h"
|
||||
#include "dap/types.h"
|
||||
|
||||
#include "gmock/gmock.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
namespace dap {
|
||||
|
||||
struct VariantTestObject {
|
||||
dap::integer i;
|
||||
dap::number n;
|
||||
};
|
||||
|
||||
DAP_STRUCT_TYPEINFO(VariantTestObject,
|
||||
"VariantTestObject",
|
||||
DAP_FIELD(i, "i"),
|
||||
DAP_FIELD(n, "n"));
|
||||
|
||||
} // namespace dap
|
||||
|
||||
TEST(Variant, EmptyConstruct) {
|
||||
dap::variant<dap::integer, dap::boolean, dap::VariantTestObject> variant;
|
||||
ASSERT_TRUE(variant.is<dap::integer>());
|
||||
ASSERT_FALSE(variant.is<dap::boolean>());
|
||||
ASSERT_FALSE(variant.is<dap::VariantTestObject>());
|
||||
}
|
||||
|
||||
TEST(Variant, Boolean) {
|
||||
dap::variant<dap::integer, dap::boolean, dap::VariantTestObject> variant(
|
||||
dap::boolean(true));
|
||||
ASSERT_TRUE(variant.is<dap::boolean>());
|
||||
ASSERT_EQ(variant.get<dap::boolean>(), dap::boolean(true));
|
||||
}
|
||||
|
||||
TEST(Variant, Integer) {
|
||||
dap::variant<dap::integer, dap::boolean, dap::VariantTestObject> variant(
|
||||
dap::integer(10));
|
||||
ASSERT_TRUE(variant.is<dap::integer>());
|
||||
ASSERT_EQ(variant.get<dap::integer>(), dap::integer(10));
|
||||
}
|
||||
|
||||
TEST(Variant, TestObject) {
|
||||
dap::variant<dap::integer, dap::boolean, dap::VariantTestObject> variant(
|
||||
dap::VariantTestObject{5, 3.0});
|
||||
ASSERT_TRUE(variant.is<dap::VariantTestObject>());
|
||||
ASSERT_EQ(variant.get<dap::VariantTestObject>().i, 5);
|
||||
ASSERT_EQ(variant.get<dap::VariantTestObject>().n, 3.0);
|
||||
}
|
||||
|
||||
TEST(Variant, Assign) {
|
||||
dap::variant<dap::integer, dap::boolean, dap::VariantTestObject> variant(
|
||||
dap::integer(10));
|
||||
variant = dap::integer(10);
|
||||
ASSERT_TRUE(variant.is<dap::integer>());
|
||||
ASSERT_FALSE(variant.is<dap::boolean>());
|
||||
ASSERT_FALSE(variant.is<dap::VariantTestObject>());
|
||||
ASSERT_EQ(variant.get<dap::integer>(), dap::integer(10));
|
||||
variant = dap::boolean(true);
|
||||
ASSERT_FALSE(variant.is<dap::integer>());
|
||||
ASSERT_TRUE(variant.is<dap::boolean>());
|
||||
ASSERT_FALSE(variant.is<dap::VariantTestObject>());
|
||||
ASSERT_EQ(variant.get<dap::boolean>(), dap::boolean(true));
|
||||
variant = dap::VariantTestObject{5, 3.0};
|
||||
ASSERT_FALSE(variant.is<dap::integer>());
|
||||
ASSERT_FALSE(variant.is<dap::boolean>());
|
||||
ASSERT_TRUE(variant.is<dap::VariantTestObject>());
|
||||
ASSERT_EQ(variant.get<dap::VariantTestObject>().i, 5);
|
||||
ASSERT_EQ(variant.get<dap::VariantTestObject>().n, 3.0);
|
||||
}
|
||||
|
||||
TEST(Variant, Accepts) {
|
||||
using variant =
|
||||
dap::variant<dap::integer, dap::boolean, dap::VariantTestObject>;
|
||||
ASSERT_TRUE(variant::accepts<dap::integer>());
|
||||
ASSERT_TRUE(variant::accepts<dap::boolean>());
|
||||
ASSERT_TRUE(variant::accepts<dap::VariantTestObject>());
|
||||
ASSERT_FALSE(variant::accepts<dap::number>());
|
||||
ASSERT_FALSE(variant::accepts<dap::string>());
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue