agent_id.h

Go to the documentation of this file.

#ifndef FIPA_ACL_AGENTID_H
#define FIPA_ACL_AGENTID_H

#include <string>
#include <vector>
#include <iosfwd>
#include <utility>
#include "userdef_param.h"

namespace fipa {

namespace acl {

class AgentID;

// TODO: Recursive container, i.e. container with incomplete type are not supported by 
// standard containers (though it will work for gcc) 
// switch to using boost::container in future
typedef std::vector<AgentID> AgentIDList;

typedef AgentIDList Resolvers;
typedef std::vector<std::string> Addresses;

class AgentID 
{
    friend class ACLMessage;
private:
    std::vector<std::string> mAddresses;

    AgentIDList mResolvers;

    std::vector<UserdefParam> mParameters;


protected:
    std::string mName;

    static const std::string UNDEFINED;

public:

    // depth in the resolver network to compare 2 agent aids; default is 1; 
    static int msResolverComparisonDepth;

    bool isValid() const;
    
    AgentID();
    
    AgentID(const std::string& name);
    
    /* NOTE: setter and getter methods are all the functionality needed so far */
    
    const std::string& getName() const { return mName; }
    
    void setName(const std::string& name);
    
    void addAddress(const std::string &adr);
    
    const std::vector<std::string>& getAddresses() const { return mAddresses; }

    void setAddresses(const std::vector<std::string>& addresses) { mAddresses = addresses; }
    
    void addResolver(const AgentID &aid);
    
    const Resolvers& getResolvers() const { return mResolvers; }

    void setResolvers(const Resolvers& resolvers) { mResolvers = resolvers; }
    
    void deleteResolver(const AgentID& id);
    
    void addUserdefParam(const UserdefParam &p);
    
    const std::vector<UserdefParam>& getUserdefParams() const { return mParameters; }

    void setUserdefParams(const std::vector<UserdefParam>& params) { mParameters = params; }
    
    //static void setResCompDepth(int);
    //static int getResCompDepth();
    
    bool empty() const;

    bool operator==(const AgentID& other) const;

    bool operator!=(const AgentID& other) const { return !(*this == other); }

    bool operator<(const AgentID& other) const { return this->getName() < other.getName(); }

    static bool compareEqual(const AgentID& a, const AgentID& b, int depth);

    std::string toString(size_t indent = 0) const;

};

template< typename C, typename E>
std::basic_ostream<C, E>& operator<<(std::basic_ostream<C,E>& out, const AgentID& agent)
{
    out << "AgentID<" << agent.getName() << ">";
    return out;
}

template< typename C, typename E>
std::basic_ostream<C, E>& operator<<(std::basic_ostream<C,E>& out, const AgentIDList& agents)
{
    AgentIDList::const_iterator cit = agents.begin();
    out << "[";
    for(; cit != agents.end(); ++cit)
    {
        out << *cit;
    }
    out << "]";
    return out;
}

class UndefinedAgentID : public AgentID
{
public:
    UndefinedAgentID();
};

}//end of acl namespace
}// end of fipa namespace
#endif