Encoding.h

Go to the documentation of this file.

#ifndef CASTOR_ENCODING_H
#define CASTOR_ENCODING_H 1

#include <endian.h>

#include <vector>

#include "NetAddress.h"
#include "Types.h"

namespace castor {

//      typedef std::vector<char> Bytes;
//      typedef boost::shared_ptr<Bytes> BytesPtr;
        typedef enum { endian_undefined = -1, endian_little = 0, endian_big = 1 } Endianness;

        class Encoder;
        typedef boost::shared_ptr<Encoder> EncoderPtr;

        class Decoder;
        typedef boost::shared_ptr<Decoder> DecoderPtr;

        template <class T>
                class Encoding {

                        protected:

                                Encoding() {
                                }
        
                        public:
        
                                static EncoderPtr createEncoder() {
                                        return EncoderPtr(new T);
                                }

                                static DecoderPtr createDecoder(const BytesPtr data, size_t offset = 0) {
                                        return DecoderPtr(new T(data, offset));
                                }

                                static DecoderPtr createDecoder(const char *data, size_t length) {
                                        return DecoderPtr(new T(data, length));
                                }

                                static DecoderPtr createDecoder(const char *data, size_t offset, size_t length) {
                                        return DecoderPtr(new T(data, offset, length));
                                }

                };

        Endianness endianness();

        class Encoder {

                protected:

                        EncoderPtr next;

                public:

                        Encoder() : next() {
                        }

                        virtual ~Encoder() {
                        }

                        virtual EncoderPtr createEncoder() = 0;

                        virtual DecoderPtr createDecoder(const BytesPtr x, size_t offset = 0) = 0;
                        virtual DecoderPtr createDecoder(const char *x, size_t length) = 0;
                        virtual DecoderPtr createDecoder(const char *x, size_t offset, size_t length) = 0;

                        void setNext(EncoderPtr value) {
                                this->next = value;
                        }

                        EncoderPtr getNext() {
                                return this->next;
                        }

                        virtual void switchEndianness(bool yes) = 0;

                        virtual const char *getBuffer() = 0;

                        virtual size_t getLength() = 0;
                        virtual size_t getPosition() = 0;

                        virtual BytesPtr getBytes() = 0;

                        virtual void mark() = 0;
                        virtual void commit() = 0;
                        virtual void rollback() = 0;
                        virtual void reset() = 0;

                        virtual void seek(long offset) = 0;
                        virtual void encLength(size_t x) = 0;
                        virtual void encBool(bool x) = 0;
                        virtual void encInt8(char x) = 0;
                        virtual void encUInt8(unsigned char x) = 0;
                        virtual void encInt16(short x) = 0;
                        virtual void encUInt16(unsigned short x) = 0;
                        virtual void encInt32(long x) = 0;
                        virtual void encUInt32(unsigned long x) = 0;
                        virtual void encInt64(long long x) = 0;
                        virtual void encUInt64(unsigned long long x) = 0;
                        virtual void encFloat(float x) = 0;
                        virtual void encDouble(double x) = 0;
                        virtual void encString(const std::string x) = 0;
                        virtual void encAddress(const castor::net::NetAddress &x) = 0;
                        virtual void encBytes(const Bytes &x) = 0;
                        virtual void encBytes(const Bytes &x, size_t offset, size_t length) = 0;
                        virtual void encBytes(const char *x, size_t length) = 0;
                        virtual void encBytes(const char *x, size_t offset, size_t length) = 0;
        };

        class Decoder {

                public:

                        Decoder() {
                        }

                        Decoder(const BytesPtr x, size_t offset = 0);
                        Decoder(const char *x, size_t length);
                        Decoder(const char *x, size_t offset, size_t length);

                        virtual ~Decoder() {
                        }

                        virtual EncoderPtr createEncoder() = 0;

                        virtual DecoderPtr createDecoder(const BytesPtr x, size_t offset = 0) = 0;
                        virtual DecoderPtr createDecoder(const char *x, size_t length) = 0;
                        virtual DecoderPtr createDecoder(const char *x, size_t offset, size_t length) = 0;

                        virtual void switchEndianness(bool yes) = 0;

                        virtual const char *getBuffer() = 0;

                        virtual size_t getLength() = 0;
                        virtual size_t getPosition() = 0;

                        virtual BytesPtr getBytes() = 0;

                        virtual void mark() = 0;
                        virtual void commit() = 0;
                        virtual void rollback() = 0;
                        virtual void reset() = 0;

                        virtual void seek(long offset) = 0;

                        virtual size_t decLength() = 0;
                        virtual bool decBool() = 0;
                        virtual char decInt8() = 0;
                        virtual unsigned char decUInt8() = 0;
                        virtual short decInt16() = 0;
                        virtual unsigned short decUInt16() = 0;
                        virtual long decInt32() = 0;
                        virtual unsigned long decUInt32() = 0;
                        virtual long long decInt64() = 0;
                        virtual unsigned long long decUInt64() = 0;
                        virtual float decFloat() = 0;
                        virtual double decDouble() = 0;
                        virtual std::string decString() = 0;
                        virtual castor::net::NetAddress decAddress() = 0;
                        virtual BytesPtr decBytes(size_t length) = 0;

        };


}

#endif /* CASTOR_ENCODING_H */