xref: /AOO42X/main/autodoc/inc/cosv/tpl/swelist.hxx (revision 9bce9b0d387299c68bd81d539e1478357a103de5)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



#ifndef CSV_SWELIST_HXX
#define CSV_SWELIST_HXX

// USED SERVICES
    // BASE CLASSES
    // COMPONENTS
    // PARAMETERS
#include <cosv/tpl/dyn.hxx>


namespace csv
{


template <class XX>
class SweListElement
{
  public:
    typedef SweListElement<XX> self;

                        SweListElement(
                            const XX &          in_aObj )
                                                :   aObj(in_aObj), pNext(0) {}

    const XX &          Obj() const             { return aObj; }
    XX &                Obj()                   { return aObj; }
    self *              Next() const            { return pNext; }

    void                SetNext(
                            self *              i_pNext )
                                                { pNext = i_pNext; }
  private:
    XX                  aObj;
    self *              pNext;
};



template <class XX>  class SweListIterator;
template <class XX>  class SweListCIterator;


template <class XX>
class SweList
{
  public:
    // TYPES
    typedef SweList<XX>             self;
    typedef XX                      value_type;
    typedef SweListIterator<XX>     iterator;
    typedef SweListCIterator<XX>    const_iterator;
  private:
    typedef SweListElement<XX>      elem;

  public:
    // LIFECYCLE
                        SweList()               : pTop(0), pTail(0) {}
                        ~SweList()              { erase_all(); }
    // OPERATIONS
    void                push_front(
                            const XX &          i_aObj );
    void                pop_front();
    void                push_back(
                            const XX &          i_aObj );
    void                erase_all();

    // INQUIRY
    const_iterator      begin() const           { return pTop; }
    iterator            begin()                 { return pTop; }
    const_iterator      end() const             { return (elem*)0; }
    iterator            end()                   { return (elem*)0; }
    const XX &          front() const           { return pTop->Obj(); }
    XX &                front()                 { return pTop->Obj(); }
    const XX &          back() const            { return pTail->Obj(); }
    XX &                back()                  { return pTail->Obj(); }

    bool                empty() const           { return pTop == 0; }
    uintt               size() const;


  private:
    // Forbiddden methods.
                        SweList(
                            const self &        i_rList );
    self &              operator=(
                            const self &        i_rList );

    // DATA
    DYN elem *          pTop;
    elem *              pTail;
};

template <class XX>
class SweList_dyn
{
  public:
    // TYPES
    typedef SweList_dyn<XX>         self;
    typedef SweListElement< XX* >   elem;
    typedef SweListIterator< XX* >  iterator;

    // LIFECYCLE
                        SweList_dyn()       : pTop(0), pTail(0) {}
                        ~SweList_dyn()      { erase_all(); }
    // OPERATIONS
    void                push_front(
                            XX *            i_pObj );
    void                push_back(
                            XX *            i_pObj );
    void                pop_front();
    void                erase_all();

    // INQUIRY
    iterator            begin() const       { return pTop; }
    iterator            end() const         { return (elem*)0; }
    XX *                front() const       { return pTop->Obj(); }
    XX *                back() const        { return pTail->Obj(); }

    bool                empty() const       { return pTop == 0; }
    uintt               size() const;

  private:
    // Forbiddden methods.
                        SweList_dyn(
                            const self &        i_rList );
    self &              operator=(
                            const self &        i_rList );

    DYN elem *          pTop;
    elem *              pTail;
};




template<class XX>
class SweListIterator
{
  public:
    typedef SweListIterator<XX> self;
    typedef SweListElement<XX>  elem;

                        SweListIterator(
                            elem *              i_pElem = 0)
                                                :   pElem(i_pElem) { }

    // OPERATORS
    XX &                operator*() const       { return pElem->Obj(); }
    self &              operator++()            { if (pElem != 0) pElem = pElem->Next();
                                                  return *this; }
    bool                operator==(
                            const self &        i_rIter ) const
                                                { return pElem == i_rIter.pElem; }
    bool                operator!=(
                            const self &        i_rIter ) const
                                                { return pElem != i_rIter.pElem; }
  private:
    friend class SweListCIterator<XX>;

    elem *              pElem;
};

template<class XX>
class SweListCIterator
{
  public:
    typedef SweListCIterator<XX> self;
    typedef SweListElement<XX>  elem;

                        SweListCIterator(
                            const elem *        i_pElem = 0)
                                                :   pElem(i_pElem) { }

    // OPERATORS
    self &              operator=(
                            const SweListIterator<XX> &
                                                i_rIter )
                                                { pElem = i_rIter.pElem; return *this; }

    const XX &          operator*() const       { return pElem->Obj(); }
    self &              operator++()            { if (pElem != 0) pElem = pElem->Next();
                                                  return *this; }
    bool                operator==(
                            const self &        i_rIter ) const
                                                { return pElem == i_rIter.pElem; }
    bool                operator!=(
                            const self &        i_rIter ) const
                                                { return pElem != i_rIter.pElem; }
  private:
    const elem *        pElem;
};

// Implementierung

template <class XX>
void
SweList<XX>::push_front( const XX & i_aObj )
{
    DYN elem * dpNew = new elem(i_aObj);
    dpNew->SetNext(pTop);
    pTop = dpNew;
    if (pTail == 0)
        pTail = pTop;
}

template <class XX>
void
SweList<XX>::push_back( const XX & i_aObj)
{
    if (pTail != 0)
    {
        pTail->SetNext(new elem(i_aObj));
        pTail = pTail->Next();
    }
    else
    {
        pTop = pTail = new elem(i_aObj);
    }
}

template <class XX>
void
SweList<XX>::pop_front()
{
    if (pTop != 0)
    {
        elem * pDel = pTop;
        pTop = pTop->Next();
        delete pDel;
        if (pTop == 0)
            pTail = 0;
    }
}

template <class XX>
uintt
SweList<XX>::size() const
{
    uintt ret = 0;
    for ( const_iterator iter = begin();
          iter != end();
          ++iter )
    {
        ++ret;
    }
    return ret;
}


template <class XX>
void
SweList<XX>::erase_all()
{
    for (pTail = pTop ; pTop != 0; pTail = pTop)
    {
        pTop = pTop->Next();
        delete pTail;
    }
    pTop = pTail = 0;
}


template <class XX>
void
SweList_dyn<XX>::push_front( XX * i_pObj )
{
    DYN elem * dpNew = new elem(i_pObj);
    dpNew->SetNext(pTop);
    pTop = dpNew;
    if (pTail == 0)
        pTail = pTop;
}

template <class XX>
void
SweList_dyn<XX>::push_back( XX * i_pObj )
{
    if (pTail != 0)
    {
        pTail->SetNext(new elem(i_pObj));
        pTail = pTail->Next();
    }
    else
    {
        pTop = pTail = new elem(i_pObj);
    }
}

template <class XX>
void
SweList_dyn<XX>::pop_front()
{
    if (pTop != 0)
    {
        elem * pDel = pTop;
        pTop = pTop->Next();
        if (pDel->Obj() != 0)
            Delete_dyn(pDel->Obj());
        delete pDel;
        if (pTop == 0)
            pTail = 0;
    }
}


template <class XX>
void
SweList_dyn<XX>::erase_all()
{
    for (pTail = pTop ; pTop != 0; pTail = pTop)
    {
        pTop = pTop->Next();
        if (pTail->Obj() != 0)
        {
            delete pTail->Obj();
        }
        delete pTail;
    }
    pTop = pTail = 0;
}

template <class XX>
uintt
SweList_dyn<XX>::size() const
{
    uintt ret = 0;
    for ( iterator iter = begin();
          iter != end();
          ++iter )
    {
        ++ret;
    }
    return ret;
}


}   // namespace csv


#endif