CrossLink.h

#ifndef _CROSS_H
#define _CROSS_H
//==================================================================================
//  Chain cros link template class
//  Programmed by you-chi@fsinet.or.jp
//  Copyright (C) 2001-2003 by you-chi@fsinet.or.jp
//  All rights reserved.
//==================================================================================
//

class SAddressBook;
namespace CLink
{

    template<class T> class SCrossLink
    {
    protected:
        SCrossLink<T>   *Parent;        
        SCrossLink<T>   *Child;         
        SCrossLink<T>   *Prev;          
        SCrossLink<T>   *Next;          

        T               Data;           

    public:
        SCrossLink(T& _Item, SCrossLink<T> *_Parent = NULL)
        {
            Parent = _Parent;
            Child = NULL;
            Next = NULL;
            Prev = NULL;
            Data = _Item;
        }

        ‾SCrossLink()
        {
            // 破棄手順は子供→兄弟の順番
            if (Child != NULL)
            {
                delete Child;
            }
            if (Next != NULL)
            {
                delete Next;
            }
        }
        const T& operator *()
        {
            return Data;
        }
        inline SCrossLink<T>   *GetParent()
        {
            return Parent;
        }
        inline SCrossLink<T>   *GetChild()
        {
            return Child;
        }
        inline SCrossLink<T>   *GetPrev()
        {
            return Prev;
        }
        inline SCrossLink<T>   *GetNext()
        {
            return Next;
        }

        SCrossLink<T>   *Add(T& _Item)
        {
            if (Child != NULL)
            {
                return Child->Connect(_Item);
            }
            else
            {
                return Chain(_Item);
            }
        }

        void Delete()
        {
            // 兄弟リンクからの削除
            if (Prev != NULL)
            {
                Prev->Next = Next;
            }
            if (Next != NULL)
            {
                Next->Prev = Prev;
            }

            // 親子リンクからの削除（親子関係は１：多の関係）
            if (Parent != NULL)
            {
                if (Parent->Child == this)
                {
                    // 親の直下の子供の場合にだけ変更する必要がある。
                    // 親子関係の更新は、リスト構造によって変更する必要があるのかも・・・
                    Parent->Child = Child;  // ( Next == NULL ) ? Child : Next;
                }
            }
            Parent = NULL;
            Prev = Next = NULL;

            // ※子供がいる場合には削除してしまいますので注意が必要です。
            delete this;
        }

        SCrossLink<T>   *Chain(T& _Item)
        {
            SCrossLink<T> *target = this;

            while (target->Child != NULL)
            {
                target = target->Child;
            }

            return target->Child = new SCrossLink<T>(_Item, target);
        }

        SCrossLink<T>   *Include(T& _Item)
        {
            SCrossLink<T> *elder = new SCrossLink<T>(_Item, this);
            if (Child != NULL)
            {
                Child->Parent = elder;
            }
            return Child = elder;
        }

        SCrossLink<T>   *Connect(T& _Item)
        {
            SCrossLink<T> *target = this;

            while (target->Next != NULL)
            {
                target = target->Next;
            }

            SCrossLink<T>   *item = new SCrossLink<T>(_Item, Parent);
            target->Next = item;
            item->Prev = target;

            return item;
        }

        SCrossLink<T>   *Insert(T& _Item)
        {
            SCrossLink<T>   *item = new SCrossLink<T>(_Item, Parent);

            if (Prev != NULL)
            {
                Prev->Next = item;
            }
            item->Prev = Prev;
            Prev = item;
            item->Next = this;

            return item;
        }

        typedef bool(*FSCrossLinkTracer)(void *_User, SCrossLink<T> *_Object);

        bool    TraceChain(bool _Nesting, void *_User, FSCrossLinkTracer _EachTrace)
        {
            SCrossLink<T>   *node = this;
            if (node != 0)
            {
                if (_EachTrace(_User, node) == false)
                {
                    return false;
                }
                if ((_Nesting == true) && (node->Child != NULL))
                {
                    if (node->Child->TraceChain(_Nesting, _User, _EachTrace) == false)
                    {
                        return false;
                    }
                }
                if ((_Nesting == true) && (node->Next != NULL))
                {
                    if (node->Next->TraceConnect(_Nesting, _User, _EachTrace) == false)
                    {
                        return false;
                    }
                }
            }
            return true;
        }

        bool    BackTraceChain(void *_User, FSCrossLinkTracer _EachTrace)
        {
            SCrossLink<T>   *node = this;
            while (node != 0)
            {
                if (_EachTrace(_User, node) == false)
                {
                    return false;
                }

                node = node->Parent;
            }
            return true;
        }

        bool    TraceConnect(bool _Nesting, void *_User, FSCrossLinkTracer _EachTrace)
        {
            SCrossLink<T>   *node = this;
            while (node != 0)
            {
                if (_EachTrace(_User, node) == false)
                {
                    return false;
                }
                if ((_Nesting == true) && (node->Child != NULL))
                {
                    if (node->Child->TraceChain(_Nesting, _User, _EachTrace) == false)
                    {
                        return false;
                    }
                }

                node = node->Next;
            }
            return true;
        }

        bool    BackTraceConnect(void *_User, FSCrossLinkTracer _EachTrace)
        {
            SCrossLink<T>   *node = this;
            while (node != 0)
            {
                if (_EachTrace(_User, node) == false)
                {
                    return false;
                }
                if (node->Prev != NULL)
                {
                    if (node->Prev->BackTraceChain(_User, _EachTrace) == false)
                    {
                        return false;
                    }
                }

                node = node->Prev;
            }
            return true;
        }

#if 0
        // 兄弟の先頭を取得する
        SCrossLink<T>   *GetElder()
        {
            SCrossLink<T>   *node = this;
            while (node->Prev != 0)
            {
                node = node->Prev;
            }
            return node;
        }
#endif

    };      // template<class T> class SCrossLink


};      // namespace CLink;

#endif  // _CROSS_H