by::binder 클래스 참조

Generalized binding class for managing instance lifecycles 더 자세히 ...

#include <binder.hpp>

by::binder에 대한 상속 다이어그램 :

Public 멤버 함수
	binder (const type &type, bindTacticable &tactic)
	Constructs a binder with a specific type and binding tactic.
	binder (const me &rhs)
instance *	operator-> ()
	Dereference operator to access bound instance
const instance *	operator-> () const BY_CONST_FUNC(operator->()) instance &operator*()
const instance &	operator* () const BY_CONST_FUNC(operator*()) me &operator
	Assigns another binder's bound instance to this binder.
id	getItsId () const
	Retrieves the unique ID of the instance currently bound by this binder.
nbool	isBind () const override
void	rel () override
nbool	canBind (const type &it) const override
	Checks if given type can be bound to this binder
nbool	bind (const instance &it) override
	Binds instance to this binder with reference counting
instance *	get ()
const instance *	get () const BY_CONST_FUNC(get()) template< typename E > E *get()
template<typename E >
const E *	get () const BY_CONST_FUNC(get< E >()) const type &getType() const override
void *	cast (const type &to) override
nbool	canBind (const T &it) const
nbool	canBind (const T *it) const BY_SIDE_FUNC(canBind)
virtual nbool	canBind (const type &it) const=0
nbool	canBind (const type *it) const BY_SIDE_FUNC(canBind)
virtual nbool	bind (const T &it)
nbool	bind (const T *it)
	Bind to instance pointer
template<typename T >
T *	cast ()
template<typename T >
const T *	cast () const BY_CONST_FUNC(cast< T >()) virtual void *cast(const type &to)
	Safe cast to target type using type hierarchy information
const void *	cast (const type &to) const BY_CONST_FUNC(cast(to)) void *cast(const type *it) BY_SIDE_FUNC(cast)
by::typeProvidable(으)로부터 상속된 Public 멤버 함수
nbool	operator== (const me &rhs) const
nbool	operator!= (const me &rhs) const
virtual const type &	getType () const =0
nbool	isSub (const type &it) const
nbool	isSub (const type *it) const BY_SIDE_FUNC(isSub)
nbool	isSub (const me &it) const
nbool	isSub (const me *it) const BY_SIDE_FUNC(isSub)
nbool	isSuper (const type &it) const
nbool	isSuper (const type *it) const BY_SIDE_FUNC(isSuper)
nbool	isSuper (const me &it) const
nbool	isSuper (const me *it) const BY_SIDE_FUNC(isSuper)
template<typename T >
nint	isSub () const
template<typename T >
nint	isSuper () const
template<typename T >
T *	cast ()
template<typename T >
const T *	cast () const BY_CONST_FUNC(cast< T >()) virtual void *cast(const type &to)
	Safe cast to target type using type hierarchy information
const void *	cast (const type &to) const BY_CONST_FUNC(cast(to)) void *cast(const type *it) BY_SIDE_FUNC(cast)
by::tbindable< instance >(으)로부터 상속된 Public 멤버 함수
	operator nbool () const
nbool	bind (const instance *it)
	Bind to instance pointer
nbool	canBind (const instance &it) const
nbool	canBind (const instance *it) const BY_SIDE_FUNC(canBind)
nbool	canBind (const type *it) const BY_SIDE_FUNC(canBind)

Protected 멤버 함수
nbool	_assign (const binder &rhs)
	Assigns binder from another binder
nbool	_onSame (const typeProvidable &rhs) const override
	Checks if two typeProvidable objects are same instance
life *	_getBindTag () const
	Retrieves life object associated with bound instance

Protected 속성
id	_itsId
const type *	_type
bindTacticable *	_tactic

Friends
struct	::binderTest

상세한 설명

Generalized binding class for managing instance lifecycles

Can bind any object inheriting from instance. Uses reference counting to properly destroy objects at appropriate times. Similar to std::weak_ptr and std::shared_ptr, with tweak handling weak pointers and tstr handling strong pointers.

Usage

Basic usage with bind(), isBind(), and get():

class A : public instance {}; // Inherits instance, so bindable
A* a = new A();
 
{
    tstr<A> strBinder;
    strBinder.bind(a);
    // a's life count becomes 1
 
    strBinder.isBind(); // true
    a == strBinder.get(); // true
} // strBinder destroys, life count becomes 0, a automatically destroyed
 
*a; // Error: using destroyed object

More concise real-world usage:

class shell : public instance {
public:
    int age;
};
 
tstr<shell> foo() {
    tstr<shell> ptr(new shell()); // Create and bind simultaneously
    ptr->age = 57; // Supports operator->
 
    tweak<shell> weak = ptr; // Binders can be compatible
    callShell(*weak); // Supports operator* too
 
    return ptr; // Returns by value, count maintained
                // shell object created with new won't be destroyed
}

Why not use shared_ptr?

Several advantages over shared_ptr:

1. Reference counting block attached to instance itself
   • shared_ptr creates a "Control block" on the heap for reference counting. This makes the following dangerous:

     Foo* raw = new Foo();
     shared_ptr<Foo> foo1(raw);
     shared_ptr<Foo> foo2(raw); // Separate control blocks -> double delete

   • memlite uses life class for reference counting, assigned per instance by watcher. No double deletion problem.
2. Provides ADT (Abstract Data Type)
   • tstr and tweak share same binder base, enabling generic logic:

     void me::rel(binder& me) { // Works for both tstr and tweak
         WHEN(!me.isBind()) .ret();
         life* l = me._getBindTag();
         if(l) l->_onStrong(-1);
     }

3. Dynamic type checking
   • binder is ADT and not even a class template. bind() parameter is instance type. tstr allows bind(new B()); without compile error. bind() uses meta module for dynamic type checking, binding only when types match.

Remarks

Abstract nature binder is abstract, so cannot create objects. Only meaningful for generic logic using already created tstr or tweak binders.

Custom memory pool

Ultimate goal of memlite is lightweight C++ memory management for byeol runtime environment. Requires GC and additional memory management, implying custom memory pool and instance lifecycle management. All instance allocation starts with instancer.

Performance improvements

shared_ptr's algorithm stores reference counting info on heap. Using faster custom memory pool instead of heap and optimizing binding speed provides performance gains. Binding is one of the hotspots consuming most performance in byeol.

Additional information

shared_ptr creates objects on heap for reference counting. memlite uses watcher to lend empty life objects from pre-allocated memory, using them as reference counting space for instances. If GC features are added later, instances may require additional lifecycle information. Unlike shared_ptr, managing each instance's lifecycle information internally allows appropriate handling of such requirements.

생성자 & 소멸자 문서화

binder()

by::binder::binder	(	const type &	type,
		bindTacticable &	tactic )

Constructs a binder with a specific type and binding tactic.

매개변수

type	The type of the instance this binder will manage.
tactic	The binding tactic (e.g., strong or weak) to use for reference counting.

멤버 함수 문서화

_assign()

nbool by::binder::_assign ( const binder & rhs )

protected

Assigns binder from another binder

반환값

true on success, false on failure

주의

Handles reference counting via tactic when copying bindings

_getBindTag()

life * by::binder::_getBindTag ( ) const

protected

Retrieves life object associated with bound instance

반환값

Pointer to life object, or nullptr if not bound

주의

Internal accessor for reference counting operations

_onSame()

nbool by::binder::_onSame ( const typeProvidable & rhs ) const

overrideprotected

Checks if two typeProvidable objects are same instance

반환값

true if same object, false otherwise

주의

Overrides typeProvidable for binder-specific equality

bind() [1/2]

nbool by::binder::bind ( const instance & it )

overridevirtual

Binds instance to this binder with reference counting

반환값

true on success, false if type mismatch or binding fails

주의

Increases reference count. Type must match via canBind() check.

by::tbindable< instance >(으)로부터 재구현되었습니다.

bind() [2/2]

nbool by::tbindable< T >::bind

(

const T *

it

)

Bind to instance pointer

binder will loose previous binding instance whether given parameter it isn't nullptr or not.

canBind() [1/2]

nbool by::binder::canBind ( const type & it ) const

overridevirtual

Checks if given type can be bound to this binder

반환값

true if type matches or is subtype of binder's type, false otherwise

주의

Uses meta module for dynamic type checking

by::tbindable< instance >를 구현.

canBind() [2/2]

virtual nbool by::tbindable< T >::canBind ( const type & it ) const

virtual

by::tbindable< instance >를 구현.

cast()

template<typename T >

const T * by::typeProvidable::cast

(

)

const &

Safe cast to target type using type hierarchy information

반환값

Pointer to object if cast is valid, nullptr otherwise

주의

Uses O(1) tier algorithm instead of slow dynamic_cast

getItsId()

id by::binder::getItsId

(

)

const

Retrieves the unique ID of the instance currently bound by this binder.

반환값

The ID of the bound instance. Returns an invalid ID if no instance is bound.

isBind()

nbool by::binder::isBind ( ) const

overridevirtual

by::tbindable< instance >를 구현.

operator*()

const instance & by::binder::operator*

(

)

const &

Assigns another binder's bound instance to this binder.

This operator handles the transfer of binding, ensuring proper reference counting adjustments for both the source and target binders.

매개변수

rhs	The binder to assign from.

반환값

A reference to this binder.

operator->()

instance * by::binder::operator->

(

)

Dereference operator to access bound instance

This follows the same policy as tmay and stl. that is, if the binder does not bind any instances and tries to dereference them with get() or operator*(), it will behave as UB. this is likely to crash.

rel()

void by::binder::rel ( )

overridevirtual

by::tbindable< instance >를 구현.

---

이 클래스에 대한 문서화 페이지는 다음의 파일들로부터 생성되었습니다.:

• /home/runner/work/byeol/byeol/module/memlite/binder/binder.hpp
• /home/runner/work/byeol/byeol/module/memlite/binder/binder.cpp