WIP: Create a public v8::DictionarySchema API for bulk reads from dict objects.

include/v8.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
@@ skipping 284 matching lines @@
   friend Local<Primitive> Null(Isolate* isolate);
   friend Local<Boolean> True(Isolate* isolate);
   friend Local<Boolean> False(Isolate* isolate);
   friend class HandleScope;
   friend class EscapableHandleScope;
   template <class F1, class F2, class F3>
   friend class PersistentValueMapBase;
   template<class F1, class F2> friend class PersistentValueVector;
   template <class F>
   friend class ReturnValue;
+  friend class DictionarySchema;
 
   explicit V8_INLINE Local(T* that) : val_(that) {}
   V8_INLINE static Local<T> New(Isolate* isolate, T* that);
   T* val_;
 };
 
 
 #if !defined(V8_IMMINENT_DEPRECATION_WARNINGS)
 // Handle is an alias for Local for historical reasons.
 template <class T>
@@ skipping 5259 matching lines @@
 class V8_EXPORT AccessorSignature : public Data {
  public:
   static Local<AccessorSignature> New(
       Isolate* isolate,
       Local<FunctionTemplate> receiver = Local<FunctionTemplate>());
 
  private:
   AccessorSignature();
 };
 
+// --- Dictionary schema ---
+
+/*
+ * A DictionarySchema defines the keys expected to be present on a dictionary
+ * object and provides an efficient way of reading them.
+ */
+class V8_EXPORT DictionarySchema : public Data {
+ public:
+  static Local<DictionarySchema> New(Isolate* isolate, Local<Value> keys[],
+                                     int keyCount);
+
+  enum ValueFilter {
+    kValueFilterNone = 0,
+    kValueFilterPrimitives = 1 << 0,
+    kValueFilterObjects = 1 << 1,
+  };
+
+  /*
+   * Reads keys from the object according to the schema, in order.
+   * Reading will abort if:
+   * - an exception is thrown (Nothing<bool>() is returned)
+   * - an object that doesn't match |continue_filter| is reached
+   *   (Just(false) is returned)
+   * - all properties are read (Just(true) is returned)
+   *
+   * |index| will be updated to point to the next index left to be read;
+   * this makes repeated invocations convenient.
+   */
+  Maybe<bool> Get(Local<Context> context, Local<Object> object,
+                  ValueFilter continue_filter, Local<Value>* out_values,
+                  int out_length, int* index);
+};
 
 // --- Extensions ---
 
 class V8_EXPORT ExternalOneByteStringResourceImpl
     : public String::ExternalOneByteStringResource {
  public:
   ExternalOneByteStringResourceImpl() : data_(0), length_(0) {}
   ExternalOneByteStringResourceImpl(const char* data, size_t length)
       : data_(data), length_(length) {}
   const char* data() const { return data_; }
@@ skipping 4237 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // INCLUDE_V8_H_