CNER.h

Go to the documentation of this file.

#ifndef CASTOR_ENCODING_CNER_H
#define CASTOR_ENCODING_CNER_H 1

#include <sstream>
#include <iostream>

#include "Encoding.h"
#include "EncodingException.h"

namespace castor { namespace encoding {

        class CNER : public Encoder, public Decoder {

                private:

                        std::stringstream buffer;

                        bool doSwitchEndian;

                        bool marked;
                        size_t marker;

                        size_t length;

                        inline void writeInternal(const char *data, size_t length, bool ignoreEndian = false) {

                                if (this->mode != encode) return;

                                if ((this->doSwitchEndian) && (!ignoreEndian)) {

                                        if (length > 0) {
                                                char temp[length];
                                                for (int i = length - 1; i >= 0; i--) {
                                                        temp[i] = data[(length - 1) - i];
                                                }
                                                this->buffer.write(temp, length);
//                                                      this->buffer.put(data[i]);
//                                              }
                                        }

                                } else {
                                        this->buffer.write(data, length);

//                                      for (size_t i = 0; i < length; i++) {
//                                              this->buffer.put(data[i]);
//                                      }
                                }
                        }

                        inline void readInternal(char *data, size_t length, bool ignoreEndian = false) {

                                if (this->mode != decode) return;

                                if ((this->doSwitchEndian) && (!ignoreEndian)) {

                                        if (length > 0) {
                                                char temp[length];
                                                this->buffer.read(temp, length);

                                                for (int i = length - 1; i >= 0; i--) {
                                                        data[i] = temp[(length - 1) - i];
//                                                      this->buffer.get();
                                                }
                                        }

                                } else {
                                        this->buffer.read(data, length);

//                                      for (size_t i = 0; i < length; i++) {
//                                              data[i] = this->buffer.get();
//                                      }
                                }
                        }

                        enum { encode, decode } mode;

                public:
        
                        CNER() :
                                buffer(std::ios_base::out), doSwitchEndian(false),
                                marked(false), marker(0), length(0), mode(encode)
                        {
                        }

                        CNER(const BytesPtr x, size_t offset) :
                                buffer(std::string(x->begin() + offset, x->end()), std::ios_base::in),
                                doSwitchEndian(false), marked(false), marker(0), length(x->size()), mode(decode)
                        {
                        }

                        CNER(const char *x, size_t length) :
                                buffer(std::string(x, length), std::ios_base::in),
                                doSwitchEndian(false), marked(false), marker(0), length(length), mode(decode)
                        {
                        }

                        CNER(const char *x, size_t offset, size_t length) :
                                buffer(std::string(std::string(x, length), offset),
                                        std::ios_base::in),
                                doSwitchEndian(false), marked(false), marker(0), length(length), mode(decode)
                        {
                        }

                        ~CNER() { }

                        inline EncoderPtr createEncoder() {
                                return EncoderPtr(new CNER());
                        }

                        inline DecoderPtr createDecoder(const BytesPtr x, size_t offset = 0) {
                                return DecoderPtr(new CNER(x, offset));
                        }

                        inline DecoderPtr createDecoder(const char *x, size_t length) {
                                return DecoderPtr(new CNER(x, length));
                        }

                        DecoderPtr createDecoder(const char *x, size_t offset, size_t length) {
                                return DecoderPtr(new CNER(x, offset, length));
                        }

                        inline void switchEndianness(bool yes) {
                                this->doSwitchEndian = yes;
                        }

                        inline size_t getLength() {

                                size_t length = 0;

                                if (this->mode == encode) {

                                        size_t pos = this->buffer.tellp();

                                        this->buffer.seekp(0, std::ios::end);
                                        length = this->buffer.tellp();
                                        this->buffer.seekp(pos, std::ios::beg);

                                } else {

                                        size_t pos = this->buffer.tellg();

                                        this->buffer.seekg(0, std::ios::end);
                                        length = this->buffer.tellg();
                                        this->buffer.seekg(pos, std::ios::beg);
                                }

                                return length;
                        }

                        inline size_t getPosition() {
                                return (this->mode == encode ?
                                                this->buffer.tellp() :
                                                this->buffer.tellg());
                        }

                        inline const char *getBuffer() {
                                return this->buffer.str().c_str();
                        }

                        inline BytesPtr getBytes() {
                                std::string x = this->buffer.str();
                                return BytesPtr(new Bytes(x.begin(), x.end()));
                        }

                        inline void mark() {
                                this->marked = true;
                                this->marker = getPosition();
                        }

                        inline void commit() {
                                this->marked = false;
                                this->marker = 0;
                        }
                        
                        inline void rollback() {
                        
                                if (this->mode == encode) {
                                        this->buffer.seekp(this->marker, std::ios_base::beg);
                                } else {
                                        this->buffer.seekg(this->marker, std::ios_base::beg);
                                }
                                this->marked = false;
                                this->marker = 0;
                        }

                        inline void reset() {
                                if (this->mode == encode) {
                                        this->buffer.str("");
                                } else {
                                        this->buffer.seekg(0, std::ios_base::beg);
                                }

                                this->buffer.clear();
                                this->marked = false;
                                this->marker = 0;
                        }

                        inline void seek(long offset) {
                                if (this->mode == encode) {
                                        this->buffer.seekp(offset, std::ios_base::cur);
                                } else {
                                        this->buffer.seekg(offset, std::ios_base::cur);
                                }
                        }

                        inline void encLength(size_t x) {

                                if (this->mode != encode) throw EncodingException("wanted to encode while being in decode mode");

                                if (x == 0) {
                                        this->buffer.put(0);
                                        return;
                                }

                                while (x > 0) {

                                        // Get the lowest 7 bits
                                        char c = (char)(x & 0x7f);

                                        // Remove these bits
                                        x >>= 7;

                                        // Write them down to the stream.
                                        // If the highest order bit is '1', there are more bytes coming.
                                        // We're processing the last byte if the highest order bit is '0'
                                        this->buffer.put((x == 0 ? c : (c | 0x80)));
                                }
                        }

                        inline void encBool(bool x) {
                                if (this->mode != encode) return;
                                this->buffer.put((char)x);
                        }

                        inline void encInt8(char x) {
                                if (this->mode != encode) return;
                                this->buffer.put(x);
                        }

                        inline void encUInt8(unsigned char x) {
                                if (this->mode != encode) return;
                                this->buffer.put((char)x);
                        }

                        inline void encInt16(short x) {
                                writeInternal((char *)&x, 2);
                        }

                        inline void encUInt16(unsigned short x) {
                                writeInternal((char *)&x, 2);
                        }

                        inline void encInt32(long x) {
                                writeInternal((char *)&x, 4);
                        }

                        inline void encUInt32(unsigned long x) {
                                writeInternal((char *)&x, 4);
                        }

                        inline void encInt64(long long x) {
                                writeInternal((char *)&x, 8);
                        }

                        inline void encUInt64(unsigned long long x) {
                                writeInternal((char *)&x, 8);
                        }

                        inline void encFloat(float x) {
                                writeInternal((char *)&x, 4);
                        }

                        /*inline void encDouble(double x) {
                                writeInternal((char *)&x, 8);
                        }*/
                        inline void encDouble(double x) {
                                float y = (float)x;
                                writeInternal((char *)&y, 4);
                        }

                        inline void encString(const std::string x) {
                                if (this->mode != encode) return;
                                encLength(x.size());
                                writeInternal(x.c_str(), x.size(), true);
                        }

                        inline void encAddress(const castor::net::NetAddress &x) {

                                if (this->mode != encode) return;
                                BytesPtr b = x.getBytes();
                                encLength(b->size());
                                writeInternal(&((*b)[0]), b->size(), true);
                        }

                        inline void encBytes(const Bytes &x) {
                                writeInternal(&x[0], x.size(), true);
                        }

                        inline void encBytes(const Bytes &x, size_t offset, size_t length) {
                                if (this->mode != encode) return;

                                if (length + offset > x.size()) {
                                        throw EncodingException("CNER: offset + length > x.size()");
                                }
                                writeInternal(&x[offset], length, true);
                        }

                        inline void encBytes(const char *x, size_t length) {
                                writeInternal(x, length, true);
                        }

                        inline void encBytes(const char *x, size_t offset, size_t length) {
                                writeInternal(&(x[offset]), length, true);
                        }

                        inline size_t decLength() {
                                if (this->mode != decode) return 0;

                                int bitsRead = 0;
                                size_t result = 0;
                                char c = 0;

                                // Read until the end of the length field is reached
                                do {

                                        c = this->buffer.get();

                                        // If more than 9 bytes were read (9 * 7 Bit = 63 Bit), abort
                                        if (bitsRead >= 64) {
                                                throw EncodingException("CNER: length field overflow (> 2^64)");
                                        }

                                        result |= (static_cast<size_t>(c & 0x7f) << bitsRead);
                                        bitsRead += 7;

                                        // Continue until the highest ordered bit is 0

                                } while ((c & 0x80) != 0);

                                return result;
                        }

                        inline bool decBool() {
                                if (this->mode != decode) return false;
                                return static_cast<bool>(this->buffer.get());
                        }

                        inline char decInt8() {
                                if (this->mode != decode) return 0;
                                return this->buffer.get();
                        }

                        inline unsigned char decUInt8() {
                                if (this->mode != decode) return 0;
                                return static_cast<unsigned char>(this->buffer.get());
                        }

                        inline short decInt16() {
                                short x = 0;
                                readInternal((char *)&x, 2);
                                return x;
                        }

                        inline unsigned short decUInt16() {
                                unsigned short x = 0;
                                readInternal((char *)&x, 2);
                                return x;
                        }

                        inline long decInt32() {
                                long x = 0;
                                readInternal((char *)&x, 4);
                                return x;
                        }

                        inline unsigned long decUInt32() {
                                unsigned long x = 0;
                                readInternal((char *)&x, 4);
                                return x;
                        }

                        inline long long decInt64() {
                                long long x = 0;
                                readInternal((char *)&x, 8);
                                return x;
                        }

                        inline unsigned long long decUInt64() {
                                unsigned long long x = 0;
                                readInternal((char *)&x, 8);
                                return x;
                        }

                        inline float decFloat() {
                                float x = 0;
                                readInternal((char *)&x, 4);
                                return x;
                        }

                        /*inline double decDouble() {
                                double x = 0;
                                readInternal((char *)&x, 8);
                                return x;
                        }*/
                        inline double decDouble() {
                                float x = 0;
                                readInternal((char *)&x, 4);
                                return (double)x;
                        }
                        
                        inline std::string decString() {
                                size_t length = decLength();
                                char x[length];
                                readInternal(x, length, true);
                                return std::string(x, length);
                        }

                        inline castor::net::NetAddress decAddress() {
                                if (this->mode != decode) return castor::net::NetAddress();

                                size_t length = decLength();
                                BytesPtr x(new Bytes(length, 0));
                                readInternal(&((*x)[0]), length, true);
                                return castor::net::NetAddress(x);
                        }

                        inline BytesPtr decBytes(size_t length) {
                                if (this->mode != decode) return BytesPtr();
                                BytesPtr x(new Bytes(length, 0));
                                readInternal(&((*x)[0]), length, true);
                                return x;
                        }
        };

} }

#endif /* CASTOR_ENCODING_CNER_H */