Add accessors for Maps to the embedding API.

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
@@ skipping 64 matching lines @@
                               list_class,
                               TypeArguments::Handle(isolate),
                               &malformed_type_error)) {
       ASSERT(malformed_type_error.IsNull());  // Type is a raw List.
       return instance.raw();
     }
   }
   return Instance::null();
 }
 
+static RawInstance* GetMapInstance(Isolate* isolate, const Object& obj) {
+  if (obj.IsInstance()) {
+    const Library& core_lib = Library::Handle(Library::CoreLibrary());
+    const Class& map_class =
+        Class::Handle(core_lib.LookupClass(Symbols::Map()));
+    ASSERT(!map_class.IsNull());
+    const Instance& instance = Instance::Cast(obj);
+    const Class& obj_class = Class::Handle(isolate, obj.clazz());
+    Error& malformed_type_error = Error::Handle(isolate);
+    if (obj_class.IsSubtypeOf(TypeArguments::Handle(isolate),
+                              map_class,
+                              TypeArguments::Handle(isolate),
+                              &malformed_type_error)) {
+      ASSERT(malformed_type_error.IsNull());  // Type is a raw Map.
+      return instance.raw();
+    }
+  }
+  return Instance::null();
+}
+
 
 static bool GetNativeStringArgument(NativeArguments* arguments,
                                     int arg_index,
                                     Dart_Handle* str,
                                     void** peer) {
   ASSERT(peer != NULL);
   if (Api::StringGetPeerHelper(arguments, arg_index, peer)) {
     *str = NULL;
     return true;
   }
@@ skipping 129 matching lines @@
   // If 'size' would be a significant fraction of new space, then use old.
   static const int kExtNewRatio = 16;
   if (size > (heap->CapacityInWords(Heap::kNew) * kWordSize) / kExtNewRatio) {
     return Heap::kOld;
   } else {
     return Heap::kNew;
   }
 }
 
 
+static RawObject* Send0Arg(const Instance& receiver,
+                           const String& selector) {
+  const intptr_t kNumArgs = 1;
+  ArgumentsDescriptor args_desc(
+      Array::Handle(ArgumentsDescriptor::New(kNumArgs)));
+  const Function& function = Function::Handle(
+      Resolver::ResolveDynamic(receiver, selector, args_desc));
+  if (function.IsNull()) {
+    return ApiError::New(String::Handle(String::New("")));
+  }
+  const Array& args = Array::Handle(Array::New(kNumArgs));
+  args.SetAt(0, receiver);
+  return DartEntry::InvokeFunction(function, args);
+}
+
+
+static RawObject* Send1Arg(const Instance& receiver,
+                           const String& selector,
+                           const Object& argument) {

[koda, 2014/05/30 20:40:23]

Instance seems safer.

[rmacnak, 2014/05/30 21:49:14]

Done.

+  const intptr_t kNumArgs = 2;
+  ArgumentsDescriptor args_desc(
+      Array::Handle(ArgumentsDescriptor::New(kNumArgs)));
+  const Function& function = Function::Handle(
+      Resolver::ResolveDynamic(receiver, selector, args_desc));
+  if (function.IsNull()) {
+    return ApiError::New(String::Handle(String::New("")));
+  }
+  const Array& args = Array::Handle(Array::New(kNumArgs));
+  args.SetAt(0, receiver);
+  args.SetAt(1, argument);
+  return DartEntry::InvokeFunction(function, args);
+}
+
+
 WeakReferenceSetBuilder* ApiState::NewWeakReferenceSetBuilder() {
   return new WeakReferenceSetBuilder(this);
 }
 
 
 void ApiState::DelayWeakReferenceSet(WeakReferenceSet* reference_set) {
   WeakReferenceSet::Push(reference_set, &delayed_weak_reference_sets_);
 }
 
 
@@ skipping 1559 matching lines @@
     return true;
   }
 
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
   return GetListInstance(isolate, obj) != Instance::null();
 }
 
 
+DART_EXPORT bool Dart_IsMap(Dart_Handle object) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
+  return GetMapInstance(isolate, obj) != Instance::null();
+}
+
+
 DART_EXPORT bool Dart_IsLibrary(Dart_Handle object) {
   TRACE_API_CALL(CURRENT_FUNC);
   return Api::ClassId(object) == kLibraryCid;
 }
 
 
 DART_EXPORT bool Dart_IsType(Dart_Handle handle) {
   TRACE_API_CALL(CURRENT_FUNC);
   return Api::ClassId(handle) == kTypeCid;
 }
@@ skipping 675 matching lines @@
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(list));
   if (obj.IsArray()) {
     GET_LIST_ELEMENT(isolate, Array, obj, index);
   } else if (obj.IsGrowableObjectArray()) {
     GET_LIST_ELEMENT(isolate, GrowableObjectArray, obj, index);
   } else if (obj.IsError()) {
     return list;
   } else {
     CHECK_CALLBACK_STATE(isolate);
-
     // Check and handle a dart object that implements the List interface.
     const Instance& instance =
         Instance::Handle(isolate, GetListInstance(isolate, obj));
     if (!instance.IsNull()) {
-      const int kNumArgs = 2;
-      ArgumentsDescriptor args_desc(
-          Array::Handle(ArgumentsDescriptor::New(kNumArgs)));
-      const Function& function = Function::Handle(
-          isolate,
-          Resolver::ResolveDynamic(instance, Symbols::IndexToken(), args_desc));
-      if (!function.IsNull()) {
-        const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
-        const Integer& indexobj = Integer::Handle(isolate, Integer::New(index));
-        args.SetAt(0, instance);
-        args.SetAt(1, indexobj);
-        return Api::NewHandle(isolate, DartEntry::InvokeFunction(function,
-                                                                 args));
-      }
+      return Api::NewHandle(isolate, Send1Arg(
+          instance,
+          Symbols::IndexToken(),
+          Integer::Handle(isolate, Integer::New(index))));
     }
     return Api::NewError("Object does not implement the 'List' interface");
   }
 }
 
 
 #define SET_LIST_ELEMENT(isolate, type, obj, index, value)                     \
   const type& array = type::Cast(obj);                                         \
   const Object& value_obj = Object::Handle(isolate, Api::UnwrapHandle(value)); \
   if (!value_obj.IsNull() && !value_obj.IsInstance()) {                        \
@@ skipping 358 matching lines @@
           return Api::NewHandle(isolate, result.raw());
         }
       }
       return Api::Success();
     }
   }
   return Api::NewError("Object does not implement the 'List' interface");
 }
 
 
+// --- Maps ---
+
+
+
+
+DART_EXPORT Dart_Handle Dart_MapGetAt(Dart_Handle map, Dart_Handle key) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(map));
+  const Instance& instance =
+      Instance::Handle(isolate, GetMapInstance(isolate, obj));
+  if (!instance.IsNull()) {
+    return Api::NewHandle(isolate, Send1Arg(
+       instance,
+       Symbols::IndexToken(),
+       Object::Handle(isolate, Api::UnwrapHandle(key))));
+  }
+  return Api::NewError("Object does not implement the 'Map' interface");
+}
+
+
+DART_EXPORT Dart_Handle Dart_MapContainsKey(Dart_Handle map, Dart_Handle key) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
+  const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(map));
+  const Instance& instance =
+      Instance::Handle(isolate, GetMapInstance(isolate, obj));
+  if (!instance.IsNull()) {
+    return Api::NewHandle(isolate, Send1Arg(
+       instance,
+       String::Handle(isolate, String::New("containsKey")),
+       Object::Handle(isolate, Api::UnwrapHandle(key))));
+  }
+  return Api::NewError("Object does not implement the 'Map' interface");
+}
+
+
+DART_EXPORT Dart_Handle Dart_MapKeys(Dart_Handle map) {
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
+  Object& obj = Object::Handle(isolate, Api::UnwrapHandle(map));
+  Instance& instance =
+      Instance::Handle(isolate, GetMapInstance(isolate, obj));
+  if (!instance.IsNull()) {
+    const Object& iterator = Object::Handle(Send0Arg(
+        instance, String::Handle(String::New("get:keys"))));
+    if (!iterator.IsInstance()) {
+      return Api::NewHandle(isolate, iterator.raw());
+    }
+    return Api::NewHandle(isolate, Send0Arg(
+        Instance::Cast(iterator),
+        String::Handle(String::New("toList"))));
+  }
+  return Api::NewError("Object does not implement the 'Map' interface");
+}
+
+
 // --- Typed Data ---
 
 // Helper method to get the type of a TypedData object.
 static Dart_TypedData_Type GetType(intptr_t class_id) {
   Dart_TypedData_Type type;
   switch (class_id) {
     case kByteDataViewCid :
       type = Dart_TypedData_kByteData;
       break;
     case kTypedDataInt8ArrayCid :
@@ skipping 2166 matching lines @@
 
 
 DART_EXPORT void Dart_RegisterRootServiceRequestCallback(
     const char* name,
     Dart_ServiceRequestCallback callback,
     void* user_data) {
   Service::RegisterRootEmbedderCallback(name, callback, user_data);
 }
 
 }  // namespace dart