From 03108713ee93044c0fba59356ec4728f03d4c54d Mon Sep 17 00:00:00 2001 From: Thomas Goyne Date: Thu, 21 Jan 2016 10:45:41 -0800 Subject: [PATCH] Make PropertyType an enum class --- src/object_accessor.hpp | 44 +++++++++++++------------- src/object_schema.cpp | 6 ++-- src/object_store.cpp | 20 ++++++------ src/parser/query_builder.cpp | 20 ++++++------ src/property.hpp | 52 +++++++++++++++---------------- src/schema.cpp | 4 +-- tests/list.cpp | 8 ++--- tests/results.cpp | 12 +++---- tests/transaction_log_parsing.cpp | 16 +++++----- 9 files changed, 91 insertions(+), 91 deletions(-) diff --git a/src/object_accessor.hpp b/src/object_accessor.hpp index 3fea1741..e8924269 100644 --- a/src/object_accessor.hpp +++ b/src/object_accessor.hpp @@ -172,31 +172,31 @@ namespace realm { } switch (property.type) { - case PropertyTypeBool: + case PropertyType::Bool: m_row.set_bool(column, Accessor::to_bool(ctx, value)); break; - case PropertyTypeInt: + case PropertyType::Int: m_row.set_int(column, Accessor::to_long(ctx, value)); break; - case PropertyTypeFloat: + case PropertyType::Float: m_row.set_float(column, Accessor::to_float(ctx, value)); break; - case PropertyTypeDouble: + case PropertyType::Double: m_row.set_double(column, Accessor::to_double(ctx, value)); break; - case PropertyTypeString: + case PropertyType::String: m_row.set_string(column, Accessor::to_string(ctx, value)); break; - case PropertyTypeData: + case PropertyType::Data: m_row.set_binary(column, BinaryData(Accessor::to_binary(ctx, value))); break; - case PropertyTypeAny: + case PropertyType::Any: m_row.set_mixed(column, Accessor::to_mixed(ctx, value)); break; - case PropertyTypeDate: + case PropertyType::Date: m_row.set_timestamp(column, Accessor::to_timestamp(ctx, value)); break; - case PropertyTypeObject: { + case PropertyType::Object: { if (Accessor::is_null(ctx, value)) { m_row.nullify_link(column); } @@ -205,7 +205,7 @@ namespace realm { } break; } - case PropertyTypeArray: { + case PropertyType::Array: { realm::LinkViewRef link_view = m_row.get_linklist(column); link_view->clear(); if (!Accessor::is_null(ctx, value)) { @@ -231,23 +231,23 @@ namespace realm { } switch (property.type) { - case PropertyTypeBool: + case PropertyType::Bool: return Accessor::from_bool(ctx, m_row.get_bool(column)); - case PropertyTypeInt: + case PropertyType::Int: return Accessor::from_long(ctx, m_row.get_int(column)); - case PropertyTypeFloat: + case PropertyType::Float: return Accessor::from_float(ctx, m_row.get_float(column)); - case PropertyTypeDouble: + case PropertyType::Double: return Accessor::from_double(ctx, m_row.get_double(column)); - case PropertyTypeString: + case PropertyType::String: return Accessor::from_string(ctx, m_row.get_string(column)); - case PropertyTypeData: + case PropertyType::Data: return Accessor::from_binary(ctx, m_row.get_binary(column)); - case PropertyTypeAny: + case PropertyType::Any: throw "Any not supported"; - case PropertyTypeDate: + case PropertyType::Date: return Accessor::from_timestamp(ctx, m_row.get_timestamp(column)); - case PropertyTypeObject: { + case PropertyType::Object: { auto linkObjectSchema = m_realm->config().schema->find(property.object_type); TableRef table = ObjectStore::table_for_object_type(m_realm->read_group(), linkObjectSchema->name); if (m_row.is_null_link(property.table_column)) { @@ -255,7 +255,7 @@ namespace realm { } return Accessor::from_object(ctx, std::move(Object(m_realm, *linkObjectSchema, table->get(m_row.get_link(column))))); } - case PropertyTypeArray: { + case PropertyType::Array: { auto arrayObjectSchema = m_realm->config().schema->find(property.object_type); return Accessor::from_list(ctx, std::move(List(m_realm, *arrayObjectSchema, static_cast(m_row.get_linklist(column))))); } @@ -281,7 +281,7 @@ namespace realm { if (primary_prop) { // search for existing object based on primary key type ValueType primary_value = Accessor::dict_value_for_key(ctx, value, object_schema.primary_key); - if (primary_prop->type == PropertyTypeString) { + if (primary_prop->type == PropertyType::String) { row_index = table->find_first_string(primary_prop->table_column, Accessor::to_string(ctx, primary_value)); } else { @@ -312,7 +312,7 @@ namespace realm { if (Accessor::has_default_value_for_property(ctx, realm.get(), object_schema, prop.name)) { object.set_property_value_impl(ctx, prop, Accessor::default_value_for_property(ctx, realm.get(), object_schema, prop.name), try_update); } - else if (prop.is_nullable || prop.type == PropertyTypeArray) { + else if (prop.is_nullable || prop.type == PropertyType::Array) { object.set_property_value_impl(ctx, prop, Accessor::null_value(ctx), try_update); } else { diff --git a/src/object_schema.cpp b/src/object_schema.cpp index dfd4679c..f794c34a 100644 --- a/src/object_schema.cpp +++ b/src/object_schema.cpp @@ -27,7 +27,7 @@ using namespace realm; #define ASSERT_PROPERTY_TYPE_VALUE(property, type) \ - static_assert(static_cast(PropertyType##property) == type_##type, \ + static_assert(static_cast(PropertyType::property) == type_##type, \ "PropertyType and DataType must have the same values") ASSERT_PROPERTY_TYPE_VALUE(Int, Int); @@ -62,9 +62,9 @@ ObjectSchema::ObjectSchema(const Group *group, const std::string &name) : name(n property.type = (PropertyType)table->get_column_type(col); property.is_indexed = table->has_search_index(col); property.is_primary = false; - property.is_nullable = table->is_nullable(col) || property.type == PropertyTypeObject; + property.is_nullable = table->is_nullable(col) || property.type == PropertyType::Object; property.table_column = col; - if (property.type == PropertyTypeObject || property.type == PropertyTypeArray) { + if (property.type == PropertyType::Object || property.type == PropertyType::Array) { // set link type for objects and arrays ConstTableRef linkTable = table->get_link_target(col); property.object_type = ObjectStore::object_type_for_table_name(linkTable->get_name().data()); diff --git a/src/object_store.cpp b/src/object_store.cpp index 565d5ac0..83742be5 100644 --- a/src/object_store.cpp +++ b/src/object_store.cpp @@ -224,25 +224,25 @@ static void copy_property_values(const Property& old_property, const Property& n static void copy_property_values(const Property& source, const Property& destination, Table& table) { switch (destination.type) { - case PropertyTypeInt: + case PropertyType::Int: copy_property_values(source, destination, table, &Table::get_int, &Table::set_int); break; - case PropertyTypeBool: + case PropertyType::Bool: copy_property_values(source, destination, table, &Table::get_bool, &Table::set_bool); break; - case PropertyTypeFloat: + case PropertyType::Float: copy_property_values(source, destination, table, &Table::get_float, &Table::set_float); break; - case PropertyTypeDouble: + case PropertyType::Double: copy_property_values(source, destination, table, &Table::get_double, &Table::set_double); break; - case PropertyTypeString: + case PropertyType::String: copy_property_values(source, destination, table, &Table::get_string, &Table::set_string); break; - case PropertyTypeData: + case PropertyType::Data: copy_property_values(source, destination, table, &Table::get_binary, &Table::set_binary); break; - case PropertyTypeDate: + case PropertyType::Date: copy_property_values(source, destination, table, &Table::get_timestamp, &Table::set_timestamp); break; default: @@ -319,8 +319,8 @@ void ObjectStore::create_tables(Group *group, Schema &target_schema, bool update if (!current_prop || current_prop->table_column == npos) { switch (target_prop.type) { // for objects and arrays, we have to specify target table - case PropertyTypeObject: - case PropertyTypeArray: { + case PropertyType::Object: + case PropertyType::Array: { TableRef link_table = ObjectStore::table_for_object_type(group, target_prop.object_type); REALM_ASSERT(link_table); target_prop.table_column = table->add_column_link(DataType(target_prop.type), target_prop.name, *link_table); @@ -560,7 +560,7 @@ MissingPropertyException::MissingPropertyException(std::string const& object_typ InvalidNullabilityException::InvalidNullabilityException(std::string const& object_type, Property const& property) : ObjectSchemaPropertyException(object_type, property) { - if (property.type == PropertyTypeObject) { + if (property.type == PropertyType::Object) { m_what = "'Object' property '" + property.name + "' must be nullable."; } else { diff --git a/src/parser/query_builder.cpp b/src/parser/query_builder.cpp index f55a3b71..28334a88 100644 --- a/src/parser/query_builder.cpp +++ b/src/parser/query_builder.cpp @@ -94,7 +94,7 @@ struct PropertyExpression KeyPath key_path = key_path_from_string(key_path_string); for (size_t index = 0; index < key_path.size(); index++) { if (prop) { - precondition(prop->type == PropertyTypeObject || prop->type == PropertyTypeArray, + precondition(prop->type == PropertyType::Object || prop->type == PropertyType::Array, (std::string)"Property '" + key_path[index] + "' is not a link in object of type '" + desc->name + "'"); indexes.push_back(prop->table_column); @@ -400,36 +400,36 @@ void do_add_comparison_to_query(Query &query, const Schema &schema, const Object { auto type = expr.prop->type; switch (type) { - case PropertyTypeBool: + case PropertyType::Bool: add_bool_constraint_to_query(query, cmp.op, value_of_type_for_query(expr.table_getter, lhs, args), value_of_type_for_query(expr.table_getter, rhs, args)); break; - case PropertyTypeDate: + case PropertyType::Date: add_numeric_constraint_to_query(query, cmp.op, value_of_type_for_query(expr.table_getter, lhs, args), value_of_type_for_query(expr.table_getter, rhs, args)); break; - case PropertyTypeDouble: + case PropertyType::Double: add_numeric_constraint_to_query(query, cmp.op, value_of_type_for_query(expr.table_getter, lhs, args), value_of_type_for_query(expr.table_getter, rhs, args)); break; - case PropertyTypeFloat: + case PropertyType::Float: add_numeric_constraint_to_query(query, cmp.op, value_of_type_for_query(expr.table_getter, lhs, args), value_of_type_for_query(expr.table_getter, rhs, args)); break; - case PropertyTypeInt: + case PropertyType::Int: add_numeric_constraint_to_query(query, cmp.op, value_of_type_for_query(expr.table_getter, lhs, args), value_of_type_for_query(expr.table_getter, rhs, args)); break; - case PropertyTypeString: + case PropertyType::String: add_string_constraint_to_query(query, cmp, value_of_type_for_query(expr.table_getter, lhs, args), value_of_type_for_query(expr.table_getter, rhs, args)); break; - case PropertyTypeData: + case PropertyType::Data: add_binary_constraint_to_query(query, cmp.op, value_of_type_for_query(expr.table_getter, lhs, args), value_of_type_for_query(expr.table_getter, rhs, args)); break; - case PropertyTypeObject: - case PropertyTypeArray: + case PropertyType::Object: + case PropertyType::Array: add_link_constraint_to_query(query, cmp.op, expr, link_argument(lhs, rhs, args)); break; default: { diff --git a/src/property.hpp b/src/property.hpp index 7f968bd2..edd22a75 100644 --- a/src/property.hpp +++ b/src/property.hpp @@ -22,17 +22,17 @@ #include namespace realm { - enum PropertyType { - PropertyTypeInt = 0, - PropertyTypeBool = 1, - PropertyTypeFloat = 9, - PropertyTypeDouble = 10, - PropertyTypeString = 2, - PropertyTypeData = 4, - PropertyTypeAny = 6, // deprecated and will be removed in the future - PropertyTypeDate = 8, - PropertyTypeObject = 12, - PropertyTypeArray = 13, + enum class PropertyType { + Int = 0, + Bool = 1, + Float = 9, + Double = 10, + String = 2, + Data = 4, + Any = 6, // deprecated and will be removed in the future + Date = 8, + Object = 12, + Array = 13, }; struct Property { @@ -47,15 +47,15 @@ namespace realm { bool requires_index() const { return is_primary || is_indexed; } bool is_indexable() const { - return type == PropertyTypeInt - || type == PropertyTypeBool - || type == PropertyTypeDate - || type == PropertyTypeString; + return type == PropertyType::Int + || type == PropertyType::Bool + || type == PropertyType::Date + || type == PropertyType::String; } #if __GNUC__ < 5 // GCC 4.9 does not support C++14 braced-init with NSDMIs - Property(std::string name="", PropertyType type=PropertyTypeInt, std::string object_type="", + Property(std::string name="", PropertyType type=PropertyType::Int, std::string object_type="", bool is_primary=false, bool is_indexed=false, bool is_nullable=false) : name(std::move(name)) , type(type) @@ -70,25 +70,25 @@ namespace realm { static inline const char *string_for_property_type(PropertyType type) { switch (type) { - case PropertyTypeString: + case PropertyType::String: return "string"; - case PropertyTypeInt: + case PropertyType::Int: return "int"; - case PropertyTypeBool: + case PropertyType::Bool: return "bool"; - case PropertyTypeDate: + case PropertyType::Date: return "date"; - case PropertyTypeData: + case PropertyType::Data: return "data"; - case PropertyTypeDouble: + case PropertyType::Double: return "double"; - case PropertyTypeFloat: + case PropertyType::Float: return "float"; - case PropertyTypeAny: + case PropertyType::Any: return "any"; - case PropertyTypeObject: + case PropertyType::Object: return "object"; - case PropertyTypeArray: + case PropertyType::Array: return "array"; #if __GNUC__ default: diff --git a/src/schema.cpp b/src/schema.cpp index 50cfc670..2d036041 100644 --- a/src/schema.cpp +++ b/src/schema.cpp @@ -74,11 +74,11 @@ void Schema::validate() const // check nullablity if (prop.is_nullable) { - if (prop.type == PropertyTypeArray || prop.type == PropertyTypeAny) { + if (prop.type == PropertyType::Array || prop.type == PropertyType::Any) { exceptions.emplace_back(InvalidNullabilityException(object.name, prop)); } } - else if (prop.type == PropertyTypeObject) { + else if (prop.type == PropertyType::Object) { exceptions.emplace_back(InvalidNullabilityException(object.name, prop)); } diff --git a/tests/list.cpp b/tests/list.cpp index c355a6ed..4495762a 100644 --- a/tests/list.cpp +++ b/tests/list.cpp @@ -24,16 +24,16 @@ TEST_CASE("list") { config.cache = false; config.schema = std::make_unique(Schema{ {"origin", "", { - {"array", PropertyTypeArray, "target"} + {"array", PropertyType::Array, "target"} }}, {"target", "", { - {"value", PropertyTypeInt} + {"value", PropertyType::Int} }}, {"other_origin", "", { - {"array", PropertyTypeArray, "other_target"} + {"array", PropertyType::Array, "other_target"} }}, {"other_target", "", { - {"value", PropertyTypeInt} + {"value", PropertyType::Int} }}, }); diff --git a/tests/results.cpp b/tests/results.cpp index 85b58692..9113d76e 100644 --- a/tests/results.cpp +++ b/tests/results.cpp @@ -23,17 +23,17 @@ TEST_CASE("Results") { config.automatic_change_notifications = false; config.schema = std::make_unique(Schema{ {"object", "", { - {"value", PropertyTypeInt}, - {"link", PropertyTypeObject, "linked to object", false, false, true} + {"value", PropertyType::Int}, + {"link", PropertyType::Object, "linked to object", false, false, true} }}, {"other object", "", { - {"value", PropertyTypeInt} + {"value", PropertyType::Int} }}, {"linking object", "", { - {"link", PropertyTypeObject, "object", false, false, true} + {"link", PropertyType::Object, "object", false, false, true} }}, {"linked to object", "", { - {"value", PropertyTypeInt} + {"value", PropertyType::Int} }} }); @@ -426,7 +426,7 @@ TEST_CASE("Async Results error handling") { config.automatic_change_notifications = false; config.schema = std::make_unique(Schema{ {"object", "", { - {"value", PropertyTypeInt}, + {"value", PropertyType::Int}, }}, }); diff --git a/tests/transaction_log_parsing.cpp b/tests/transaction_log_parsing.cpp index b4654d24..fd35503b 100644 --- a/tests/transaction_log_parsing.cpp +++ b/tests/transaction_log_parsing.cpp @@ -113,8 +113,8 @@ TEST_CASE("Transaction log parsing") { SECTION("schema change validation") { config.schema = std::make_unique(Schema{ {"table", "", { - {"unindexed", PropertyTypeInt}, - {"indexed", PropertyTypeInt, "", false, true} + {"unindexed", PropertyType::Int}, + {"indexed", PropertyType::Int, "", false, true} }}, }); auto r = Realm::get_shared_realm(config); @@ -180,7 +180,7 @@ TEST_CASE("Transaction log parsing") { SECTION("table change information") { config.schema = std::make_unique(Schema{ {"table", "", { - {"value", PropertyTypeInt} + {"value", PropertyType::Int} }}, }); @@ -269,10 +269,10 @@ TEST_CASE("Transaction log parsing") { SECTION("LinkView change information") { config.schema = std::make_unique(Schema{ {"origin", "", { - {"array", PropertyTypeArray, "target"} + {"array", PropertyType::Array, "target"} }}, {"target", "", { - {"value", PropertyTypeInt} + {"value", PropertyType::Int} }}, }); @@ -806,9 +806,9 @@ TEST_CASE("DeepChangeChecker") { config.schema = std::make_unique(Schema{ {"table", "", { - {"int", PropertyTypeInt}, - {"link", PropertyTypeObject, "table", false, false, true}, - {"array", PropertyTypeArray, "table"} + {"int", PropertyType::Int}, + {"link", PropertyType::Object, "table", false, false, true}, + {"array", PropertyType::Array, "table"} }}, });