---

HrefIdMap.h

Go to the documentation of this file.

// /******************************************************************************\
// *
// * File:          HrefIdMap.h
// * Creation date: June 11, 2001 11:05
// * Author:        ClassBuilder
// *                XXXX
// * Purpose:       Declaration of class 'HrefIdMap'
// *
// * Modifications: @INSERT_MODIFICATIONS(* )
// * June 12, 2001 09:22 WERS
// *     Added method 'RealNode'
// * June 11, 2001 11:41 WERS
// *     Added method 'RealNode'
// * June 11, 2001 11:09 WERS
// *     Added method 'Build'
// * June 11, 2001 11:05 WERS
// *     Added method 'FindReverseHrefId'
// *     Added method 'FindHrefId'
// *     Added method 'FindEqualOrSmallerHrefId'
// *     Added method 'FindEqualOrBiggerHrefId'
// *     Added method 'DestructorInclude'
// *     Added method 'ConstructorInclude'
// *     Added method '~HrefIdMap'
// *     Added method 'HrefIdMap'
// *     Added relation 'HrefIdMap <>-->> HrefId'
// *
// *
// \******************************************************************************/
#ifndef _HREFIDMAP_H
#define _HREFIDMAP_H

//@START_USER1
/* --------------------------------------------------------------
Copyright (C) 2001 LifeLine Networks BV <soap2corba@lifeline.nl>

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-------------------------------------------------------------- */
//@END_USER1


class HrefIdMap
{
    // RELATION_AVLTREE_OWNED_ACTIVE(HrefIdMap, HrefIdMap, HrefId, HrefId)
private:
    HrefId * _topHrefId;
    int _countHrefId;

protected:

public:
    void AddHrefId(HrefId* item);
    void RemoveHrefId(HrefId* item);
    void DeleteAllHrefId();
    void ReplaceHrefId(HrefId* item, HrefId* newItem);
    HrefId* GetFirstHrefId() const;
    HrefId* GetLastHrefId() const;
    HrefId* GetNextHrefId(HrefId* pos) const;
    HrefId* GetPrevHrefId(HrefId* pos) const;
    int GetHrefIdCount() const;
    
    class  HrefIdIterator
    {
    private:
        HrefId* _refHrefId;
        HrefId* _prevHrefId;
        HrefId* _nextHrefId;
        const HrefIdMap* _iterHrefIdMap;
        
        HrefIdIterator* _prev;
        HrefIdIterator* _next;
        
        int (HrefId::*_method)() const;
        
        static HrefIdIterator* _first;
        static HrefIdIterator* _last;
        
    public:
        HrefIdIterator(const HrefIdMap* iterHrefIdMap,
                         int (HrefId::*method)() const = 0,
                         HrefId* refHrefId = 0);
        HrefIdIterator(const HrefIdMap& iterHrefIdMap,
                         int (HrefId::*method)() const = 0,
                         HrefId* refHrefId = 0);
        HrefIdIterator(const HrefIdIterator& iterator,
                         int (HrefId::*method)() const = 0);
        ~HrefIdIterator();
        
        HrefIdIterator& operator= (const HrefIdIterator& iterator)
        {
            _iterHrefIdMap = iterator._iterHrefIdMap;
            _refHrefId = iterator._refHrefId;
            _prevHrefId = iterator._prevHrefId;
            _nextHrefId = iterator._nextHrefId;
            _method = iterator._method;
            return *this;
        }
        HrefId* operator++ ()
        {
            _nextHrefId = _iterHrefIdMap->GetNextHrefId(_nextHrefId);
            if (_method != 0)
            {
                while (_nextHrefId && !(_nextHrefId->*_method)())
                    _nextHrefId = _iterHrefIdMap->GetNextHrefId(_nextHrefId);
            }
            _refHrefId = _prevHrefId = _nextHrefId;
            return _refHrefId;
        }
        HrefId* operator-- ()
        {
            _prevHrefId = _iterHrefIdMap->GetPrevHrefId(_prevHrefId);
            if (_method != 0)
            {
                while (_prevHrefId && !(_prevHrefId->*_method)())
                    _prevHrefId = _iterHrefIdMap->GetPrevHrefId(_prevHrefId);
            }
            _refHrefId = _nextHrefId = _prevHrefId;
            return _refHrefId;
        }
        operator HrefId*() { return _refHrefId; }
        HrefId* operator-> () { return _refHrefId; }
        HrefId* Get() { return _refHrefId; }
        void Reset() { _refHrefId = _prevHrefId = _nextHrefId = (HrefId*)0; }
        
        int IsLast() { return (_iterHrefIdMap->GetLastHrefId() == _refHrefId); }
        int IsFirst() { return (_iterHrefIdMap->GetFirstHrefId() == _refHrefId); }
        
        static void Check(HrefId* itemHrefId);
        static void Check(HrefId* itemHrefId, HrefId* newItemHrefId);
    };

//@START_USER2
//@END_USER2

// Members
private:

protected:

public:

// Methods
private:
    void ConstructorInclude();
    void DestructorInclude();

protected:

public:
    HrefIdMap();
    virtual ~HrefIdMap();
    void Build(DOM_Node& rNode);
    void RealNode(DOM_Node& rRealNode, DOM_Node& rFakeNode);
    void RealNode(DOM_Element& rElement, DOM_Node& rFakeNode);
    HrefId* FindEqualOrBiggerHrefId(const CString& id);
    HrefId* FindEqualOrSmallerHrefId(const CString& id);
    HrefId* FindHrefId(const CString& id);
    HrefId* FindReverseHrefId(const CString& id);
};

#endif


#ifdef CB_INLINES
#ifndef _HREFIDMAP_H_INLINES
#define _HREFIDMAP_H_INLINES

//@START_USER3
//@END_USER3

#endif
#endif

---