0
0
Fork 0
mirror of https://github.com/matrix-construct/construct synced 2024-12-25 15:04:10 +01:00
construct/include/ircd/js/root.h
2018-02-05 21:24:34 -08:00

151 lines
3.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_ROOT_H
namespace ircd {
namespace js {
template<class T>
using handle = typename T::handle;
// This conversion is missing in the jsapi. Is this object not gc rooted? Can it not have a handle?
template<class T>
JS::Handle<T>
operator&(const JS::Heap<T> &h)
{
return JS::Handle<T>::fromMarkedLocation(h.address());
}
// This conversion is missing in the jsapi. Is this object not gc rooted? Can it not have a handle?
template<class T>
JS::MutableHandle<T>
operator&(JS::Heap<T> &h)
{
const auto ptr(const_cast<T *>(h.address()));
return JS::MutableHandle<T>::fromMarkedLocation(ptr);
}
// This conversion is missing in the jsapi. Is this object not gc rooted? Can it not have a handle?
template<class T>
JS::Handle<T>
operator&(const JS::TenuredHeap<T> &h)
{
return JS::Handle<T>::fromMarkedLocation(h.address());
}
// This conversion is missing in the jsapi. Is this object not gc rooted? Can it not have a handle?
template<class T>
JS::MutableHandle<T>
operator&(JS::TenuredHeap<T> &h)
{
const auto ptr(const_cast<T *>(h.address()));
return JS::MutableHandle<T>::fromMarkedLocation(ptr);
}
template<class T>
struct root
:JS::Heap<T>
{
using value_type = T;
using base_type = JS::Heap<T>;
using handle = JS::Handle<T>;
using handle_mutable = JS::MutableHandle<T>;
using type = root<value_type>;
operator handle() const
{
const auto ptr(this->address());
return JS::Handle<T>::fromMarkedLocation(ptr);
}
operator handle_mutable()
{
const auto ptr(this->address());
return JS::MutableHandle<T>::fromMarkedLocation(ptr);
}
private:
tracing::list::iterator tracing_it;
tracing::list::iterator add(base_type *const &ptr)
{
return cx->tracing.heap.emplace(end(cx->tracing.heap), tracing::thing { ptr, js::type<T>() });
}
void del(const tracing::list::iterator &tracing_it)
{
if(tracing_it != end(cx->tracing.heap))
{
const void *ptr = tracing_it->ptr;
cx->tracing.heap.erase(tracing_it);
}
}
public:
root(const handle &h)
:base_type{h.get()}
,tracing_it{add(this)}
{
}
root(const handle_mutable &h)
:base_type{h.get()}
,tracing_it{add(this)}
{
}
explicit root(const T &t)
:base_type{t}
,tracing_it{add(this)}
{
}
root()
:base_type{}
,tracing_it{add(this)}
{
}
root(root &&other) noexcept
:base_type{other.get()}
,tracing_it{std::move(other.tracing_it)}
{
other.tracing_it = end(cx->tracing.heap);
tracing_it->ptr = static_cast<base_type *>(this);
}
root(const root &other)
:base_type{other.get()}
,tracing_it{add(this)}
{
}
root &operator=(root &&other) noexcept
{
base_type::operator=(std::move(other.get()));
return *this;
}
root &operator=(const root &other)
{
base_type::operator=(other.get());
return *this;
}
~root() noexcept
{
del(tracing_it);
}
};
} // namespace js
} // namespace ircd