Push SetAccessor to Template

include/v8.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 2109 matching lines @@
                                  AccessControl settings = DEFAULT,
                                  PropertyAttribute attribute = None));
   bool SetAccessor(Handle<String> name,
                    AccessorGetterCallback getter,
                    AccessorSetterCallback setter = 0,
                    Handle<Value> data = Handle<Value>(),
                    AccessControl settings = DEFAULT,
                    PropertyAttribute attribute = None);
 
   // This function is not yet stable and should not be used at this time.
-  bool SetAccessor(Handle<String> name,
-                   Handle<DeclaredAccessorDescriptor> descriptor,
-                   AccessControl settings = DEFAULT,
-                   PropertyAttribute attribute = None);
+  bool SetDeclaredAccessor(Handle<String> name,
+                           Handle<DeclaredAccessorDescriptor> descriptor,
+                           AccessControl settings = DEFAULT,
+                           PropertyAttribute attribute = None);
 
   /**
    * Returns an array containing the names of the enumerable properties
    * of this object, including properties from prototype objects.  The
    * array returned by this method contains the same values as would
    * be enumerated by a for-in statement over this object.
    */
   Local<Array> GetPropertyNames();
 
   /**
@@ skipping 826 matching lines @@
 
 /**
  * The superclass of object and function templates.
  */
 class V8_EXPORT Template : public Data {
  public:
   /** Adds a property to each instance created by this template.*/
   void Set(Handle<String> name, Handle<Data> value,
            PropertyAttribute attributes = None);
   V8_INLINE(void Set(const char* name, Handle<Data> value));
+
+  /**
+   * Whenever the property with the given name is accessed on objects
+   * created from this Template the getter and setter callbacks
+   * are called instead of getting and setting the property directly
+   * on the JavaScript object.
+   *
+   * \param name The name of the property for which an accessor is added.
+   * \param getter The callback to invoke when getting the property.
+   * \param setter The callback to invoke when setting the property.
+   * \param data A piece of data that will be passed to the getter and setter
+   *   callbacks whenever they are invoked.
+   * \param settings Access control settings for the accessor. This is a bit
+   *   field consisting of one of more of
+   *   DEFAULT = 0, ALL_CAN_READ = 1, or ALL_CAN_WRITE = 2.
+   *   The default is to not allow cross-context access.
+   *   ALL_CAN_READ means that all cross-context reads are allowed.
+   *   ALL_CAN_WRITE means that all cross-context writes are allowed.
+   *   The combination ALL_CAN_READ | ALL_CAN_WRITE can be used to allow all
+   *   cross-context access.
+   * \param attribute The attributes of the property for which an accessor
+   *   is added.
+   * \param signature The signature describes valid receivers for the accessor
+   *   and is used to perform implicit instance checks against them. If the
+   *   receiver is incompatible (i.e. is not an instance of the constructor as
+   *   defined by FunctionTemplate::HasInstance()), an implicit TypeError is
+   *   thrown and no callback is invoked.
+   */
+  void SetNativeAccessor(Handle<String> name,

[Michael Starzinger, 2013/08/20 17:05:41]

As discussed offline, the following naming scheme makes the most sense to me and
Andreas. WDYT?

- SetDataProperty(), for normal data properties taking HValue
- SetNativeProperty(), for data properties using Accessor[G/S]etterCallback
- SetAccessorProperty(), for JavaScript accessors

To be more precise, this would yield the following signatures:

void SetDataProperty(Handle<String> name,
                     Handle<Data> value,
                     PropertyAttribute attributes = None);

void SetNativeProperty(Handle<String> name,
                       AccessorGetterCallback getter,
                       AccessorSetterCallback setter = 0,
                       Handle<Value> data = Handle<Value>(),
                       AccessControl settings = DEFAULT,
                       PropertyAttribute attribute = None,
                       Handle<AccessorSignature> signature =
                           Handle<AccessorSignature>());

void SetAccessorProperty(Handle<String> name,
                         Handle<FunctionTemplate> getter,
                         Handle<FunctionTemplate> setter =
                             Handle<FunctionTemplate>(),
                         AccessControl settings = DEFAULT,
                         PropertyAttribute attribute = None);

+                         AccessorGetterCallback getter,
+                         AccessorSetterCallback setter = 0,
+                         Handle<Value> data = Handle<Value>(),
+                         AccessControl settings = DEFAULT,
+                         PropertyAttribute attribute = None,
+                         Handle<AccessorSignature> signature =
+                             Handle<AccessorSignature>());
+
+  // This function is not yet stable and should not be used at this time.
+  bool SetDeclaredAccessor(Handle<String> name,
+                           Handle<DeclaredAccessorDescriptor> descriptor,
+                           AccessControl settings = DEFAULT,
+                           PropertyAttribute attribute = None,
+                           Handle<AccessorSignature> signature =
+                               Handle<AccessorSignature>());
+
  private:
   Template();
 
   friend class ObjectTemplate;
   friend class FunctionTemplate;
 };
 
 
 template<typename T>
 class ReturnValue {
@@ skipping 496 matching lines @@
                                      Handle<AccessorSignature>()));
   void SetAccessor(Handle<String> name,
                    AccessorGetterCallback getter,
                    AccessorSetterCallback setter = 0,
                    Handle<Value> data = Handle<Value>(),
                    AccessControl settings = DEFAULT,
                    PropertyAttribute attribute = None,
                    Handle<AccessorSignature> signature =
                        Handle<AccessorSignature>());
 
-  // This function is not yet stable and should not be used at this time.
-  bool SetAccessor(Handle<String> name,
-                   Handle<DeclaredAccessorDescriptor> descriptor,
-                   AccessControl settings = DEFAULT,
-                   PropertyAttribute attribute = None,
-                   Handle<AccessorSignature> signature =
-                       Handle<AccessorSignature>());
-
   /**
    * Sets a named property handler on the object template.
    *
    * Whenever a named property is accessed on objects created from
    * this object template, the provided callback is invoked instead of
    * accessing the property directly on the JavaScript object.
    *
    * \param getter The callback to invoke when getting a property.
    * \param setter The callback to invoke when setting a property.
    * \param query The callback to invoke to check if a property is present,
@@ skipping 3072 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_