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);
}