IPKIFColleague.h

Go to the documentation of this file.

#ifndef __IPKIFColleague_H__
#define __IPKIFColleague_H__

#include "PKIFdll.h"
#include <vector>

class IPKIFColleague;
typedef IPKIFColleague IPKIFMediator;
typedef boost::shared_ptr<IPKIFMediator> IPKIFMediatorPtr;
class CPKIFException;

class CAC_API CAC_NO_VTABLE IPKIFColleague
{
//  friend class IPKIFMediator;
public:
    virtual void Initialize();
    IPKIFColleague();
    virtual ~IPKIFColleague();

    void AddParent(IPKIFMediator* parent);
    void RemoveParent(IPKIFMediator* parent);
    bool IsParent(IPKIFMediator*) const;
    
    
    // interface for colleagues that are mediators as well
    // merged into the general colleague class to work around a circular dependency that grew
    // when smart pointers were added.
    virtual void InitializeMediator(std::vector<CPKIFException*>* errorInfo = NULL);
    virtual void Terminate();
    
    template<class X> X* GetMediator() const;
    void AddMediator(IPKIFMediatorPtr& m);
    
    //added 12/04/02
    void RemoveMediator(IPKIFMediator*);
    void RemoveMediatorAssociations();
    
    template<class X> X* GetMediator(std::vector<const IPKIFColleague *>* tree) const;
    void GetMediators(std::vector<IPKIFMediatorPtr>& v) const;
    
    template <class X>
        X* FindMediator(const std::vector<IPKIFMediator*>& v, std::vector<const IPKIFColleague *>* tree) const
    {
            using namespace std;
            //The purpose of this function is to return a pointer to a desired interface.  The 
            //interface may be implemented or held by any mediator in a collection of mediators.  
            //We don't care where the interface comes from as long as we get it.  The v param
            //is the vector that is searched for the interface.  The tree param contains pointers
            //to mediators/colleagues already on the call stack so we don't loop.
            typename vector<IPKIFMediator*>::const_iterator pos;
            const typename vector<IPKIFMediator*>::const_iterator end = v.end();
            X* x = NULL;
            
            //1) See if any of the objects in the vector are the desired interface.
            for(pos = v.begin(); pos != end; ++pos)
            {
                x = dynamic_cast<X*>(*pos);
                if(NULL != x)
                    return x;
            }
            
            //2) See if any of the objects in the vector know anyone with the desired interface.
            //const vector<const IPKIFColleague *>::iterator treeBegin = tree->begin();
            //const vector<const IPKIFColleague *>::iterator treeEnd = tree->end();
            for(pos = v.begin(); pos != end; ++pos)
            {
                //moved these down here because the GetMediatorFromParent call below can invalidate the iterators
                //11/9/2003
                const vector<const IPKIFColleague *>::const_iterator treeBegin = tree->begin();
                const vector<const IPKIFColleague *>::const_iterator treeEnd = tree->end();
                
                //see if the current position has already been visited during this search
                if(treeEnd == find(treeBegin, treeEnd, (*pos)))
                {
                    //added 10/2/2003
                    x = (*pos)->template GetMediatorFromParent<X>(tree);
                    if(NULL != x)
                        return x;
                    //end added 10/2/2003
                    
                    //if it hasn't ask it for the interface
                    x = (*pos)->template GetMediator<X>(tree);
                    if(NULL != x)
                        return x;
                }
            }
            
            //3) Give up.
            return NULL;
    }
    
    template <class X>
        X* FindMediator(const std::vector<IPKIFMediatorPtr>& v, std::vector<const IPKIFColleague *>* tree) const
    {
            using namespace std;
            //The purpose of this function is to return a pointer to a desired interface.  The 
            //interface may be implemented or held by any mediator in a collection of mediators.  
            //We don't care where the interface comes from as long as we get it.  The v param
            //is the vector that is searched for the interface.  The tree param contains pointers
            //to mediators/colleagues already on the call stack so we don't loop.
            typename vector<IPKIFMediatorPtr>::const_iterator pos;
            const typename vector<IPKIFMediatorPtr>::const_iterator end = v.end();
            X* x = NULL;
            
            //1) See if any of the objects in the vector are the desired interface.
            for(pos = v.begin(); pos != end; ++pos)
            {
                x = dynamic_cast<X*>(&(*(*pos)));
                if(NULL != x)
                    return x;
            }
            
            //2) See if any of the objects in the vector know anyone with the desired interface.
            //const vector<const IPKIFColleague *>::iterator treeBegin = tree->begin();
            //const vector<const IPKIFColleague *>::iterator treeEnd = tree->end();
            for(pos = v.begin(); pos != end; ++pos)
            {
                //moved these down here because the GetMediatorFromParent call below can invalidate the iterators
                //11/9/2003
                const vector<const IPKIFColleague *>::const_iterator treeBegin = tree->begin();
                const vector<const IPKIFColleague *>::const_iterator treeEnd = tree->end();
                
                //see if the current position has already been visited during this search
                IPKIFMediator * tmpMed = &(*(*pos));
                if(treeEnd == find(treeBegin, treeEnd, tmpMed))
                {
                    //added 10/2/2003
                    x = tmpMed->template GetMediatorFromParent<X>(tree);
                    if(NULL != x)
                        return x;
                    //end added 10/2/2003
                    
                    //if it hasn't ask it for the interface
                    x = tmpMed->template GetMediator<X>(tree);
                    if(NULL != x)
                        return x;
                }
            }
            
            //3) Give up.
            return NULL;
    }
    
    

    //this is implemented here because I could not get it to compile outside of the class declartion
    template<class X> X* GetMediatorFromParent() const 
    {
        //this function should be called when initiating a search.  we create a vector and push this
        //instance into it then call the other GetMediatorFromParent function.
        std::vector<const IPKIFColleague *> tree; 
        return GetMediatorFromParent<X>(&tree);
    }

    //this is implemented here because I could not get it to compile outside of the class declartion
    template<class X> X* GetMediatorFromParent(std::vector<const IPKIFColleague *>* tree) const 
    {
        //this function is called when a search is underway.  push this into the vector and call FindMediator.
        tree->push_back(this);  
        return FindMediator<X>(m_parents, tree);
    }

protected:
    std::vector<IPKIFMediator*> m_parents;
    std::vector<IPKIFMediatorPtr> m_mediators;
private:
    //added 8/21/2004
    IPKIFColleague(const IPKIFColleague& copy);
    IPKIFColleague& operator=(const IPKIFColleague& rhs); 
};
DECLARE_SMART_POINTERS(IPKIFColleague);

template<class X> 
X* IPKIFMediator::GetMediator(
                              std::vector<const IPKIFColleague *>* tree) const
{
    tree->push_back(this);  
    
    //1) See if any of the associated mediators either are or know where to find the desired interface.
    X* x = FindMediator<X>(m_mediators, tree);
    if(NULL != x)
        return x;
    
    //2) Still no luck?  See if our parents can help out.
    return GetMediatorFromParent<X>(tree);
}
template<class X> 
X* IPKIFMediator::GetMediator() const
{
    //first see if this instance is the requested interface (added 12/3/2002)
    X* x = NULL;
    x = dynamic_cast<X*>(const_cast<IPKIFMediator*>(this));
    if(NULL != x)
        return x;
    
    //this function is called when starting a search.  create a vector 
    //for the tree then call the other GetMediator function
    std::vector<const IPKIFColleague *> tree; 
    return GetMediator<X>(&tree);
}

#endif