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 62 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 1689 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 1063 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()) {
+    const intptr_t 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));
+      args.SetAt(0, instance);
+      args.SetAt(1, Object::Handle(isolate, Api::UnwrapHandle(key)));
+      return Api::NewHandle(isolate, DartEntry::InvokeFunction(function,
+                            args));
+    }
+  }
+  return Api::NewError("Object does not implement the 'Map' interface");
+}
+
+
+DART_EXPORT Dart_Handle Dart_MapContainsKey(Dart_Handle map, Dart_Handle key) {

[koda, 2014/05/22 23:40:24]

These two functions only differ by the method name resolved. Please consider
sharing their code (possibly also with some List functions above).

[rmacnak, 2014/05/30 17:23:33]

Factored out 0 and 1 argument sends, and used in ListGetAt. Much of list
functions is C/Dart conversion code, so it doesn't share well with the map
functions which only deal with Dart objects.

+  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()) {
+    const intptr_t kNumArgs = 2;
+    ArgumentsDescriptor args_desc(
+        Array::Handle(ArgumentsDescriptor::New(kNumArgs)));
+    const Function& function = Function::Handle(
+  isolate,

[koda, 2014/05/22 23:40:24]

Indentation.

+        Resolver::ResolveDynamic(instance,
+                                 String::Handle(String::New("containsKey")),
+                                 args_desc));
+    if (!function.IsNull()) {
+      const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
+      args.SetAt(0, instance);
+      args.SetAt(1, Object::Handle(isolate, Api::UnwrapHandle(key)));
+      return Api::NewHandle(isolate, DartEntry::InvokeFunction(function,
+                                                               args));
+    }
+  }
+  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 intptr_t kNumArgs = 1;
+    ArgumentsDescriptor args_desc(
+        Array::Handle(ArgumentsDescriptor::New(kNumArgs)));
+    Function& function = Function::Handle(
+          isolate,
+          Resolver::ResolveDynamic(instance,
+                                   String::Handle(String::New("get:keys")),
+                                   args_desc));
+    if (!function.IsNull()) {
+      const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
+      args.SetAt(0, instance);
+      obj = DartEntry::InvokeFunction(function, args);
+      if (!obj.IsInstance()) {
+        return Api::NewHandle(isolate, obj.raw());
+      }
+      instance ^= obj.raw();

[koda, 2014/05/22 23:40:24]

To help the reader, please create a new handle (with a descriptive name).

[rmacnak, 2014/05/30 17:23:33]

Intermediate result named iterator.

+      function = Resolver::ResolveDynamic(instance,
+                                          String::Handle(String::New("toList")),
+                                          args_desc);
+      args.SetAt(0, instance);

[koda, 2014/05/23 00:33:05]

Consider passing in 'false' as an argument to get a fixed size list.

[rmacnak, 2014/05/30 17:23:33]

Not worth another helper to handle the optional parameter.

+      if (!function.IsNull()) {
+        return Api::NewHandle(isolate, DartEntry::InvokeFunction(function,
+                                                                 args));
+      }
+    }
+  }
+  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