Messages.h

Go to the documentation of this file.

#ifndef CASTOR_MESSAGES_H
#define CASTOR_MESSAGES_H 1

#include <string>
#include <boost/shared_ptr.hpp>

#include "Messages.h"
#include "Encryption.h"
#include "Authentication.h"
#include "Encoding.h"
#include "Identity.h"

using namespace castor::spica::security;

namespace castor { namespace spica {

        class Container;
        class Message;

        typedef boost::shared_ptr<Container> ContainerPtr;
        typedef boost::shared_ptr<Message> MessagePtr;

        class Container {

                protected:

                        bool modified;
                        bool empty;

                        Identity id;

                public:

                        Container() : modified(true), empty(true), id() {
                        }

                        virtual ~Container() {
                        }

                        bool isModified()                       { return this->modified; }
                        void isModified(bool value)     { this->modified = value; }
                        void touch()                            { this->modified = true; }

                        bool isEmpty()                          { return this->empty; }
                        void isEmpty(bool value)        { this->empty = value; }

                        virtual std::string concept() = 0;
                        virtual std::string rep() = 0;

                        virtual const Identity &identity()      { return this->id; };

                        virtual unsigned int messageType() = 0;
                        virtual unsigned int messageType(castor::DecoderPtr dec) = 0;
        
                        virtual ContainerPtr hierarchyTop() = 0;

                        virtual void encode(castor::EncoderPtr enc) = 0;
                        virtual void encodeHeader(castor::EncoderPtr enc) = 0;
                        virtual void encodeBody(castor::EncoderPtr enc) = 0;

                        virtual void decode(castor::DecoderPtr dec) = 0;
                        virtual void decodeHeader(castor::DecoderPtr dec) = 0;
                        virtual void decodeBody(castor::DecoderPtr dec) = 0;

                        virtual ContainerPtr decodeAny(castor::DecoderPtr dec) = 0;

                        virtual ContainerPtr clone() = 0;

                        virtual void copyTo(ContainerPtr message) = 0;
                        virtual void copyHeaderTo(ContainerPtr message) = 0;
                        virtual void copyBodyTo(ContainerPtr message) = 0;

                        virtual std::string toString() = 0;

                        virtual void clear() = 0;

                        virtual std::string dump() = 0;

                        virtual int hashcode() const = 0;

                        virtual int compareTo(ContainerPtr other) const = 0;

                        template<typename T>
                                bool equals(T other) {
                                        if (typeid(this) != typeid(other)) return false;
                                        return (this->compareTo(other) == 0);
                                }
        };

        class Message : public Container {

                protected:

                        AuthServicePtr authService;
                        AuthResult authResult;

                        EncryptServicePtr encryptService;
                        EncryptResult encryptResult;

                        int mtu;

                public:

                        Message() :
                                authService(), authResult(castor::spica::security::auth_unknown),
                                encryptService(), encryptResult(castor::spica::security::enc_unknown), mtu(64000)
                        {
                        }

                        virtual ~Message() {
                        }

                        virtual bool decodePart(castor::DecoderPtr dec) = 0;
                        
                        virtual MessagePtr decodeAnyPart(castor::DecoderPtr dec) = 0;

                        virtual MessagePtr createInstance(unsigned int id) = 0;
                        virtual MessagePtr createInstance(const std::string name) = 0;
                        virtual MessagePtr createInstance(const std::string concept, const std::string rep) = 0;
        
                        virtual std::string typeToSemantic(unsigned int type) = 0;
                        virtual std::vector<unsigned int> semanticToTypes(const std::string key) = 0;

                        // Authentication
                        virtual bool isAuthSupported() = 0;
                        virtual void authVerify() = 0;
                        AuthResult getAuthResult()                                              { return this->authResult; }
                        AuthServicePtr getAuthService()                                 { return this->authService; }
                        void setAuthService(AuthServicePtr value)               { this->authService = value; }

                        // Encryption
                        virtual bool isEncryptSupported() = 0;
                        EncryptResult getEncryptResult()                                { return this->encryptResult; }
                        EncryptServicePtr getEncryptService()                   { return this->encryptService; }
                        void setEncryptService(EncryptServicePtr value) { this->encryptService = value; }

                        // Framentation
                        virtual bool isFragSupported() = 0;
                        virtual int getFragmentId() = 0;
                        virtual int getFragmentId(castor::DecoderPtr dec) = 0;
                        int getMtu()                                                                    { return this->mtu; }
                        void setMtu(int value)                                                  { this->mtu = value; }
        };

} }

#endif /* CASTOR_MESSAGES_H */