acl_envelope.h

Go to the documentation of this file.

#ifndef FIPA_ACL_MESSAGE_ENVELOPE_H
#define FIPA_ACL_MESSAGE_ENVELOPE_H

#include <stdint.h>
#include <fipa_acl/message_generator/acl_message.h>
#include <fipa_acl/message_generator/received_object.h>
#include <fipa_acl/message_generator/types.h>

namespace fipa {
namespace acl {

typedef std::string Comments;
typedef uint32_t PayloadLength;
typedef std::string PayloadEncoding;
typedef std::string ACLRepresentation;
typedef std::string TransportBehaviour;
typedef std::vector<ReceivedObject> ReceivedObjectList;

class ACLBaseEnvelope;
typedef std::vector<ACLBaseEnvelope> ACLBaseEnvelopeList;

namespace envelope {

    // Parameter id to allow checking whether certain field in an envelope
    // have been set
    enum ParameterId { NONE = 0x00, TO = 0x01, FROM = 0x02, COMMENTS = 0x04,
ACL_REPRESENTATION = 0x08, PAYLOAD_LENGTH = 0x10, PAYLOAD_ENCODING = 0x20, DATE = 0x40, INTENDED_RECEIVERS = 0x80, RECEIVED_OBJECT = 0x0100, TRANSPORT_BEHAVIOUR = 0x0200, USERDEFINED_PARAMETERS = 0x0400, PARAMETER_END = 0x0800};
}

class ACLBaseEnvelope
{
private:
    envelope::ParameterId mParameters;

    AgentIDList mTo;

    AgentID mFrom;

    Comments mComments;

    representation::Type mACLRepresentation;

    PayloadLength mPayloadLength;

    PayloadEncoding mPayloadEncoding;

    base::Time mDate;

    AgentIDList mIntendedReceivers;

    ReceivedObject mReceivedObject;

    TransportBehaviour mTransportBehaviour;

    UserdefinedParameterList mUserdefinedParameters;

public:
    ACLBaseEnvelope();

    bool contains(envelope::ParameterId id) const { return mParameters & id; }

    const AgentIDList& getTo() const { return mTo; }

    void addTo(const AgentID& agent);

    void setTo(const AgentIDList& receivers);

    bool removeTo(const AgentID& agentId);

    void clearAllTo() { mTo.clear(); }

    const AgentID& getFrom() const { return mFrom; }

    void setFrom(const AgentID& from);

    const Comments& getComments() const { return mComments; }

    void setComments(const Comments& comments);

    const representation::Type& getACLRepresentation() const { return mACLRepresentation; }

    const std::string& getACLRepresentationString() const { return representation::TypeTxt[mACLRepresentation]; }

    void setACLRepresentation(representation::Type representation);

    void setACLRepresentation(const std::string& represention);

    const PayloadLength& getPayloadLength() const { return mPayloadLength; }

    void setPayloadLength(const PayloadLength& length);

    const PayloadEncoding& getPayloadEncoding() const { return mPayloadEncoding; }

    void setPayloadEncoding(const PayloadEncoding& encoding);

    const base::Time& getDate() const { return mDate; }

    void setDate(const base::Time& date);

    const AgentIDList& getIntendedReceivers() const { return mIntendedReceivers; }

    void setIntendedReceivers(const AgentIDList& receivers);

    void addIntendedReceiver(const AgentID& agent);

    bool removeIntendedReceiver(const AgentID& agent);

    void clearAllIntendedReceivers() { mIntendedReceivers.clear(); }

    const ReceivedObject& getReceivedObject() const { return mReceivedObject; }

    void setReceivedObject(const ReceivedObject& receivedObject);

    bool hasReceivedObject(const ReceivedObject& receivedObject) const;

    const TransportBehaviour& getTransportBehaviour() const { return mTransportBehaviour; }

    void setTransportBehaviour(const TransportBehaviour& transportBehaviour);

    const UserdefinedParameterList& getUserdefinedParameters() const { return mUserdefinedParameters; }

    void setUserdefinedParameters(const UserdefinedParameterList& parameters);

    ACLBaseEnvelope merge(const ACLBaseEnvelope& other) const;

    ACLBaseEnvelope flatten(const ACLBaseEnvelopeList& extraEnvelopes) const;

    void stamp(const ReceivedObject& receivedObject) { setReceivedObject(receivedObject); }

    bool hasStamp(const ReceivedObject& receivedObject) const { return hasReceivedObject(receivedObject); }

};


class EnvelopeFormat;
class ACLEnvelope
{
    friend class EnvelopeFormat;

    ACLBaseEnvelopeList mExtraEnvelopes;

    ACLBaseEnvelope mBaseEnvelope;

    // The payload data that is transported within this envelope
    std::string mPayload;

    static uint32_t mStampCounter;

    static ID createLocalId();

public:

    ACLEnvelope();

    ACLEnvelope(const ACLMessage& msg, const fipa::acl::representation::Type& format);

    void insert(const ACLMessage& msg, const fipa::acl::representation::Type& format);

    const ACLBaseEnvelopeList& getExtraEnvelopes() const { return mExtraEnvelopes; }

    void addExtraEnvelope(const ACLBaseEnvelope& envelope)  { mExtraEnvelopes.push_back(envelope); }

    void setExtraEnvelopes(const ACLBaseEnvelopeList& envelopes) { mExtraEnvelopes = envelopes; }

    const ACLBaseEnvelope& getBaseEnvelope() const { return mBaseEnvelope; }

    void setBaseEnvelope(const ACLBaseEnvelope& envelope) { mBaseEnvelope = envelope; }

    ACLBaseEnvelope flattened() const { return mBaseEnvelope.flatten(mExtraEnvelopes); }

    AgentIDList getDeliveryPath() const;

    std::string getDeliveryPathString() const;

    void setPayload(const std::string& payload) { mPayload = payload; }

    const std::string& getPayload() const { return mPayload; }

    fipa::acl::ACLMessage getACLMessage() const;

    void stamp(const fipa::acl::AgentID& id);

    bool hasStamp(fipa::acl::AgentID id) const;

    ACLEnvelope createDedicatedEnvelope(const AgentID& receiverId) const;
};

typedef ACLEnvelope Letter;

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