private int get(cef_v8accessor_t* self, cef_string_t* name, cef_v8value_t* @object, cef_v8value_t** retval, cef_string_t* exception)
        {
            CheckSelf(self);

            var m_name = cef_string_t.ToString(name);
            var m_obj = CefV8Value.FromNative(@object);
            CefV8Value m_returnValue;
            string mException;

            var handled = Get(m_name, m_obj, out m_returnValue, out mException);

            if (handled)
            {
                if (mException != null)
                {
                    cef_string_t.Copy(mException, exception);
                }
                else if (m_returnValue != null)
                {
                    *retval = m_returnValue.ToNative();
                }
            }

            return handled ? 1 : 0;
        }
        private int set(cef_v8accessor_t* self, cef_string_t* name, cef_v8value_t* @object, cef_v8value_t* value, cef_string_t* exception)
        {
            CheckSelf(self);

            var m_name = cef_string_t.ToString(name);
            var m_obj = CefV8Value.FromNative(@object);
            var m_value = CefV8Value.FromNative(value);
            string mException;

            var handled = this.Set(m_name, m_obj, m_value, out mException);

            if (handled)
            {
                if (mException != null)
                {
                    cef_string_t.Copy(mException, exception);
                }
            }

            return handled ? 1 : 0;
        }
        private int execute(cef_v8handler_t* self, cef_string_t* name, cef_v8value_t* @object, UIntPtr argumentsCount, cef_v8value_t** arguments, cef_v8value_t** retval, cef_string_t* exception)
        {
            CheckSelf(self);

            var m_name = cef_string_t.ToString(name);
            var m_obj = CefV8Value.FromNative(@object);
            var argc = (int)argumentsCount;
            CefV8Value[] m_arguments;
            if (argc == 0) { m_arguments = emtpyArgs; }
            else
            {
                m_arguments = new CefV8Value[argc];
                for (var i = 0; i < argc; i++)
                {
                    m_arguments[i] = CefV8Value.FromNative(arguments[i]);
                }
            }

            CefV8Value m_returnValue;
            string m_exception;

            var handled = Execute(m_name, m_obj, m_arguments, out m_returnValue, out m_exception);

            if (handled)
            {
                if (m_exception != null)
                {
                    cef_string_t.Copy(m_exception, exception);
                }
                else if (m_returnValue != null)
                {
                    *retval = m_returnValue.ToNative();
                }
            }

            return handled ? 1 : 0;
        }
 public static int set_value_byindex(cef_v8value_t* self, int index, cef_v8value_t* value)
 {
     set_value_byindex_delegate d;
     var p = self->_set_value_byindex;
     if (p == _p23) { d = _d23; }
     else
     {
         d = (set_value_byindex_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_value_byindex_delegate));
         if (_p23 == IntPtr.Zero) { _d23 = d; _p23 = p; }
     }
     return d(self, index, value);
 }
 public static cef_v8value_t* get_value_byindex(cef_v8value_t* self, int index)
 {
     get_value_byindex_delegate d;
     var p = self->_get_value_byindex;
     if (p == _p21) { d = _d21; }
     else
     {
         d = (get_value_byindex_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_value_byindex_delegate));
         if (_p21 == IntPtr.Zero) { _d21 = d; _p21 = p; }
     }
     return d(self, index);
 }
 public static int delete_value_byindex(cef_v8value_t* self, int index)
 {
     delete_value_byindex_delegate d;
     var p = self->_delete_value_byindex;
     if (p == _p1f) { d = _d1f; }
     else
     {
         d = (delete_value_byindex_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(delete_value_byindex_delegate));
         if (_p1f == IntPtr.Zero) { _d1f = d; _p1f = p; }
     }
     return d(self, index);
 }
 public static int has_value_byindex(cef_v8value_t* self, int index)
 {
     has_value_byindex_delegate d;
     var p = self->_has_value_byindex;
     if (p == _p1d) { d = _d1d; }
     else
     {
         d = (has_value_byindex_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(has_value_byindex_delegate));
         if (_p1d == IntPtr.Zero) { _d1d = d; _p1d = p; }
     }
     return d(self, index);
 }
 public static int will_rethrow_exceptions(cef_v8value_t* self)
 {
     will_rethrow_exceptions_delegate d;
     var p = self->_will_rethrow_exceptions;
     if (p == _p1a) { d = _d1a; }
     else
     {
         d = (will_rethrow_exceptions_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(will_rethrow_exceptions_delegate));
         if (_p1a == IntPtr.Zero) { _d1a = d; _p1a = p; }
     }
     return d(self);
 }
 public static cef_v8exception_t* get_exception(cef_v8value_t* self)
 {
     get_exception_delegate d;
     var p = self->_get_exception;
     if (p == _p18) { d = _d18; }
     else
     {
         d = (get_exception_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_exception_delegate));
         if (_p18 == IntPtr.Zero) { _d18 = d; _p18 = p; }
     }
     return d(self);
 }
 public static int is_string(cef_v8value_t* self)
 {
     is_string_delegate d;
     var p = self->_is_string;
     if (p == _pb) { d = _db; }
     else
     {
         d = (is_string_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_string_delegate));
         if (_pb == IntPtr.Zero) { _db = d; _pb = p; }
     }
     return d(self);
 }
 public static int is_double(cef_v8value_t* self)
 {
     is_double_delegate d;
     var p = self->_is_double;
     if (p == _p9) { d = _d9; }
     else
     {
         d = (is_double_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_double_delegate));
         if (_p9 == IntPtr.Zero) { _d9 = d; _p9 = p; }
     }
     return d(self);
 }
 public static int is_null(cef_v8value_t* self)
 {
     is_null_delegate d;
     var p = self->_is_null;
     if (p == _p5) { d = _d5; }
     else
     {
         d = (is_null_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_null_delegate));
         if (_p5 == IntPtr.Zero) { _d5 = d; _p5 = p; }
     }
     return d(self);
 }
 public static int is_valid(cef_v8value_t* self)
 {
     is_valid_delegate d;
     var p = self->_is_valid;
     if (p == _p3) { d = _d3; }
     else
     {
         d = (is_valid_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_valid_delegate));
         if (_p3 == IntPtr.Zero) { _d3 = d; _p3 = p; }
     }
     return d(self);
 }
 public static int get_refct(cef_v8value_t* self)
 {
     get_refct_delegate d;
     var p = self->_base._get_refct;
     if (p == _p2) { d = _d2; }
     else
     {
         d = (get_refct_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_refct_delegate));
         if (_p2 == IntPtr.Zero) { _d2 = d; _p2 = p; }
     }
     return d(self);
 }
 public static int release(cef_v8value_t* self)
 {
     release_delegate d;
     var p = self->_base._release;
     if (p == _p1) { d = _d1; }
     else
     {
         d = (release_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(release_delegate));
         if (_p1 == IntPtr.Zero) { _d1 = d; _p1 = p; }
     }
     return d(self);
 }
 public static int is_user_created(cef_v8value_t* self)
 {
     is_user_created_delegate d;
     var p = self->_is_user_created;
     if (p == _p16) { d = _d16; }
     else
     {
         d = (is_user_created_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_user_created_delegate));
         if (_p16 == IntPtr.Zero) { _d16 = d; _p16 = p; }
     }
     return d(self);
 }
 public static int has_exception(cef_v8value_t* self)
 {
     has_exception_delegate d;
     var p = self->_has_exception;
     if (p == _p17) { d = _d17; }
     else
     {
         d = (has_exception_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(has_exception_delegate));
         if (_p17 == IntPtr.Zero) { _d17 = d; _p17 = p; }
     }
     return d(self);
 }
 public static int is_object(cef_v8value_t* self)
 {
     is_object_delegate d;
     var p = self->_is_object;
     if (p == _pc) { d = _dc; }
     else
     {
         d = (is_object_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_object_delegate));
         if (_pc == IntPtr.Zero) { _dc = d; _pc = p; }
     }
     return d(self);
 }
 public static int clear_exception(cef_v8value_t* self)
 {
     clear_exception_delegate d;
     var p = self->_clear_exception;
     if (p == _p19) { d = _d19; }
     else
     {
         d = (clear_exception_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(clear_exception_delegate));
         if (_p19 == IntPtr.Zero) { _d19 = d; _p19 = p; }
     }
     return d(self);
 }
 public static int is_array(cef_v8value_t* self)
 {
     is_array_delegate d;
     var p = self->_is_array;
     if (p == _pd) { d = _dd; }
     else
     {
         d = (is_array_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_array_delegate));
         if (_pd == IntPtr.Zero) { _dd = d; _pd = p; }
     }
     return d(self);
 }
 public static int set_rethrow_exceptions(cef_v8value_t* self, int rethrow)
 {
     set_rethrow_exceptions_delegate d;
     var p = self->_set_rethrow_exceptions;
     if (p == _p1b) { d = _d1b; }
     else
     {
         d = (set_rethrow_exceptions_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_rethrow_exceptions_delegate));
         if (_p1b == IntPtr.Zero) { _d1b = d; _p1b = p; }
     }
     return d(self, rethrow);
 }
 public static int is_function(cef_v8value_t* self)
 {
     is_function_delegate d;
     var p = self->_is_function;
     if (p == _pe) { d = _de; }
     else
     {
         d = (is_function_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_function_delegate));
         if (_pe == IntPtr.Zero) { _de = d; _pe = p; }
     }
     return d(self);
 }
 public static int delete_value_bykey(cef_v8value_t* self, cef_string_t* key)
 {
     delete_value_bykey_delegate d;
     var p = self->_delete_value_bykey;
     if (p == _p1e) { d = _d1e; }
     else
     {
         d = (delete_value_bykey_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(delete_value_bykey_delegate));
         if (_p1e == IntPtr.Zero) { _d1e = d; _p1e = p; }
     }
     return d(self, key);
 }
 public static int is_same(cef_v8value_t* self, cef_v8value_t* that)
 {
     is_same_delegate d;
     var p = self->_is_same;
     if (p == _pf) { d = _df; }
     else
     {
         d = (is_same_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(is_same_delegate));
         if (_pf == IntPtr.Zero) { _df = d; _pf = p; }
     }
     return d(self, that);
 }
 public static cef_v8value_t* get_value_bykey(cef_v8value_t* self, cef_string_t* key)
 {
     get_value_bykey_delegate d;
     var p = self->_get_value_bykey;
     if (p == _p20) { d = _d20; }
     else
     {
         d = (get_value_bykey_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_value_bykey_delegate));
         if (_p20 == IntPtr.Zero) { _d20 = d; _p20 = p; }
     }
     return d(self, key);
 }
 public static int get_bool_value(cef_v8value_t* self)
 {
     get_bool_value_delegate d;
     var p = self->_get_bool_value;
     if (p == _p10) { d = _d10; }
     else
     {
         d = (get_bool_value_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_bool_value_delegate));
         if (_p10 == IntPtr.Zero) { _d10 = d; _p10 = p; }
     }
     return d(self);
 }
 public static int set_value_bykey(cef_v8value_t* self, cef_string_t* key, cef_v8value_t* value, CefV8PropertyAttribute attribute)
 {
     set_value_bykey_delegate d;
     var p = self->_set_value_bykey;
     if (p == _p22) { d = _d22; }
     else
     {
         d = (set_value_bykey_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(set_value_bykey_delegate));
         if (_p22 == IntPtr.Zero) { _d22 = d; _p22 = p; }
     }
     return d(self, key, value, attribute);
 }
 public static cef_time_t get_date_value(cef_v8value_t* self)
 {
     get_date_value_delegate d;
     var p = self->_get_date_value;
     if (p == _p14) { d = _d14; }
     else
     {
         d = (get_date_value_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_date_value_delegate));
         if (_p14 == IntPtr.Zero) { _d14 = d; _p14 = p; }
     }
     return d(self);
 }
 public static int eval(cef_v8context_t* self, cef_string_t* code, cef_v8value_t** retval, cef_v8exception_t** exception)
 {
     eval_delegate d;
     var p = self->_eval;
     if (p == _pb) { d = _db; }
     else
     {
         d = (eval_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(eval_delegate));
         if (_pb == IntPtr.Zero) { _db = d; _pb = p; }
     }
     return d(self, code, retval, exception);
 }
 public static cef_string_userfree* get_string_value(cef_v8value_t* self)
 {
     get_string_value_delegate d;
     var p = self->_get_string_value;
     if (p == _p15) { d = _d15; }
     else
     {
         d = (get_string_value_delegate)Marshal.GetDelegateForFunctionPointer(p, typeof(get_string_value_delegate));
         if (_p15 == IntPtr.Zero) { _d15 = d; _p15 = p; }
     }
     return d(self);
 }