game2006/server/gameserver/weakptr.cc

#include "precompile.h"
#include "weakptr.h"
#include "creature.h"
#include "roomobstacle.h"

CreatureWeakPtrChunk::CreatureWeakPtrChunk()
{
    INIT_LIST_HEAD(&ptrs_);
}

CreatureWeakPtrChunk::~CreatureWeakPtrChunk()
{
    Clear();
}

void CreatureWeakPtrChunk::Clear()
{
    struct CreatureWeakPtr *weakptr, *tmp;
    struct list_head ptr_list;

    list_replace_init(&ptrs_, &ptr_list);
    list_for_each_entry_safe(weakptr, tmp, &ptr_list, entry_) {
        weakptr->Reset();
    }
}

void CreatureWeakPtrChunk::Set(Creature* c)
{
    ptr_ = c;
}

CreatureWeakPtr::CreatureWeakPtr()
{
    INIT_LIST_HEAD(&entry_);
}

CreatureWeakPtr::CreatureWeakPtr(const CreatureWeakPtr& x)
{
    INIT_LIST_HEAD(&entry_);
    if (x.ptr_) {
        Attach(x.ptr_);
    }
}

CreatureWeakPtr::CreatureWeakPtr(CreatureWeakPtr&& x)
{
    INIT_LIST_HEAD(&entry_);
    if (x.ptr_) {
        Attach(x.ptr_);
        x.Detach();
    }
}

CreatureWeakPtr& CreatureWeakPtr::operator=(const CreatureWeakPtr& x)
{
    if (ptr_) {
        Detach();
    }
    if (x.ptr_) {
        Attach(x.ptr_);
    }
    return *this;
}

CreatureWeakPtr&& CreatureWeakPtr::operator=(CreatureWeakPtr&& x)
{
    if (ptr_) {
        Detach();
    }
    if (x.ptr_) {
        Attach(x.ptr_);
        x.Detach();
    }
    abort();
    //    return *this;
}

CreatureWeakPtr::~CreatureWeakPtr()
{
    Reset();
}

void CreatureWeakPtr::Reset()
{
    if (ptr_) {
        Detach();
    }
}

Creature* CreatureWeakPtr::Get()
{
    return ptr_;
}

void CreatureWeakPtr::Attach(Creature* c)
{
    Reset();
    CreatureWeakPtrChunk* chunk = c->GetWeakPtrChunk();
    if (c != chunk->ptr_) {
        abort();
    }
    ptr_ = c;
    list_add_tail(&entry_, &chunk->ptrs_);
}

void CreatureWeakPtr::Detach()
{
    if (ptr_) {
        ptr_ = nullptr;
        list_del_init(&entry_);
    }
}

RoomObstacleWeakPtrChunk::RoomObstacleWeakPtrChunk()
{
    INIT_LIST_HEAD(&ptrs_);
}

RoomObstacleWeakPtrChunk::~RoomObstacleWeakPtrChunk()
{
    Clear();
}

void RoomObstacleWeakPtrChunk::Clear()
{
    struct RoomObstacleWeakPtr *weakptr, *tmp;
    struct list_head ptr_list;

    list_replace_init(&ptrs_, &ptr_list);
    list_for_each_entry_safe(weakptr, tmp, &ptr_list, entry_) {
        weakptr->Reset();
    }
}

void RoomObstacleWeakPtrChunk::Set(RoomObstacle* c)
{
    ptr_ = c;
}

RoomObstacleWeakPtr::RoomObstacleWeakPtr()
{
    INIT_LIST_HEAD(&entry_);
}

RoomObstacleWeakPtr::RoomObstacleWeakPtr(const RoomObstacleWeakPtr& x)
{
    INIT_LIST_HEAD(&entry_);
    if (x.ptr_) {
        Attach(x.ptr_);
    }
}

RoomObstacleWeakPtr::RoomObstacleWeakPtr(RoomObstacleWeakPtr&& x)
{
    INIT_LIST_HEAD(&entry_);
    if (x.ptr_) {
        Attach(x.ptr_);
        x.Detach();
    }
}

RoomObstacleWeakPtr& RoomObstacleWeakPtr::operator=(const RoomObstacleWeakPtr& x)
{
    if (ptr_) {
        Detach();
    }
    if (x.ptr_) {
        Attach(x.ptr_);
    }
    return *this;
}

RoomObstacleWeakPtr&& RoomObstacleWeakPtr::operator=(RoomObstacleWeakPtr&& x)
{
    if (ptr_) {
        Detach();
    }
    if (x.ptr_) {
        Attach(x.ptr_);
        x.Detach();
    }
    abort();
    //    return *this;
}

RoomObstacleWeakPtr::~RoomObstacleWeakPtr()
{
    Reset();
}

void RoomObstacleWeakPtr::Reset()
{
    if (ptr_) {
        Detach();
    }
}

RoomObstacle* RoomObstacleWeakPtr::Get()
{
    return ptr_;
}

void RoomObstacleWeakPtr::Attach(RoomObstacle* c)
{
    Reset();
    RoomObstacleWeakPtrChunk* chunk = c->GetWeakPtrChunk();
    if (c != chunk->ptr_) {
        abort();
    }
    ptr_ = c;
    list_add_tail(&entry_, &chunk->ptrs_);
}

void RoomObstacleWeakPtr::Detach()
{
    if (ptr_) {
        ptr_ = nullptr;
        list_del_init(&entry_);
    }
}

EntityWeakPtrChunk::EntityWeakPtrChunk()
{
    INIT_LIST_HEAD(&ptrs_);
}

EntityWeakPtrChunk::~EntityWeakPtrChunk()
{
    Clear();
}

void EntityWeakPtrChunk::Clear()
{
    struct EntityWeakPtr *weakptr, *tmp;
    struct list_head ptr_list;

    list_replace_init(&ptrs_, &ptr_list);
    list_for_each_entry_safe(weakptr, tmp, &ptr_list, entry_) {
        weakptr->Reset();
    }
}

void EntityWeakPtrChunk::Set(Entity* c)
{
    ptr_ = c;
}

EntityWeakPtr::EntityWeakPtr()
{
    INIT_LIST_HEAD(&entry_);
}

EntityWeakPtr::EntityWeakPtr(const EntityWeakPtr& x)
{
    INIT_LIST_HEAD(&entry_);
    if (x.ptr_) {
        Attach(x.ptr_);
    }
}

EntityWeakPtr::EntityWeakPtr(EntityWeakPtr&& x)
{
    INIT_LIST_HEAD(&entry_);
    if (x.ptr_) {
        Attach(x.ptr_);
        x.Detach();
    }
}

EntityWeakPtr& EntityWeakPtr::operator=(const EntityWeakPtr& x)
{
    if (ptr_) {
        Detach();
    }
    if (x.ptr_) {
        Attach(x.ptr_);
    }
    return *this;
}

EntityWeakPtr&& EntityWeakPtr::operator=(EntityWeakPtr&& x)
{
    if (ptr_) {
        Detach();
    }
    if (x.ptr_) {
        Attach(x.ptr_);
        x.Detach();
    }
    abort();
    //    return *this;
}

EntityWeakPtr::~EntityWeakPtr()
{
    Reset();
}

void EntityWeakPtr::Reset()
{
    if (ptr_) {
        Detach();
    }
}

Entity* EntityWeakPtr::Get()
{
    return ptr_;
}

void EntityWeakPtr::Attach(Entity* c)
{
    Reset();
    EntityWeakPtrChunk* chunk = c->GetEntityWeakPtrChunk();
    if (c != chunk->ptr_) {
        abort();
    }
    ptr_ = c;
    list_add_tail(&entry_, &chunk->ptrs_);
}

void EntityWeakPtr::Detach()
{
    if (ptr_) {
        ptr_ = nullptr;
        list_del_init(&entry_);
    }
}