/* vim: set ts=4 sw=4 tw=99 et:

 *

 * Copyright (C) 2012 David Anderson

 *

 * This file is part of JITCraft.

 *

 * JITCraft is free software: you can redistribute it and/or modify it under

 * the terms of the GNU General Public License as published by the Free

 * Software Foundation, either version 3 of the License, or (at your option)

 * any later version.

 * 

 * Foobar is distributed in the hope that it will be useful, but WITHOUT ANY

 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * JITCraft. If not, see http://www.gnu.org/licenses/.

 */

#ifndef _include_jitcraft_rooting_h_

#define _include_jitcraft_rooting_h_

#include <stdlib.h>

#include "PoolAllocator.h"

namespace ke {

class Zone;

class Object;

template <typename T> class Local;

template <typename T> class ScopedRoot;

struct NullAddress

{

    static void * const Sentinel;

};

/*

 * Internal handles work differently from API handles. An API handle is a

 * root, whereas as an internal handle points to a rooted location. This

 * subtle difference makes handles easy for embedders, but somewhat

 * cumbersome internally.

 */

template <typename T>

class Handle

{

    T * const *thingp_;

  private:

    Handle()

      : thingp_(reinterpret_cast<T * const *>(&NullAddress::Sentinel))

    {

    }

  public:

    Handle(const Handle &other) {

        thingp_ = other.address();

    }

    template <typename S> Handle(const Handle<S> &handle) {

        typeCheck<S>();

        thingp_ = reinterpret_cast<T * const *>(handle.address());

    }

    template <typename S> inline Handle(const Local<S> &local);

    template <typename S> inline Handle(const ScopedRoot<S> &root);

    static inline Handle Null() {

        return Handle();

    }

  public:

    T *operator ->() {

        return *thingp_;

    }

    T *operator *() {

        return *thingp_;

    }

    operator T *() const { return *thingp_; }

    operator bool() const {

        return thingp_ && *thingp_;

    }

    T * const *address() const {

        return thingp_;

    }

    bool operator ==(const Handle<T> &other) const {

        return (!thingp_ && !other.thingp_) ||

               *thingp_ == *other.thingp_;

    }

    bool operator !=(const Handle<T> &other) const {

        return (!thingp_ != !other.thingp_) ||

               *thingp_ != *other.thingp_;

    }

  private:

    template <typename S>

    void typeCheck() {

#ifndef NDEBUG

        T *v1 = NULL;

        S *v2 = NULL;

        v1 = v2;

        (void)v1;

#endif

    }

};

template <typename T>

class Local

{

    friend class Zone;

    Zone *zone_;

    T *thing_;

    Local<Object> *prev_;

    Local<Object> *prev() {

        return prev_;

    }

    Local<Object> *toRaw() {

        return reinterpret_cast<Local<Object>*>(this);

    }

  public:

    // These are implemented in Zone.h.

    inline explicit Local(Zone *zone, T *thing = NULL);

    inline ~Local();

    const Local &operator =(T *thing) {

        thing_ = thing;

        return *this;

    }

    T *operator ->() const {

        return operator *();

    }

    T *operator *() const {

        return thing_;

    }

    operator bool () const {

        return !!thing_;

    }

    bool operator !=(const Local &other) {

        return thing_ != other.thing_;

    }

    T **address() {

        return (T **)&thing_;

    }

    T * const *address() const {

        return (T * const *)&thing_;

    }

    T **ref() {

        return &thing_;

    }

    operator T *() {

        return thing_;

    }

    Local &operator =(const Local &other) {

        thing_ = other.thing_;

        return *this;

    }

  private:

    // Disallow heap allocation.

    void *operator new(size_t size);

    void *operator new[](size_t size);

    // Disallow copy construction.

    Local(const Local<T> &other);

};

// A ScopedRoot is a special kind of handle for storing references on the

// heap in bulk.

template <typename T>

class ScopedRoot : public PoolObject

{

    T **thingp_;

  private:

    // This is implemented in Zone.h.

    inline T **make(T *other);

    void assign(T *other) {

        *thingp_ = other;

    }

  public:

    ScopedRoot();

    // This is implemented in Zone.h.

    inline ScopedRoot(T *thing);

    ScopedRoot &operator =(const ScopedRoot<T> &other) {

        assign(*other);

        return *this;

    }

    ScopedRoot &operator =(T *other) {

        assign(other);

        return *this;

    }

    T *operator ->() const {

        return operator *();

    }

    T *operator *() const {

        return *thingp_;

    }

    operator T *() const {

        return *thingp_;

    }

    operator bool () const {

        return !!*thingp_;

    }

    T **address() const {

        return thingp_;

    }

};

template <typename T> template <typename S> inline

Handle<T>::Handle(const Local<S> &local)

{

    typeCheck<S>();

    thingp_ = reinterpret_cast<T * const *>(local.address());

}

template <typename T> template <typename S> inline

Handle<T>::Handle(const ScopedRoot<S> &root)

{

    typeCheck<S>();

    thingp_ = reinterpret_cast<T * const *>(root.address());

}

}

#endif // _include_jitcraft_rooting_h_