Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

use shared_ptr + variant for Value instead of std::any #13

Merged
merged 5 commits into from
Jan 3, 2024
Merged

use shared_ptr + variant for Value instead of std::any #13

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
f996b20
use shared_ptr + variant for Value instead of std::any
petiaccja Jan 3, 2024
744c486
fix
petiaccja Jan 3, 2024
6de4b61
fix
petiaccja Jan 3, 2024
58c02a5
fix
petiaccja Jan 3, 2024
c2d1be6
fix
petiaccja Jan 3, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
21 changes: 8 additions & 13 deletions src/lib/Archive/Types/ValueToToken.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -96,20 +96,15 @@ namespace impl {
out.push_back(std::move(token));
}
else if (value.IsInteger()) {
const auto result = ForEachType<Value::IntTypes>([&]<class T>(T*) -> std::optional<bool> {
if (value.Type() == typeid(T)) {
Token token = {
.tag = eTag::SHORT_ATOM,
.isByte = false,
.isSigned = std::is_signed_v<T>,
.data = ToBytes(value.Get<T>()),
};
out.push_back(std::move(token));
return true;
}
return std::nullopt;
auto token = value.VisitInt([]<class T>(const T& value) {
return Token{
.tag = eTag::SHORT_ATOM,
.isByte = false,
.isSigned = std::is_signed_v<T>,
.data = ToBytes(value),
};
});
assert(result.has_value());
out.push_back(std::move(token));
}
else if (value.IsList()) {
out.push_back(Token{ .tag = eTag::START_LIST });
Expand Down
153 changes: 51 additions & 102 deletions src/lib/Data/Value.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3,53 +3,28 @@

namespace sedmgr {


//------------------------------------------------------------------------------
// Construction
//------------------------------------------------------------------------------

Value::Value(std::initializer_list<Value> values)
: m_value(ListType(values)) {}
: m_storage(std::make_shared<StorageType>(List(values))) {}


Value::Value(Named value)
: m_value(std::move(value)) {}
: m_storage(std::make_shared<StorageType>(std::move(value))) {}


Value::Value(eCommand command)
: m_value(command) {}
: m_storage(std::make_shared<StorageType>(command)) {}


bool Value::operator==(const Value& rhs) const {
if (IsInteger() && rhs.IsInteger()) {
if (Type() != rhs.Type()) {
return false;
}
const auto cmpResult = impl::ForEachType<IntTypes>([&]<class T>(T*) -> std::optional<bool> {
if (Type() == typeid(T)) {
const auto lhsv = Get<T>();
const auto rhsv = rhs.Get<T>();
return lhsv == rhsv;
}
return std::nullopt;
});
return cmpResult.value_or(false);
}
else if (IsBytes() && rhs.IsBytes()) {
return std::ranges::equal(GetBytes(), rhs.GetBytes());
}
else if (IsCommand() && rhs.IsCommand()) {
return GetCommand() == rhs.GetCommand();
}
else if (IsList() && rhs.IsList()) {
return std::ranges::equal(GetList(), rhs.GetList());
}
else if (IsNamed() && rhs.IsNamed()) {
return GetNamed().name == rhs.GetNamed().name && GetNamed().value == rhs.GetNamed().value;
}
else if (!HasValue() && !rhs.HasValue()) {
return true;
if (HasValue() && rhs.HasValue()) {
return *m_storage == *rhs.m_storage;
}
return false;
return !HasValue() && !rhs.HasValue();
}


Expand All @@ -58,127 +33,101 @@ bool Value::operator==(const Value& rhs) const {
//------------------------------------------------------------------------------

std::span<const Value> Value::GetList() const {
try {
return std::any_cast<const ListType&>(m_value);
}
catch (std::bad_any_cast&) {
throw TypeConversionError(GetTypeStr(), "list");
if (IsList()) {
return std::get<List>(*m_storage);
}
throw TypeConversionError(GetTypeStr(), GetTypeStr<List>());
}

std::vector<Value>& Value::GetList() {
try {
return std::any_cast<std::vector<Value>&>(m_value);
}
catch (std::bad_any_cast&) {
throw TypeConversionError(GetTypeStr(), "list");
if (IsList()) {
return std::get<List>(*m_storage);
}
throw TypeConversionError(GetTypeStr(), GetTypeStr<List>());
}

std::vector<std::byte>& Value::GetBytes() {
try {
return std::any_cast<BytesType&>(m_value);
}
catch (std::bad_any_cast&) {
throw TypeConversionError(GetTypeStr(), "bytes");
if (IsBytes()) {
return std::get<Bytes>(*m_storage);
}
throw TypeConversionError(GetTypeStr(), GetTypeStr<Bytes>());
}

std::span<const std::byte> Value::GetBytes() const {
try {
return { std::any_cast<const BytesType&>(m_value) };
}
catch (std::bad_any_cast&) {
throw TypeConversionError(GetTypeStr(), "bytes");
if (IsBytes()) {
return std::get<Bytes>(*m_storage);
}
throw TypeConversionError(GetTypeStr(), GetTypeStr<Bytes>());
}

const Named& Value::GetNamed() const {
try {
return std::any_cast<const Named&>(m_value);
}
catch (std::bad_any_cast&) {
throw TypeConversionError(GetTypeStr(), "named");
if (IsNamed()) {
return std::get<Named>(*m_storage);
}
throw TypeConversionError(GetTypeStr(), GetTypeStr<Named>());
}

Named& Value::GetNamed() {
try {
return std::any_cast<Named&>(m_value);
}
catch (std::bad_any_cast&) {
throw TypeConversionError(GetTypeStr(), "named");
if (IsNamed()) {
return std::get<Named>(*m_storage);
}
throw TypeConversionError(GetTypeStr(), GetTypeStr<Named>());
}

eCommand Value::GetCommand() const {
try {
return std::any_cast<eCommand>(m_value);
}
catch (std::bad_any_cast&) {
throw TypeConversionError(GetTypeStr(), "command");
if (IsCommand()) {
return std::get<eCommand>(*m_storage);
}
throw TypeConversionError(GetTypeStr(), GetTypeStr<eCommand>());
}


//------------------------------------------------------------------------------
// Querystd::optional(Get<T>() == )
// Query
//------------------------------------------------------------------------------

bool Value::IsInteger() const {
const auto v = impl::ForEachType<IntTypes>([this](auto* ptr) -> std::optional<bool> {
if (m_value.type() == typeid(decltype(*ptr))) {
return true;
}
return std::nullopt;
});
return v.has_value();
if (!m_storage) {
return false;
}
const auto visitor = []<class S>(const S&) { return std::is_integral_v<S>; };
return std::visit(visitor, *m_storage);
}

bool Value::IsBytes() const {
return typeid(BytesType) == m_value.type();
return m_storage && std::holds_alternative<Bytes>(*m_storage);
}

bool Value::IsList() const {
return typeid(ListType) == m_value.type();
return m_storage && std::holds_alternative<List>(*m_storage);
}

bool Value::IsNamed() const {
return typeid(Named) == m_value.type();
return m_storage && std::holds_alternative<Named>(*m_storage);
}

bool Value::IsCommand() const {
return typeid(eCommand) == m_value.type();
return m_storage && std::holds_alternative<eCommand>(*m_storage);
}

bool Value::HasValue() const {
return m_storage != nullptr;
}

const std::type_info& Value::Type() const {
return m_value.type();
if (!HasValue()) {
return typeid(void);
}
const auto visitor = []<class S>(const S&) -> const std::type_info& { return typeid(S); };
return std::visit(visitor, *m_storage);
}

std::string Value::GetTypeStr() const {
if (IsInteger()) {
const auto v = impl::ForEachType<IntTypes>([this](auto* ptr) -> std::optional<std::pair<size_t, bool>> {
using Q = std::decay_t<decltype(*ptr)>;
if (m_value.type() == typeid(Q)) {
return std::pair{ sizeof(Q), std::is_signed_v<Q> };
}
return std::nullopt;
});
return std::format("{}int{}", v->second ? "" : "u", v->first * 8);
}
else if (IsCommand()) {
return "command";
}
else if (IsList()) {
return "list";
}
else if (IsNamed()) {
return "named";
}
else if (IsBytes()) {
return "bytes";
if (!HasValue()) {
return "<empty>";
}
return "<empty>";
const auto visitor = []<class S>(const S&) { return GetTypeStr<S>(); };
return std::visit(visitor, *m_storage);
}

} // namespace sedmgr
Loading
Loading