/*

 * 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 "Heap.h"

namespace jc {

class Zone;

template <typename T> class Local;

template <typename T> class ScopedRoot;

template <typename T>

class Handle

{

    T * const *thingp_;

  public:

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

        typeCheck<S>();

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

    }

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

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

  public:

    T *operator ->() {

        return *thingp_;

    }

    T *operator *() {

        return *thingp_;

    }

    operator T() { return *thingp_; }

    operator bool() const {

        return thingp_ && *thingp_;

    }

    T **addr() const {

        return thingp_;

    }

  private:

    template <typename S>

    void typeCheck() {

#ifdef DEBUG

        T *v1 = NULL;

        S *v2 = NULL;

        v1 = v2;

        (void)v1;

#endif

    }

};

template <typename T>

class Local

{

    friend class Zone;

    Zone *zone_;

    Local<Object> *prev_;

    T *thing_;

    Local<Object> *prev() {

        return prev_;

    }

    Local<Object> *toRaw() {

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

    }

  public:

    inline explicit Local(Zone *zone);

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

    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_;

    }

    Object **addr() {

        return (Object **)&thing_;

    }

    Object * const *addr() const {

        return (Object * const *)&thing_;

    }

    operator T *() {

        return thing_;

    }

  private:

    // Disallow heap allocation.

    void *operator new(size_t size);

    void *operator new[](size_t size);

    // Disallow copy construction.

    Local(const Local<T> &other);

    Local &operator =(const Local &other);

};

template <typename T> template <typename S> inline

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

{

    typeCheck<S>();

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

}

}

#endif // _include_jitcraft_rooting_h_