X-Git-Url: https://git.mdrn.pl/wl-app.git/blobdiff_plain/53b27422d140022594fc241cca91c3183be57bca..48b2fe9f7c2dc3d9aeaaa6dbfb27c7da4f3235ff:/iOS/Pods/Realm/include/core/realm/column_mixed.hpp diff --git a/iOS/Pods/Realm/include/core/realm/column_mixed.hpp b/iOS/Pods/Realm/include/core/realm/column_mixed.hpp new file mode 100644 index 0000000..5f74c41 --- /dev/null +++ b/iOS/Pods/Realm/include/core/realm/column_mixed.hpp @@ -0,0 +1,265 @@ +/************************************************************************* + * + * Copyright 2016 Realm Inc. + * + * 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 + * + * http://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 REALM_COLUMN_MIXED_HPP +#define REALM_COLUMN_MIXED_HPP + +#include + +#include +#include +#include +#include +#include + + +namespace realm { + + +// Pre-declarations +class BinaryColumn; + + +/// A mixed column (MixedColumn) is composed of three subcolumns. The first +/// subcolumn is an integer column (Column) and stores value types. The second +/// one stores values and is a subtable parent column (SubtableColumnBase), +/// which is a subclass of an integer column (Column). The last one is a binary +/// column (BinaryColumn) and stores additional data for values of type string +/// or binary data. The last subcolumn is optional. The root of a mixed column +/// is an array node of type Array that stores the root refs of the subcolumns. +class MixedColumn : public ColumnBaseSimple { +public: + /// Create a mixed column wrapper and attach it to a preexisting + /// underlying structure of arrays. + /// + /// \param alloc The memory allocator to change the underlying + /// structure in memory. + /// + /// \param ref The memory reference of the MixedColumn for which + /// this accessor should be creator for. + /// + /// \param table If this column is used as part of a table you + /// must pass a pointer to that table. Otherwise you must pass + /// null + /// + /// \param column_ndx If this column is used as part of a table + /// you must pass the logical index of the column within that + /// table. Otherwise you should pass zero. + MixedColumn(Allocator& alloc, ref_type ref, Table* table, size_t column_ndx); + + ~MixedColumn() noexcept override; + + DataType get_type(size_t ndx) const noexcept; + size_t size() const noexcept final + { + return m_types->size(); + } + bool is_empty() const noexcept + { + return size() == 0; + } + + int64_t get_int(size_t ndx) const noexcept; + bool get_bool(size_t ndx) const noexcept; + OldDateTime get_olddatetime(size_t ndx) const noexcept; + Timestamp get_timestamp(size_t ndx) const noexcept; + float get_float(size_t ndx) const noexcept; + double get_double(size_t ndx) const noexcept; + StringData get_string(size_t ndx) const noexcept; + BinaryData get_binary(size_t ndx) const noexcept; + StringData get_index_data(size_t ndx, StringIndex::StringConversionBuffer& buffer) const noexcept override; + + /// The returned array ref is zero if the specified row does not + /// contain a subtable. + ref_type get_subtable_ref(size_t row_ndx) const noexcept; + + /// The returned size is zero if the specified row does not + /// contain a subtable. + size_t get_subtable_size(size_t row_ndx) const noexcept; + + TableRef get_subtable_accessor(size_t row_ndx) const noexcept override; + + void discard_subtable_accessor(size_t row_ndx) noexcept override; + + /// If the value at the specified index is a subtable, return a + /// TableRef to that accessor for that subtable. Otherwise return + /// null. The accessor will be created if it does not already + /// exist. + TableRef get_subtable_tableref(size_t row_ndx); + + ConstTableRef get_subtable_tableref(size_t subtable_ndx) const; + + void set_int(size_t ndx, int64_t value); + void set_bool(size_t ndx, bool value); + void set_olddatetime(size_t ndx, OldDateTime value); + void set_timestamp(size_t ndx, Timestamp value); + void set_float(size_t ndx, float value); + void set_double(size_t ndx, double value); + void set_string(size_t ndx, StringData value) override; + void set_binary(size_t ndx, BinaryData value); + void set_subtable(size_t ndx, const Table* value); + + void insert_int(size_t ndx, int_fast64_t value); + void insert_bool(size_t ndx, bool value); + void insert_olddatetime(size_t ndx, OldDateTime value); + void insert_timestamp(size_t ndx, Timestamp value); + void insert_float(size_t ndx, float value); + void insert_double(size_t ndx, double value); + void insert_string(size_t ndx, StringData value); + void insert_binary(size_t ndx, BinaryData value); + void insert_subtable(size_t ndx, const Table* value); + + void erase(size_t row_ndx); + void move_last_over(size_t row_ndx); + void clear(); + + /// Compare two mixed columns for equality. + bool compare_mixed(const MixedColumn&) const; + + int compare_values(size_t row1, size_t row2) const noexcept override; + + void discard_child_accessors() noexcept; + + static ref_type create(Allocator&, size_t size = 0); + + static size_t get_size_from_ref(ref_type root_ref, Allocator&) noexcept; + + // Overriding method in ColumnBase + ref_type write(size_t, size_t, size_t, _impl::OutputStream&) const override; + + void insert_rows(size_t, size_t, size_t, bool) override; + void erase_rows(size_t, size_t, size_t, bool) override; + void move_last_row_over(size_t, size_t, bool) override; + void swap_rows(size_t, size_t) override; + void clear(size_t, bool) override; + void update_from_parent(size_t) noexcept override; + void adj_acc_insert_rows(size_t, size_t) noexcept override; + void adj_acc_erase_row(size_t) noexcept override; + void adj_acc_move_over(size_t, size_t) noexcept override; + void adj_acc_swap_rows(size_t, size_t) noexcept override; + void adj_acc_move_row(size_t, size_t) noexcept override; + void adj_acc_clear_root_table() noexcept override; + void mark(int) noexcept override; + void refresh_accessor_tree(size_t, const Spec&) override; + + void verify() const override; + void verify(const Table&, size_t) const override; + void to_dot(std::ostream&, StringData title) const override; + void do_dump_node_structure(std::ostream&, int) const override; + +private: + enum MixedColType { + // NOTE: below numbers must be kept in sync with ColumnType + // Column types used in Mixed + mixcol_Int = 0, + mixcol_Bool = 1, + mixcol_String = 2, + // 3, used for STRING_ENUM in ColumnType + mixcol_Binary = 4, + mixcol_Table = 5, + mixcol_Mixed = 6, + mixcol_OldDateTime = 7, + mixcol_Timestamp = 8, + mixcol_Float = 9, + mixcol_Double = 10, // Positive Double + mixcol_DoubleNeg = 11, // Negative Double + mixcol_IntNeg = 12 // Negative Integers + }; + + class RefsColumn; + + /// Stores the MixedColType of each value at the given index. For + /// values that uses all 64 bits, the type also encodes the sign + /// bit by having distinct types for positive negative values. + std::unique_ptr m_types; + + /// Stores the data for each entry. For a subtable, the stored + /// value is the ref of the subtable. For string, binary data, + /// the stored value is an index within `m_binary_data`. Likewise, + /// for timestamp, an index into `m_timestamp` is stored. For other + /// types the stored value is itself. Since we only have 63 bits + /// available for a non-ref value, the sign of numeric values is + /// encoded as part of the type in `m_types`. + std::unique_ptr m_data; + + /// For string and binary data types, the bytes are stored here. + std::unique_ptr m_binary_data; + + /// Timestamps are stored here. + std::unique_ptr m_timestamp_data; + + void do_erase(size_t row_ndx, size_t num_rows_to_erase, size_t prior_num_rows); + void do_move_last_over(size_t row_ndx, size_t prior_num_rows); + void do_swap_rows(size_t, size_t); + void do_clear(size_t num_rows); + + void create(Allocator&, ref_type, Table*, size_t column_ndx); + void ensure_binary_data_column(); + void ensure_timestamp_column(); + + MixedColType clear_value(size_t ndx, MixedColType new_type); // Returns old type + void clear_value_and_discard_subtab_acc(size_t ndx, MixedColType new_type); + + // Get/set/insert 64-bit values in m_data/m_types + int64_t get_value(size_t ndx) const noexcept; + void set_value(size_t ndx, int64_t value, MixedColType); + void set_int64(size_t ndx, int64_t value, MixedColType pos_type, MixedColType neg_type); + + void insert_value(size_t row_ndx, int_fast64_t types_value, int_fast64_t data_value); + void insert_int(size_t ndx, int_fast64_t value, MixedColType type); + void insert_pos_neg(size_t ndx, int_fast64_t value, MixedColType pos_type, MixedColType neg_type); + + void do_discard_child_accessors() noexcept override; + +#ifdef REALM_DEBUG + void do_verify(const Table*, size_t col_ndx) const; +#endif + void leaf_to_dot(MemRef, ArrayParent*, size_t, std::ostream&) const override; +}; + +// LCOV_EXCL_START +inline StringData MixedColumn::get_index_data(size_t, StringIndex::StringConversionBuffer&) const noexcept +{ + REALM_ASSERT(false && "Index not supported for MixedColumn yet."); + REALM_UNREACHABLE(); + return {}; +} +// LCOV_EXCL_STOP + + +class MixedColumn::RefsColumn : public SubtableColumnBase { +public: + RefsColumn(Allocator& alloc, ref_type ref, Table* table, size_t column_ndx); + ~RefsColumn() noexcept override; + + using SubtableColumnBase::get_subtable_tableref; + + void refresh_accessor_tree(size_t, const Spec&) override; + + friend class MixedColumn; +}; + + +} // namespace realm + + +// Implementation +#include + + +#endif // REALM_COLUMN_MIXED_HPP