0
0
Fork 0
mirror of https://github.com/matrix-construct/construct synced 2024-10-31 10:58:54 +01:00
construct/include/ircd/js/object.h
2018-02-05 21:24:34 -08:00

411 lines
8.2 KiB
C++

// Matrix Construct
//
// Copyright (C) Matrix Construct Developers, Authors & Contributors
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice is present in all copies. The
// full license for this software is available in the LICENSE file.
#pragma once
#define HAVE_IRCD_JS_OBJECT_H
namespace ircd {
namespace js {
using object_handle = JS::Handle<JSObject *>;
using object_handle_mutable = JS::MutableHandle<JSObject *>;
// get()/set() et al overload on reserved{n} to manipulate reserved slot n
IRCD_STRONG_TYPEDEF(uint, reserved)
// Get the JSClass from which the trap can also be derived.
bool has_jsclass(const JSObject *const &);
const JSClass &jsclass(JSObject *const &);
// Get the flags from the object's JSClass or 0.
uint flags(const JSObject *const &);
// Get the `this` global from any object
JSObject *current_global(JSObject *const &);
// Misc utils
bool is_array(const object_handle &);
bool is_extensible(const object_handle &);
uint32_t size(const object_handle &);
bool deep_freeze(const object_handle &);
bool freeze(const object_handle &);
size_t bytecodes(const object_handle &, uint8_t *const &buf, const size_t &size);
struct object
:root<JSObject *>
{
IRCD_OVERLOAD(json)
IRCD_OVERLOAD(array)
IRCD_OVERLOAD(uninitialized)
using handle = object_handle;
using handle_mutable = object_handle_mutable;
explicit operator JSString *() const;
explicit operator JS::Value() const;
operator value() const;
object constructor() const; // Get the constructor
object prototype() const; // Get the prototype
void prototype(object::handle); // Set the prototype
bool is_array() const;
uint32_t size() const; // Number elements in array object
void resize(const uint32_t &); // Set the number of elements in array object
object clone() const; // Copy the object and prototype
// new object
object(const JSClass *const &, const handle &ctor, const JS::HandleValueArray &args);
object(const JSClass *const &, const JS::CallArgs &args);
object(const JSClass *const &, const object &proto);
object(const JSClass *const &);
object(const uint8_t *const &bytecode, const size_t &size);
using root<JSObject *>::root;
template<class... args> object(json_t, args&&...);
object(array_t, const size_t &length);
object(const JS::HandleValueArray &);
object(std::initializer_list<std::pair<const char *, value>>);
object(const value &);
object(JSObject *const &);
object(JSObject &);
object(nullptr_t);
object(uninitialized_t);
object();
static object global(); // current_global(cx)
};
inline
object::object()
:object::root::type
{
JS_NewPlainObject(*cx)
}
{
if(unlikely(!this->get()))
throw internal_error("NULL object (plain)");
}
inline
object::object(uninitialized_t)
:object::root::type{}
{
}
inline
object::object(nullptr_t)
:object{value{nullptr}}
{
}
inline
object::object(JSObject &obj)
:object::root::type{&obj}
{
if(unlikely(!this->get()))
throw internal_error("NULL object (ref)");
}
inline
object::object(JSObject *const &obj)
:object::root::type{obj}
{
if(unlikely(!this->get()))
throw internal_error("NULL object");
}
inline
object::object(const value &val)
:object::root::type{}
{
if(!JS_ValueToObject(*cx, val, &(*this)))
throw type_error("Value is not an Object");
}
inline
object::object(std::initializer_list<std::pair<const char *, value>> list)
:object{}
{
for(const auto &pair : list)
{
const auto &key(pair.first);
const auto &val(pair.second);
if(!JS_SetProperty(*cx, *this, key, val))
throw jserror(jserror::pending);
}
}
inline
object::object(const JS::HandleValueArray &values)
:object::root::type
{
JS_NewArrayObject(*cx, values)
}
{
if(unlikely(!this->get()))
throw internal_error("NULL object (array)");
}
inline
object::object(array_t,
const size_t &length)
:object::root::type
{
JS_NewArrayObject(*cx, length)
}
{
if(unlikely(!this->get()))
throw internal_error("NULL object (array)");
}
template<class... args>
object::object(json_t,
args&&... a)
:object(js::json::parse(std::forward<args>(a)...))
{
}
inline
object::object(const JSClass *const &clasp)
:object::root::type
{
JS_NewObject(*cx, clasp)
}
{
if(unlikely(!this->get()))
throw internal_error("NULL object (clasp)");
}
inline
object::object(const JSClass *const &clasp,
const object &proto)
:object::root::type
{
JS_NewObjectWithGivenProto(*cx, clasp, proto)
}
{
if(unlikely(!this->get()))
throw internal_error("NULL object (with given proto)");
}
inline
object::object(const JSClass *const &clasp,
const JS::CallArgs &args)
:object::root::type
{
JS_NewObjectForConstructor(*cx, clasp, args)
}
{
if(unlikely(!this->get()))
throw internal_error("NULL object (for constructor)");
}
inline
object::object(const JSClass *const &clasp,
const object::handle &ctor,
const JS::HandleValueArray &args)
:object::root::type
{
JS_New(*cx, ctor, args)
}
{
if(unlikely(!this->get()))
throw internal_error("NULL object (new)");
}
inline
object::object(const uint8_t *const &bytecode,
const size_t &size)
:object::root::type
{
//JS_DecodeInterpretedFunction(*cx, bytecode, size)
}
{
if(unlikely(!this->get()))
throw jserror(jserror::pending);
}
inline object
object::global()
{
return current_global();
}
inline object
object::clone()
const
{
return JS_CloneObject(*cx, *this, prototype());
}
inline void
object::resize(const uint32_t &length)
{
if(!JS_SetArrayLength(*cx, *this, length))
throw internal_error("Failed to set array object length");
}
inline uint32_t
object::size()
const
{
return js::size(*this);
}
inline bool
object::is_array()
const
{
return js::is_array(handle(*this));
}
inline object
object::constructor()
const
{
return JS_GetConstructor(*cx, *this);
}
inline void
object::prototype(object::handle obj)
{
if(!JS_SetPrototype(*cx, *this, obj))
throw internal_error("Failed to set prototype for object");
}
inline object
object::prototype()
const
{
object ret;
if(!JS_GetPrototype(*cx, *this, &ret))
throw internal_error("Failed to get prototype for object");
return ret;
}
inline
object::operator value()
const
{
return static_cast<JS::Value>(*this);
}
inline
object::operator JS::Value()
const
{
assert(this->get());
return JS::ObjectValue(*this->get());
}
inline
object::operator JSString *()
const
{
assert(this->get());
return JS_BasicObjectToString(*cx, *this);
}
inline size_t
bytecodes(const object_handle &obj,
uint8_t *const &buf,
const size_t &size)
{
uint32_t ret;
const custom_ptr<void> ptr
{
//JS_EncodeInterpretedFunction(*cx, obj, &ret), js_free
};
const auto cpsz(std::min(size_t(ret), size));
memcpy(buf, ptr.get(), cpsz);
return cpsz;
}
inline bool
freeze(const object_handle &obj)
{
return JS_FreezeObject(*cx, obj);
}
inline bool
deep_freeze(const object_handle &obj)
{
return JS_DeepFreezeObject(*cx, obj);
}
inline uint32_t
size(const object_handle &obj)
{
uint32_t ret;
if(!JS_GetArrayLength(*cx, obj, &ret))
throw internal_error("Failed to get array object length");
return ret;
}
inline bool
is_array(const object &obj)
{
return is_array(object::handle(obj));
}
inline bool
is_array(const object_handle &obj)
{
bool ret;
if(!JS_IsArrayObject(*cx, obj, &ret))
throw internal_error("Failed to query if object is array");
return ret;
}
inline bool
is_extensible(const object_handle &obj)
{
bool ret;
if(!JS_IsExtensible(*cx, obj, &ret))
throw internal_error("Failed to query object extensibility");
return ret;
}
inline JSObject *
current_global(JSObject *const &obj)
{
return JS_GetGlobalForObject(*cx, obj);
}
inline uint
flags(const JSObject *const &obj)
{
return has_jsclass(obj)? jsclass(const_cast<JSObject *>(obj)).flags : 0;
}
inline const JSClass &
jsclass(JSObject *const &obj)
{
assert(has_jsclass(obj));
const auto jsc(JS_GetClass(obj));
return *const_cast<JSClass *>(jsc);
}
inline bool
has_jsclass(const JSObject *const &obj)
{
assert(obj);
return JS_GetClass(const_cast<JSObject *>(obj)) != nullptr;
}
} // namespace js
} // namespace ircd