148 lines
3.5 KiB
C++
148 lines
3.5 KiB
C++
/*
|
|
* moocpp/gobjrawptr.h
|
|
*
|
|
* Copyright (C) 2004-2016 by Yevgen Muntyan <emuntyan@users.sourceforge.net>
|
|
*
|
|
* This file is part of medit. medit 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 2.1 of the License,
|
|
* or (at your option) any later version.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with medit. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "moocpp/gobjref.h"
|
|
|
|
namespace moo {
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// gobj_raw_ptr
|
|
//
|
|
|
|
template<typename Object>
|
|
class gobj_raw_ptr
|
|
{
|
|
using ref_type = gobj_ref<Object>;
|
|
|
|
public:
|
|
gobj_raw_ptr(Object* obj = nullptr) { m_ref._set_gobj(obj); }
|
|
|
|
operator Object*() const { return gobj(); }
|
|
operator GTypeInstance*() const { return reinterpret_cast<GTypeInstance*>(gobj()); }
|
|
operator gpointer() const { return gobj(); }
|
|
operator gobj_ref<Object>*() const { return m_ref.self(); }
|
|
|
|
ref_type* operator->() const { return m_ref.self(); }
|
|
ref_type& operator*() const { return m_ref; }
|
|
|
|
Object* gobj() const { return m_ref.gobj(); }
|
|
void set(Object* p) { m_ref._set_gobj(p); }
|
|
|
|
template<typename Super>
|
|
Super* gobj() const
|
|
{
|
|
return gobj_is_subclass<Object, Super>::down_cast(m_ref.gobj());
|
|
}
|
|
|
|
template<typename Subclass>
|
|
void set(Subclass* p)
|
|
{
|
|
set(gobj_is_subclass<Subclass, Object>::down_cast(p));
|
|
}
|
|
|
|
operator bool() const { return gobj() != nullptr; }
|
|
bool operator!() const { return gobj() == nullptr; }
|
|
|
|
gobj_raw_ptr(const gobj_raw_ptr& other) = default;
|
|
gobj_raw_ptr& operator=(const gobj_raw_ptr& other) = default;
|
|
|
|
gobj_raw_ptr(gobj_raw_ptr&& other)
|
|
: m_ref(std::move(other.m_ref))
|
|
{
|
|
other.set(nullptr);
|
|
}
|
|
|
|
gobj_raw_ptr& operator=(gobj_raw_ptr&& other)
|
|
{
|
|
m_ref = std::move(other.m_ref);
|
|
return *this;
|
|
}
|
|
|
|
template<typename T>
|
|
gobj_raw_ptr& operator=(T* p)
|
|
{
|
|
set(p);
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
mutable gobj_ref<Object> m_ref;
|
|
};
|
|
|
|
} // namespace moo
|
|
|
|
template<typename X>
|
|
inline bool operator==(const moo::gobj_raw_ptr<X>& p, const nullptr_t&)
|
|
{
|
|
return p.gobj() == nullptr;
|
|
}
|
|
|
|
template<typename X>
|
|
inline bool operator==(const nullptr_t&, const moo::gobj_raw_ptr<X>& p)
|
|
{
|
|
return p.gobj() == nullptr;
|
|
}
|
|
|
|
template<typename X>
|
|
inline bool operator==(const moo::gobj_raw_ptr<X>& p1, const moo::gobj_raw_ptr<X>& p2)
|
|
{
|
|
return p1.gobj() == p2.gobj();
|
|
}
|
|
|
|
template<typename X>
|
|
inline bool operator==(const moo::gobj_raw_ptr<X>& p1, const X* p2)
|
|
{
|
|
return p1.gobj() == p2;
|
|
}
|
|
|
|
template<typename X>
|
|
inline bool operator==(const moo::gobj_raw_ptr<X>& p1, X* p2)
|
|
{
|
|
return p1.gobj() == p2;
|
|
}
|
|
|
|
template<typename X>
|
|
inline bool operator==(const X* p1, const moo::gobj_raw_ptr<X>& p2)
|
|
{
|
|
return p1 == p2.gobj();
|
|
}
|
|
|
|
template<typename X>
|
|
inline bool operator==(X* p1, const moo::gobj_raw_ptr<X>& p2)
|
|
{
|
|
return p1 == p2.gobj();
|
|
}
|
|
|
|
template<typename X>
|
|
bool operator!=(const moo::gobj_raw_ptr<X>& p1, const moo::gobj_raw_ptr<X>& p2)
|
|
{
|
|
return !(p1 == p2);
|
|
}
|
|
|
|
template<typename X, typename Y>
|
|
bool operator!=(const moo::gobj_raw_ptr<X>& p1, const Y& p2)
|
|
{
|
|
return !(p1 == p2);
|
|
}
|
|
|
|
template<typename X, typename Y>
|
|
bool operator!=(const X& p1, const moo::gobj_raw_ptr<Y>& p2)
|
|
{
|
|
return !(p1 == p2);
|
|
}
|