Item.h

Go to the documentation of this file.

/*
* Nirvana IDL front-end library.
*
* This is a part of the Nirvana project.
*
* Author: Igor Popov
*
* Copyright (c) 2021 Igor Popov.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 Lesser General Public
* License along with this library.  If not, see <http://www.gnu.org/licenses/>.
*
* Send comments and/or bug reports to:
*  popov.nirvana@gmail.com
*/
#ifndef IDLFE_AST_ITEM_H_
#define IDLFE_AST_ITEM_H_
#pragma once
 
#include <utility>
#include <assert.h>
 
namespace AST {
 
template <class T> class Ptr;
 
class Item
{
public:
    enum class Kind
    {
        ROOT, 
        INCLUDE, 
        NATIVE, 
        TYPE_DEF, 
        CONSTANT, 
        MODULE, 
        MODULE_ITEMS, 
        INTERFACE_DECL, 
        INTERFACE, 
        OPERATION, 
        PARAMETER, 
        ATTRIBUTE, 
        EXCEPTION, 
        STRUCT_DECL, 
        STRUCT, 
        MEMBER, 
        UNION_DECL, 
        UNION, 
        UNION_ELEMENT, 
        ENUM, 
        ENUM_ITEM, 
        VALUE_TYPE_DECL, 
        VALUE_TYPE, 
        VALUE_BOX, 
        STATE_MEMBER, 
        VALUE_FACTORY 
    };
 
    Kind kind () const noexcept
    {
        return kind_;
    }
 
    bool is_type () const noexcept;
 
    bool is_forward_decl () const noexcept;
 
protected:
    Item (Kind kind) :
        kind_ (kind),
        ref_cnt_ (1)
    {}
 
    Item (const Item& src) :
        kind_ (src.kind_),
        ref_cnt_ (1)
    {}
 
    virtual ~Item () {}
 
    Item& operator = (const Item& src)
    {
        assert (kind_ == src.kind_);
        return *this;
    }
 
private:
    template <class T> friend class Ptr;
 
    void* operator new (std::size_t cb)
    {
        return ::operator new (cb);
    }
 
    void _add_ref () const noexcept
    {
        ++ref_cnt_;
    }
 
    void _remove_ref () const noexcept
    {
        if (!--ref_cnt_)
            delete this;
    }
 
private:
    const Kind kind_;
    mutable unsigned ref_cnt_;
};
 
template <class T>
class Ptr
{
    template <class T1> friend class Ptr;
public:
    Ptr () noexcept :
        p_ (nullptr)
    {}
 
    template <class T1, class ... Args>
    static Ptr make (Args ... args)
    {
        return Ptr (new T1 (std::forward <Args> (args)...), Make ());
    }
 
    template <class T1>
    Ptr (const Ptr <T1>& src) noexcept :
        p_ (src.p_)
    {
        if (p_)
            p_->_add_ref ();
    }
    
    Ptr (const Ptr& src) noexcept :
        p_ (src.p_)
    {
        if (p_)
            p_->_add_ref ();
    }
 
    template <class T1>
    Ptr (Ptr <T1>&& src) noexcept :
        p_ (src.p_)
    {
        src.p_ = nullptr;
    }
 
    Ptr (Ptr&& src) noexcept :
        p_ (src.p_)
    {
        src.p_ = nullptr;
    }
 
    template <class T1>
    Ptr (T1* p) noexcept :
        p_ (p)
    {
        if (p_)
            p_->_add_ref ();
    }
 
    Ptr (T* p) noexcept :
        p_ (p)
    {
        if (p_)
            p_->_add_ref ();
    }
 
    ~Ptr () noexcept
    {
        if (p_)
            p_->_remove_ref ();
    }
 
    template <class T1>
    Ptr& operator = (const Ptr <T1>& src) noexcept
    {
        if (p_ != src.p_) {
            if (p_)
                p_->_remove_ref ();
            if ((p_ = src.p_))
                p_->_add_ref ();
        }
        return *this;
    }
 
    Ptr& operator = (const Ptr <T>& src) noexcept
    {
        if (p_ != src.p_) {
            if (p_)
                p_->_remove_ref ();
            if ((p_ = src.p_))
                p_->_add_ref ();
        }
        return *this;
    }
 
    template <class T1>
    Ptr& operator = (Ptr <T1>&& src) noexcept
    {
        if (p_ != src.p_) {
            if (p_)
                p_->_remove_ref ();
            p_ = src.p_;
            src.p_ = nullptr;
        }
        return *this;
    }
 
    Ptr& operator = (Ptr <T>&& src) noexcept
    {
        if (p_ != src.p_) {
            if (p_)
                p_->_remove_ref ();
            p_ = src.p_;
            src.p_ = nullptr;
        }
        return *this;
    }
 
    template <class T1>
    Ptr& operator = (T1* p) noexcept
    {
        if (p_ != p) {
            if (p_)
                p_->_remove_ref ();
            p_ = p;
        }
        return *this;
    }
 
    Ptr& operator = (T* p) noexcept
    {
        if (p_ != p) {
            if (p_)
                p_->_remove_ref ();
            p_ = p;
        }
        return *this;
    }
 
    Ptr& operator = (std::nullptr_t) noexcept
    {
        if (p_) {
            p_->_remove_ref ();
            p_ = nullptr;
        }
        return *this;
    }
 
    T* operator -> () const noexcept
    {
        assert (p_);
        return p_;
    }
 
    operator T* () const noexcept
    {
        return p_;
    }
 
    T& operator * () const noexcept
    {
        assert (p_);
        return *p_;
    }
 
private:
    struct Make {};
 
    Ptr (T* p, const Make&) :
        p_ (p)
    {}
 
private:
    T* p_;
};
 
template <class T1, class T>
T1* scast (const Ptr <T>& ptr) noexcept
{
    return static_cast <T1*> ((T*)ptr);
}
 
}
 
#endif