status-im
/
realm-js
mirror of https://github.com/status-im/realm-js.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

create RealmObject class and make isValid a member

This commit is contained in:
Ari Lazier 2016-04-26 16:30:04 -07:00
parent 988f723f49
commit b59784670b
7 changed files with 60 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
lib/browser/index.js
View File

@ -151,7 +151,6 @@ export default class Realm {
// Non-mutating methods:
util.createMethods(Realm.prototype, objectTypes.REALM, [
'close',
'isValid',
]);
// Mutating methods:

10
lib/browser/objects.js
View File

@ -23,10 +23,18 @@ import { getterForProperty, setterForProperty } from './util';
const registeredConstructors = {};
export default class RealmObject {
}
// Non-mutating methods:
createMethods(RealmObject.prototype, objectTypes.OBJECT, [
'isValid',
]);
export function create(realmId, info) {
let schema = info.schema;
let constructor = (registeredConstructors[realmId] || {})[schema.name];
let object = constructor ? Object.create(constructor.prototype) : {};
let object = Object.create(constructor ? constructor.prototype : RealmObject.prototype);
object[keys.realm] = realmId;
object[keys.id] = info.id;

19
src/js_realm.hpp
View File

@ -138,7 +138,6 @@ class Realm {
static void create(ContextType, ObjectType, size_t, const ValueType[], ReturnValue &);
static void delete_one(ContextType, ObjectType, size_t, const ValueType[], ReturnValue &);
static void delete_all(ContextType, ObjectType, size_t, const ValueType[], ReturnValue &);
static void is_object_valid(ContextType, ObjectType, size_t, const ValueType[], ReturnValue &);
static void write(ContextType, ObjectType, size_t, const ValueType[], ReturnValue &);
static void add_listener(ContextType, ObjectType, size_t, const ValueType[], ReturnValue &);
static void remove_listener(ContextType, ObjectType, size_t, const ValueType[], ReturnValue &);
@ -213,7 +212,6 @@ struct RealmClass : ClassDefinition<T, SharedRealm> {
{"create", wrap<Realm::create>},
{"delete", wrap<Realm::delete_one>},
{"deleteAll", wrap<Realm::delete_all>},
{"isValid", wrap<Realm::is_object_valid>},
{"write", wrap<Realm::write>},
{"addListener", wrap<Realm::add_listener>},
{"removeListener", wrap<Realm::remove_listener>},
@ -233,11 +231,13 @@ inline typename T::Function Realm<T>::create_constructor(ContextType ctx) {
FunctionType collection_constructor = ObjectWrap<T, CollectionClass<T>>::create_constructor(ctx);
FunctionType list_constructor = ObjectWrap<T, ListClass<T>>::create_constructor(ctx);
FunctionType results_constructor = ObjectWrap<T, ResultsClass<T>>::create_constructor(ctx);
FunctionType realm_object_constructor = ObjectWrap<T, RealmObjectClass<T>>::create_constructor(ctx);
PropertyAttributes attributes = PropertyAttributes(ReadOnly | DontEnum | DontDelete);
Object::set_property(ctx, realm_constructor, "Collection", collection_constructor, attributes);
Object::set_property(ctx, realm_constructor, "List", list_constructor, attributes);
Object::set_property(ctx, realm_constructor, "Results", results_constructor, attributes);
Object::set_property(ctx, realm_constructor, "RealmObject", realm_object_constructor, attributes);
return realm_constructor;
}
@ -456,19 +456,6 @@ void Realm<T>::delete_all(ContextType ctx, ObjectType this_object, size_t argc,
ObjectStore::table_for_object_type(realm->read_group(), objectSchema.name)->clear();
}
}
template<typename T>
void Realm<T>::is_object_valid(ContextType ctx, ObjectType this_object, size_t argc, const ValueType arguments[], ReturnValue &return_value) {
validate_argument_count(argc, 1);
ObjectType arg = Value::validated_to_object(ctx, arguments[0]);
if (Object::template is_instance<RealmObjectClass<T>>(ctx, arg)) {
return_value.set(get_internal<T, RealmObjectClass<T>>(arg)->is_valid());
}
else {
throw std::runtime_error("Object is not a Realm Object");
}
}
template<typename T>
void Realm<T>::write(ContextType ctx, ObjectType this_object, size_t argc, const ValueType arguments[], ReturnValue &return_value) {
@ -484,7 +471,7 @@ void Realm<T>::write(ContextType ctx, ObjectType this_object, size_t argc, const
}
catch (std::exception &e) {
realm->cancel_transaction();
throw e;
throw;
}
realm->commit_transaction();

17
src/js_realm_object.hpp
View File

@ -46,6 +46,8 @@ class RealmObject {
static void get_property(ContextType, ObjectType, const String &, ReturnValue &);
static bool set_property(ContextType, ObjectType, const String &, ValueType);
static std::vector<String> get_property_names(ContextType, ObjectType);
static void is_valid(ContextType, ObjectType, size_t, const ValueType [], ReturnValue &);
};
template<typename T>
@ -59,8 +61,23 @@ struct RealmObjectClass : ClassDefinition<T, realm::Object> {
wrap<RealmObject::set_property>,
wrap<RealmObject::get_property_names>,
};
using ContextType = typename T::Context;
using ObjectType = typename T::Object;
using ValueType = typename T::Value;
using ReturnValue = js::ReturnValue<T>;
MethodMap<T> const methods = {
{"isValid", wrap<RealmObject::is_valid>},
};
};
template<typename T>
void RealmObject<T>::is_valid(ContextType ctx, ObjectType this_object, size_t argc, const ValueType arguments[], ReturnValue &return_value) {
return_value.set(get_internal<T, RealmObjectClass<T>>(this_object)->is_valid());
}
template<typename T>
typename T::Object RealmObject<T>::create_instance(ContextType ctx, realm::Object &realm_object) {
static String prototype_string = "prototype";

12
src/object-store/src/object_accessor.hpp
View File

@ -48,7 +48,7 @@ namespace realm {
const ObjectSchema &get_object_schema() { return *m_object_schema; }
Row row() { return m_row; }
bool is_valid() { return m_row.is_attached(); }
bool is_valid() const { return m_row.is_attached(); }
private:
SharedRealm m_realm;
@ -147,9 +147,7 @@ namespace realm {
//
template <typename ValueType, typename ContextType>
inline void Object::set_property_value(ContextType ctx, std::string prop_name, ValueType value, bool try_update)
{
verify_attached();
{
const Property *prop = m_object_schema->property_for_name(prop_name);
if (!prop) {
throw InvalidPropertyException(m_object_schema->name, prop_name,
@ -161,8 +159,6 @@ namespace realm {
template <typename ValueType, typename ContextType>
inline ValueType Object::get_property_value(ContextType ctx, std::string prop_name)
{
verify_attached();
const Property *prop = m_object_schema->property_for_name(prop_name);
if (!prop) {
throw InvalidPropertyException(m_object_schema->name, prop_name,
@ -176,6 +172,8 @@ namespace realm {
{
using Accessor = NativeAccessor<ValueType, ContextType>;
verify_attached();
if (!m_realm->is_in_transaction()) {
throw MutationOutsideTransactionException("Can only set property values within a transaction.");
}
@ -240,6 +238,8 @@ namespace realm {
{
using Accessor = NativeAccessor<ValueType, ContextType>;
verify_attached();
size_t column = property.table_column;
if (property.is_nullable && m_row.is_null(column)) {
return Accessor::null_value(ctx);

26
tests/js/object-tests.js
View File

@ -431,5 +431,29 @@ module.exports = BaseTest.extend({
object.dataCol = [1];
});
});
}
},
testObjectConstructor: function() {
var realm = new Realm({schema: [schemas.TestObject]});
realm.write(function() {
var obj = realm.create('TestObject', {doubleCol: 1});
TestCase.assertTrue(obj instanceof Realm.RealmObject);
});
},
testIsValid: function() {
var realm = new Realm({schema: [schemas.TestObject]});
var obj;
realm.write(function() {
obj = realm.create('TestObject', {doubleCol: 1});
TestCase.assertEqual(obj.isValid(), true);
realm.delete(obj);
TestCase.assertEqual(obj.isValid(), false);
});
TestCase.assertEqual(obj.isValid(), false);
TestCase.assertThrows(function() {
obj.doubleCol;
});
},
});

16
tests/js/realm-tests.js
View File

@ -516,22 +516,6 @@ module.exports = BaseTest.extend({
TestCase.assertEqual(realm.objects('IntPrimaryObject').length, 0);
},
testIsValid: function() {
var realm = new Realm({schema: [schemas.TestObject]});
var obj;
realm.write(function() {
obj = realm.create('TestObject', {doubleCol: 1});
TestCase.assertEqual(realm.isValid(obj), true);
realm.delete(obj);
TestCase.assertEqual(realm.isValid(obj), false);
});
TestCase.assertEqual(realm.isValid(obj), false);
TestCase.assertThrows(function() {
obj.doubleCol;
});
},
testRealmObjects: function() {
var realm = new Realm({schema: [schemas.PersonObject, schemas.DefaultValues, schemas.TestObject]});