__LIST.cpp

Go to the documentation of this file.

#ifdef __DCL_INTERNAL__
 
#ifdef __COMPILE_StringList__
    #define THIS_NAME                       __szStringList_cpp__
    #define THIS_VALUE                      __T("dcl/__LIST.cpp/String")
    #define LIST_T                          StringList
    #define ELEMENT_T                       String
    #define ELEMENT_T_CAST
    #define CONST_ELEMENT_REF               const String&
    #define HAVE_CONSTRUCTOR_ELEMENT        1
#elif defined(__COMPILE_ByteStringList__)
    #define THIS_NAME                       __szByteStringList_cpp__
    #define THIS_VALUE                      __T("dcl/__LIST.cpp/ByteString")
    #define LIST_T                          ByteStringList
    #define ELEMENT_T                       ByteString
    #define ELEMENT_T_CAST
    #define CONST_ELEMENT_REF               const ByteString&
    #define HAVE_CONSTRUCTOR_ELEMENT        1
#elif defined(__COMPILE_PointerList__)
    #define THIS_NAME                       __szPointerList_cpp__
    #define THIS_VALUE                      __T("dcl/__LIST.cpp/void*")
    #define LIST_T                          PointerList
    #define ELEMENT_T                       void*
    #define ELEMENT_T_CAST                  (void*)
    #define CONST_ELEMENT_REF               const void*
    #define HAVE_CONSTRUCTOR_ELEMENT        0
#endif
 
#if __DCL_HAVE_THIS_FILE__
    static const char_t THIS_NAME[] = THIS_VALUE;
    #undef __THIS_FILE__
    #define __THIS_FILE__   THIS_NAME
#endif
 
#if __DCL_HAVE_ALLOC_DEBUG
    #undef __DCL_ALLOC_LEVEL
    #define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif

 
IMPLEMENT_CLASSINFO(LIST_T, Object)
 
String LIST_T::toString() const
{
    StringBuilder r = __T("{");
    for (ConstIterator it = begin(); it != end(); it++)
    {
        if (it != begin())
            r += __T(", ");
#ifdef __COMPILE_StringList__
        r += __T("\"");
        r += String::escape((*it), (*it).length());
        r += __T("\"");
#elif defined(__COMPILE_ByteStringList__)
        r += __T("\"");
        r += String::tryString((*it), 8);
        r += __T("\"");
#elif defined(__COMPILE_PointerList__)
        r.format(__T("%p"), (*it));
#else
        r += (*it).toString();
#endif
    }
    r += __T("}");
    return r;
}
 
LIST_T::~LIST_T()
{
    if (!isEmpty())
        clear();
    free(__pMasterNode);
}
 
LIST_T::LIST_T()
{
    __pMasterNode = (NodeBase*) malloc(sizeof(NodeBase));
    // FIXME!
    // if (pNode == NULL)
    //      throw new BadAllocException(sizeof(HashNode), __THIS_FILE__, __LINE__);
    __DCL_ASSERT(__pMasterNode != NULL);
 
    __pMasterNode->pPrev = __pMasterNode;
    __pMasterNode->pNext = __pMasterNode;
    __size = 0;
}
 
LIST_T::LIST_T(const LIST_T& _src)
{
    __pMasterNode = (NodeBase*) malloc(sizeof(NodeBase));
    // FIXME!
    // if (pNode == NULL)
    //      throw new BadAllocException(sizeof(HashNode), __THIS_FILE__, __LINE__);
    __DCL_ASSERT(__pMasterNode != NULL);
 
    __pMasterNode->pPrev = __pMasterNode;
    __pMasterNode->pNext = __pMasterNode;
    __size = 0;
 
    insert(end(), _src.begin(), _src.end());
}
 
const LIST_T&
LIST_T::operator=(const LIST_T& _src)
{
    if (&_src != this)
    {
        if (!isEmpty())
            clear();
        insert(end(), _src.begin(), _src.end());
    }
    return *this;
}
 
LIST_T::ListNode*
LIST_T::createNode(CONST_ELEMENT_REF _element)
{
    ListNode* pNode = (ListNode*) malloc(sizeof(ListNode));
    // FIXME!
    // if (pNode == NULL)
    //      throw new BadAllocException(sizeof(HashNode), __THIS_FILE__, __LINE__);
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef new
#endif
 
#if HAVE_CONSTRUCTOR_ELEMENT
    new(&(pNode->data)) ELEMENT_T;
#endif
 
#if __DCL_HAVE_ALLOC_DEBUG
#define new __DCL_DEBUG_NEW
#endif
 
    pNode->data = ELEMENT_T_CAST _element;
    return pNode;
}
 
void
LIST_T::destroyNode(ListNode* _pNode)
{
#if HAVE_CONSTRUCTOR_ELEMENT
    _pNode->data.~ELEMENT_T();
#endif
    free(_pNode);
}
 
LIST_T::Iterator
LIST_T::insert(Iterator _pos, CONST_ELEMENT_REF _element)
{
    ListNode* pNewNode = createNode(_element);
    pNewNode->pPrev = _pos.__pNode->pPrev;
    pNewNode->pNext = _pos.__pNode;
    _pos.__pNode->pPrev->pNext = pNewNode;
    _pos.__pNode->pPrev = pNewNode;
 
    __size++;
 
    return (ListNode*)pNewNode;
}
 
void
LIST_T::insert(Iterator _pos, ConstIterator _first, ConstIterator _last)
{
    for(; _first != _last; _first++)
    {
        insert(_pos, *_first);
    }
}
 
LIST_T::Iterator
LIST_T::find(CONST_ELEMENT_REF _element)
{
    Iterator it = begin();
    for (; it != end(); it++)
    {
        if (*it == _element)
            break;
    }
    return it;
}
 
void
LIST_T::clear()
{
    ListNode* pNodeTemp = NULL;
    NodeBase* pNode = __pMasterNode->pNext;
    while(pNode != __pMasterNode)
    {
        pNodeTemp = (ListNode*)pNode;
        pNode = pNode->pNext;
        destroyNode(pNodeTemp);
    }
    __pMasterNode->pNext = __pMasterNode;
    __pMasterNode->pPrev = __pMasterNode;
    __size = 0;
}
 
LIST_T::Iterator
LIST_T::erase(Iterator _pos)
{
    __DCL_ASSERT(_pos != end());
    ListNode* pNodeTemp = (ListNode*)_pos.__pNode;
    NodeBase* pNext = pNodeTemp->pNext;
    pNodeTemp->pPrev->pNext = pNodeTemp->pNext;
    pNodeTemp->pNext->pPrev = pNodeTemp->pPrev;
    destroyNode(pNodeTemp);
    __size--;
    return (ListNode*)pNext;
}
 
ELEMENT_T
LIST_T::removeHead()
{
    __DCL_ASSERT(!isEmpty());
    ELEMENT_T result = *begin();
    erase(begin());
    return result;
}
 
ELEMENT_T
LIST_T::removeTail()
{
    __DCL_ASSERT(!isEmpty());
    Iterator it = end();
    ELEMENT_T result = *(--it);
    erase(it);
    return result;
}
 
void
LIST_T::move(Iterator _pos, Iterator _first, Iterator _last)
{
    if (_pos != _last)
    {
        _last.__pNode->pPrev->pNext = _pos.__pNode;
        _first.__pNode->pPrev->pNext = _last.__pNode;
        _pos.__pNode->pPrev->pNext = _first.__pNode;
 
        NodeBase* pTemp = _pos.__pNode->pPrev;
        _pos.__pNode->pPrev = _last.__pNode->pPrev;
        _last.__pNode->pPrev = _first.__pNode->pPrev;
        _first.__pNode->pPrev = pTemp;
    }
}
 
void
LIST_T::splice(Iterator _pos, 
        LIST_T& _other, Iterator _otherFirst, Iterator _otherLast)
{
    size_t nMoveCount = size((ListNode*)(_otherFirst.__pNode),
                        (ListNode*)(_otherLast.__pNode));
    __size += nMoveCount;
    _other.__size -= nMoveCount;
 
    move(_pos, _otherFirst, _otherLast);
}
 
size_t
LIST_T::size(ConstIterator _first, ConstIterator _last) const
{
    size_t nCount = 0;
    for(; _first != _last; _first++)
        nCount++;
    return nCount;
}
 
#if __DCL_HAVE_THIS_FILE__
    #undef __THIS_FILE__
    #define __THIS_FILE__   __T(__FILE__)
#endif
 
#undef THIS_NAME
#undef THIS_VALUE
#undef LIST_T
#undef ELEMENT_T
#undef ELEMENT_T_CAST
#undef CONST_ELEMENT_REF
#undef HAVE_CONSTRUCTOR_ELEMENT
 
#endif      // __DCL_INTERNAL__