Skip to content

better from<Rust>(foo) implementation #67

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

Open
wants to merge 1 commit into
base: master
Choose a base branch
from
Open

better from<Rust>(foo) implementation #67

Changes from all commits
Commits
Show all changes
1 commit
Select commit
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
74 changes: 36 additions & 38 deletions kj-rs/convert.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -183,10 +183,10 @@ namespace kj_rs {

// KJ to Rust conversion utilities with different ownership semantics

/// Template function for nicer syntax: from<Rust>(rustObject) instead of fromRust(rustObject)
/// Template function for nicer syntax: from<Rust>(rustObject) is expanded to from(Rust, rustObject)
template <typename T, typename U>
inline auto from(U&& rustObject) {
return T::into(std::forward<U>(rustObject));
return from(T{}, std::forward<U>(rustObject));
}

/// Zero-copy read-only Rust views: kjObject.as<Rust>() and from<Rust>(kjObject)
Expand Down Expand Up @@ -217,31 +217,29 @@ struct Rust {
static ::rust::Slice<const char> from(const kj::ConstString* str) {
return ::rust::Slice(str->begin(), str->size());
}
};

// into() methods for from<Rust>(rustObject) - converting Rust to KJ

/// from<Rust>(rustVec) - Zero-copy read-only view
template <typename T>
static kj::ArrayPtr<const T> into(const ::rust::Vec<T>& vec) {
return kj::ArrayPtr<const T>(vec.data(), vec.size());
}
/// from<Rust>(rustVec) - Zero-copy read-only view
template <typename T>
inline kj::ArrayPtr<const T> from(Rust, const ::rust::Vec<T>& vec) {
return kj::ArrayPtr<const T>(vec.data(), vec.size());
}

/// from<Rust>(rustSlice) - Zero-copy slice view
template <typename T>
static kj::ArrayPtr<T> into(const ::rust::Slice<T>& slice) {
return kj::ArrayPtr<T>(slice.data(), slice.size());
}
/// from<Rust>(rustSlice) - Zero-copy slice view
template <typename T>
inline kj::ArrayPtr<T> from(Rust, const ::rust::Slice<T>& slice) {
return kj::ArrayPtr<T>(slice.data(), slice.size());
}

/// from<Rust>(rustString) - Zero-copy string chars (not null-terminated)
static kj::ArrayPtr<const char> into(const ::rust::String& str) {
return kj::ArrayPtr<const char>(str.data(), str.size());
}
/// from<Rust>(rustString) - Zero-copy string chars (not null-terminated)
inline kj::ArrayPtr<const char> from(Rust, const ::rust::String& str) {
return kj::ArrayPtr<const char>(str.data(), str.size());
}

/// from<Rust>(rustStr) - Zero-copy string slice chars (not null-terminated)
static kj::ArrayPtr<const char> into(const ::rust::Str& str) {
return kj::ArrayPtr<const char>(str.data(), str.size());
}
};
/// from<Rust>(rustStr) - Zero-copy string slice chars (not null-terminated)
inline kj::ArrayPtr<const char> from(Rust, const ::rust::Str& str) {
return kj::ArrayPtr<const char>(str.data(), str.size());
}

/// Owned Rust copies: kjObject.as<RustCopy>() and from<RustCopy>(kjObject)
struct RustCopy {
Expand All @@ -267,25 +265,25 @@ struct RustCopy {
auto ptr = str->asArray();
return from(&ptr);
}
};

/// from<RustCopy>(rustSliceOfStrs) - Copy slice of strs to null-terminated KJ strings
static kj::Array<kj::String> into(::rust::Slice<::rust::str> slice) {
auto res = kj::heapArrayBuilder<kj::String>(slice.size());
for (auto& entry: slice) {
res.add(kj::str(entry));
}
return res.finish();
/// from<RustCopy>(rustSliceOfStrs) - Copy slice of strs to null-terminated KJ strings
inline kj::Array<kj::String> from(RustCopy, ::rust::Slice<::rust::str> slice) {
auto res = kj::heapArrayBuilder<kj::String>(slice.size());
for (auto& entry: slice) {
res.add(kj::str(entry));
}
return res.finish();
}

/// from<RustCopy>(rustVecOfStrings) - Copy string vector to null-terminated KJ strings
static kj::Array<kj::String> into(const ::rust::Vec<::rust::String>& vec) {
auto res = kj::heapArrayBuilder<kj::String>(vec.size());
for (auto& entry: vec) {
res.add(kj::str(entry));
}
return res.finish();
/// from<RustCopy>(rustVecOfStrings) - Copy string vector to null-terminated KJ strings
inline kj::Array<kj::String> from(RustCopy, const ::rust::Vec<::rust::String>& vec) {
auto res = kj::heapArrayBuilder<kj::String>(vec.size());
for (auto& entry: vec) {
res.add(kj::str(entry));
}
};
return res.finish();
}

/// Mutable Rust views: kjObject.as<RustMutable>() and from<RustMutable>(kjObject)
struct RustMutable {
Expand Down