---

InterfaceRepository.h

Go to the documentation of this file.

// /******************************************************************************\
// *
// * File:          InterfaceRepository.h
// * Creation date: May 25, 2001 11:34
// * Author:        ClassBuilder
// *                XXXX
// * Purpose:       Declaration of class 'SCInterfaceRepository'
// *
// * Modifications: @INSERT_MODIFICATIONS(* )
// * June 06, 2001 12:52 WERS
// *     Added method 'FindInterfaceMethod'
// * May 25, 2001 11:34 WERS
// *     Added method 'DestructorInclude'
// *     Added method 'ConstructorInclude'
// *     Added method '~SCInterfaceRepository'
// *     Added method 'SCInterfaceRepository'
// *     Added relation 'InterfaceRepository(SCInterfaceRepository) <>-->> InterfaceMethod(SCInterfaceMethod)'
// *
// *
// \******************************************************************************/
#ifndef _INTERFACEREPOSITORY_H
#define _INTERFACEREPOSITORY_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 SCInterfaceRepository
{
    // RELATION_MULTI_OWNED_ACTIVE(SCInterfaceRepository, InterfaceRepository, SCInterfaceMethod, InterfaceMethod)
public:
    SCInterfaceMethod * _firstInterfaceMethod;
    SCInterfaceMethod * _lastInterfaceMethod;
    int _countInterfaceMethod;

protected:
    void AddInterfaceMethodFirst(SCInterfaceMethod* item);
    void AddInterfaceMethodLast(SCInterfaceMethod* item);
    void AddInterfaceMethodAfter(SCInterfaceMethod* item, SCInterfaceMethod* pos);
    void AddInterfaceMethodBefore(SCInterfaceMethod* item, SCInterfaceMethod* pos);
    void RemoveInterfaceMethod(SCInterfaceMethod* item);
    void ReplaceInterfaceMethod(SCInterfaceMethod* item, SCInterfaceMethod* newItem);

public:
    void DeleteAllInterfaceMethod();
    SCInterfaceMethod* GetFirstInterfaceMethod() const;
    SCInterfaceMethod* GetLastInterfaceMethod() const;
    SCInterfaceMethod* GetNextInterfaceMethod(SCInterfaceMethod* pos) const;
    SCInterfaceMethod* GetPrevInterfaceMethod(SCInterfaceMethod* pos) const;
    int GetInterfaceMethodCount() const;
    void MoveInterfaceMethodFirst(SCInterfaceMethod* item);
    void MoveInterfaceMethodLast(SCInterfaceMethod* item);
    void MoveInterfaceMethodAfter(SCInterfaceMethod* item, SCInterfaceMethod* pos);
    void MoveInterfaceMethodBefore(SCInterfaceMethod* item, SCInterfaceMethod* pos);
    void SortInterfaceMethod(int (*comp)(SCInterfaceMethod*, SCInterfaceMethod*));
    
    class  InterfaceMethodIterator
    {
    private:
        SCInterfaceMethod* _refInterfaceMethod;
        SCInterfaceMethod* _prevInterfaceMethod;
        SCInterfaceMethod* _nextInterfaceMethod;
        const SCInterfaceRepository* _iterInterfaceRepository;
        
        InterfaceMethodIterator* _prev;
        InterfaceMethodIterator* _next;
        
        int (SCInterfaceMethod::*_method)() const;
        
        static InterfaceMethodIterator* _first;
        static InterfaceMethodIterator* _last;
        
    public:
        InterfaceMethodIterator(const SCInterfaceRepository* iterInterfaceRepository,
                         int (SCInterfaceMethod::*method)() const = 0,
                         SCInterfaceMethod* refInterfaceMethod = 0);
        InterfaceMethodIterator(const SCInterfaceRepository& iterInterfaceRepository,
                         int (SCInterfaceMethod::*method)() const = 0,
                         SCInterfaceMethod* refInterfaceMethod = 0);
        InterfaceMethodIterator(const InterfaceMethodIterator& iterator,
                         int (SCInterfaceMethod::*method)() const = 0);
        ~InterfaceMethodIterator();
        
        InterfaceMethodIterator& operator= (const InterfaceMethodIterator& iterator)
        {
            _iterInterfaceRepository = iterator._iterInterfaceRepository;
            _refInterfaceMethod = iterator._refInterfaceMethod;
            _prevInterfaceMethod = iterator._prevInterfaceMethod;
            _nextInterfaceMethod = iterator._nextInterfaceMethod;
            _method = iterator._method;
            return *this;
        }
        SCInterfaceMethod* operator++ ()
        {
            _nextInterfaceMethod = _iterInterfaceRepository->GetNextInterfaceMethod(_nextInterfaceMethod);
            if (_method != 0)
            {
                while (_nextInterfaceMethod && !(_nextInterfaceMethod->*_method)())
                    _nextInterfaceMethod = _iterInterfaceRepository->GetNextInterfaceMethod(_nextInterfaceMethod);
            }
            _refInterfaceMethod = _prevInterfaceMethod = _nextInterfaceMethod;
            return _refInterfaceMethod;
        }
        SCInterfaceMethod* operator-- ()
        {
            _prevInterfaceMethod = _iterInterfaceRepository->GetPrevInterfaceMethod(_prevInterfaceMethod);
            if (_method != 0)
            {
                while (_prevInterfaceMethod && !(_prevInterfaceMethod->*_method)())
                    _prevInterfaceMethod = _iterInterfaceRepository->GetPrevInterfaceMethod(_prevInterfaceMethod);
            }
            _refInterfaceMethod = _nextInterfaceMethod = _prevInterfaceMethod;
            return _refInterfaceMethod;
        }
        operator SCInterfaceMethod*() { return _refInterfaceMethod; }
        SCInterfaceMethod* operator-> () { return _refInterfaceMethod; }
        SCInterfaceMethod* Get() { return _refInterfaceMethod; }
        void Reset() { _refInterfaceMethod = _prevInterfaceMethod = _nextInterfaceMethod = (SCInterfaceMethod*)0; }
        
        int IsLast() { return (_iterInterfaceRepository->GetLastInterfaceMethod() == _refInterfaceMethod); }
        int IsFirst() { return (_iterInterfaceRepository->GetFirstInterfaceMethod() == _refInterfaceMethod); }
        
        static void Check(SCInterfaceMethod* itemInterfaceMethod);
        static void Check(SCInterfaceMethod* itemInterfaceMethod, SCInterfaceMethod* newItemInterfaceMethod);
    };

//@START_USER2
//@END_USER2

// Members
private:

protected:

public:

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

protected:

public:
    SCInterfaceRepository();
    virtual ~SCInterfaceRepository();
    SCInterfaceMethod* FindInterfaceMethod(const char* methPath);
};

#endif


#ifdef CB_INLINES
#ifndef _INTERFACEREPOSITORY_H_INLINES
#define _INTERFACEREPOSITORY_H_INLINES

//@START_USER3
//@END_USER3

#endif
#endif

---