| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef LIB_FIDL_CPP_STRING_H_ |
| #define LIB_FIDL_CPP_STRING_H_ |
| |
| #include <lib/fidl/cpp/builder.h> |
| #include <lib/fidl/cpp/string_view.h> |
| |
| #include <iosfwd> |
| #include <string> |
| #include <utility> |
| |
| #include <zircon/assert.h> |
| |
| #include "lib/fidl/cpp/coding_traits.h" |
| #include "lib/fidl/cpp/traits.h" |
| |
| namespace fidl { |
| |
| // A representation of a FIDL string that owns the memory for the string. |
| // |
| // A StringPtr has three states: (1) null, (2) empty, (3) contains a string. In |
| // the second state, operations that return an std::string return the empty |
| // std::string. The null and empty states can be distinguished using the |
| // |is_null| and |operator bool| methods. |
| class StringPtr final { |
| public: |
| StringPtr() = default; |
| StringPtr(const StringPtr& other) = default; |
| StringPtr(StringPtr&& other) noexcept = default; |
| ~StringPtr() = default; |
| |
| StringPtr& operator=(const StringPtr&) = default; |
| StringPtr& operator=(StringPtr&& other) = default; |
| |
| StringPtr(std::string str) : str_(std::move(str)), is_null_if_empty_(false) {} |
| StringPtr(const char* str) |
| : str_(str ? std::string(str) : std::string()), is_null_if_empty_(!str) {} |
| StringPtr(const char* str, size_t length) |
| : str_(str ? std::string(str, length) : std::string()), |
| is_null_if_empty_(!str) {} |
| |
| |
| // Accesses the underlying std::string object. |
| const std::string& get() const { return str_; } |
| |
| // Stores the given std::string in this StringPtr. |
| // |
| // After this method returns, the StringPtr is non-null. |
| void reset(std::string str) { |
| str_ = std::move(str); |
| is_null_if_empty_ = false; |
| } |
| |
| // Causes this StringPtr to become null. |
| void reset() { |
| str_.clear(); |
| is_null_if_empty_ = true; |
| } |
| |
| void swap(StringPtr& other) { |
| using std::swap; |
| swap(str_, other.str_); |
| swap(is_null_if_empty_, other.is_null_if_empty_); |
| } |
| |
| // Whether this StringPtr is null. |
| // |
| // The null state is separate from the empty state. |
| bool is_null() const { return is_null_if_empty_ && str_.empty(); } |
| |
| // Tests as true if non-null, false if null. |
| explicit operator bool() const { return !is_null(); } |
| |
| // Provides access to the underlying std::string. |
| std::string* operator->() { return &str_; } |
| const std::string* operator->() const { return &str_; } |
| |
| // Provides access to the underlying std::string. |
| const std::string& operator*() const { return str_; } |
| |
| operator const std::string&() const { return str_; } |
| |
| void Encode(Encoder* encoder, size_t offset); |
| static void Decode(Decoder* decoder, StringPtr* value, size_t offset); |
| |
| template <class EncoderImpl> |
| static void EncodeString(EncoderImpl* encoder, const std::string& value, |
| size_t offset) { |
| fidl_string_t* string = encoder->template GetPtr<fidl_string_t>(offset); |
| string->size = value.size(); |
| string->data = reinterpret_cast<char*>(FIDL_ALLOC_PRESENT); |
| size_t base = encoder->Alloc(value.size()); |
| char* payload = encoder->template GetPtr<char>(base); |
| memcpy(payload, value.data(), value.size()); |
| } |
| |
| template <class DecoderImpl> |
| static void DecodeString(DecoderImpl* decoder, std::string* value, |
| size_t offset) { |
| fidl_string_t* string = decoder->template GetPtr<fidl_string_t>(offset); |
| ZX_ASSERT(string->data != nullptr); |
| *value = std::string(string->data, string->size); |
| } |
| |
| private: |
| std::string str_; |
| bool is_null_if_empty_ = true; |
| }; |
| |
| template<> |
| struct Equality<StringPtr> { |
| static inline bool Equals(const StringPtr& a, const StringPtr& b) { |
| if (a.is_null()) { |
| return b.is_null(); |
| } |
| return !b.is_null() && a.get() == b.get(); |
| } |
| }; |
| |
| inline bool operator==(const StringPtr& a, const StringPtr& b) { |
| if (a.is_null()) { |
| return b.is_null(); |
| } |
| return !b.is_null() && a.get() == b.get(); |
| } |
| |
| inline bool operator==(const char* a, const StringPtr& b) { |
| if (a == nullptr) { |
| return b.is_null(); |
| } |
| return !b.is_null() && a == b.get(); |
| } |
| |
| inline bool operator==(const StringPtr& a, const char* b) { |
| if (a.is_null()) { |
| return b == nullptr; |
| } |
| return b != nullptr && a.get() == b; |
| } |
| |
| inline bool operator!=(const StringPtr& a, const StringPtr& b) { |
| return !(a == b); |
| } |
| |
| inline bool operator!=(const char* a, const StringPtr& b) { return !(a == b); } |
| |
| inline bool operator!=(const StringPtr& a, const char* b) { return !(a == b); } |
| |
| inline bool operator<(const StringPtr& a, const StringPtr& b) { |
| if (a.is_null() || b.is_null()) { |
| return !b.is_null(); |
| } |
| return *a < *b; |
| } |
| |
| inline bool operator<(const char* a, const StringPtr& b) { |
| if (a == nullptr || b.is_null()) { |
| return !b.is_null(); |
| } |
| return a < *b; |
| } |
| |
| inline bool operator<(const StringPtr& a, const char* b) { |
| if (a.is_null() || b == nullptr) { |
| return b != nullptr; |
| } |
| return *a < b; |
| } |
| |
| inline bool operator>(const StringPtr& a, const StringPtr& b) { |
| if (a.is_null() || b.is_null()) { |
| return !a.is_null(); |
| } |
| return *a > *b; |
| } |
| |
| inline bool operator>(const char* a, const StringPtr& b) { |
| if (a == nullptr || b.is_null()) { |
| return a != nullptr; |
| } |
| return a > *b; |
| } |
| |
| inline bool operator>(const StringPtr& a, const char* b) { |
| if (a.is_null() || b == nullptr) { |
| return a != nullptr; |
| } |
| return *a > b; |
| } |
| |
| inline bool operator<=(const StringPtr& a, const StringPtr& b) { |
| return !(a > b); |
| } |
| |
| inline bool operator<=(const char* a, const StringPtr& b) { return !(a > b); } |
| |
| inline bool operator<=(const StringPtr& a, const char* b) { return !(a > b); } |
| |
| inline bool operator>=(const StringPtr& a, const StringPtr& b) { |
| return !(a < b); |
| } |
| |
| inline bool operator>=(const char* a, const StringPtr& b) { return !(a < b); } |
| |
| inline bool operator>=(const StringPtr& a, const char* b) { return !(a < b); } |
| |
| inline std::ostream& operator<<(std::ostream& out, const StringPtr& str) { |
| return out << str.get(); |
| } |
| |
| template <> |
| struct CodingTraits<StringPtr> |
| : public EncodableCodingTraits<StringPtr, sizeof(fidl_string_t)> {}; |
| |
| template <> |
| struct CodingTraits<::std::string> { |
| static constexpr size_t encoded_size = sizeof(fidl_string_t); |
| template <class EncoderImpl> |
| static void Encode(EncoderImpl* encoder, std::string* value, size_t offset) { |
| ::fidl::StringPtr::EncodeString(encoder, *value, offset); |
| } |
| template <class DecoderImpl> |
| static void Decode(DecoderImpl* decoder, std::string* value, size_t offset) { |
| ::fidl::StringPtr::DecodeString(decoder, value, offset); |
| } |
| }; |
| |
| } // namespace fidl |
| |
| #endif // LIB_FIDL_CPP_STRING_H_ |