* MessageBlock.h
 *
 *  Created on: Aug 11, 2012
 *      Author: archy_yu
 */

#ifndef MESSAGEBLOCK_H_
#define MESSAGEBLOCK_H_

#include <TlvPackage.h>
#include <string>

class MessageBlock
{
public:
    MessageBlock(int =0);
    /*
    MessageBlock(short tag,short len);
    MessageBlock(TLVEntity paraTlvEntity);
    */

MessageBlock(MessageBlock &mb);

/*
    MessageBlock(char* msg,int len);
    MessageBlock(std::string str);
    */
    virtual ~MessageBlock();

MessageBlock& operator << (const char &value);
    MessageBlock& operator << (const short &value);
    MessageBlock& operator << (const int &value);
    MessageBlock& operator << (const char* ss);

MessageBlock& operator >> (char &value);
    MessageBlock& operator >> (short &value);
    MessageBlock& operator >> (int &value);
    MessageBlock& operator >> (char* ss);

void set_len();
    int get_len();
    char* wr_ptr();
    char* rd_ptr();
    int Capacity();

private:
    int wr_position;
    int rd_position;
    int capacity;
    int len;
    char* data;
};
#endif /* MESSAGEBLOCK_H_ */

/*
 * MessageBlock.cpp
 *
 *  Created on: Aug 11, 2012
 *      Author: archy_yu
 */

#include <stdlib.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "MessageBlock.h"

MessageBlock::MessageBlock(int n)
{
    wr_position = 0;
    rd_position = 0;
    len = 0;
    this->data = (char *)calloc(n > 0 ? n : 1024,sizeof(char));
    this->capacity = n > 0 ? n : 1024;
}

/*
MessageBlock::MessageBlock(short tag,short len)
{
    this->dataindex = 0;
    this->len = len;
    this->data = (char *)calloc(len,sizeof(char));
    if(this->data == NULL)
    {
        //error
    }
}

MessageBlock::MessageBlock(TLVEntity paraTlvEntity)
{
    this->dataindex = 0;
    this->len = paraTlvEntity.Length;
    this->data = (char* )calloc(paraTlvEntity.Length,sizeof(char));
    if(this->data == NULL)
    {
        //error
    }
    memcpy(this->data,paraTlvEntity.Value,paraTlvEntity.Length);
}
*/
MessageBlock::MessageBlock(MessageBlock &mb)
{
    this->data = mb.data;
    this->len = mb.len;
    this->capacity = mb.capacity;
    this->rd_position = mb.rd_position;
    this->wr_position = mb.wr_position;
}

/*
MessageBlock::MessageBlock(char* msg,int len)
{
    this->data = (msg);
    this->len = len;
    this->dataindex = 0;
}

MessageBlock::MessageBlock(std::string str)
{
    this->data = const_cast<char* >(str.c_str());
    this->len = str.size();
    this->dataindex = 0;
}
*/
MessageBlock::~MessageBlock()
{
    // TODO Auto-generated destructor stub
    free(this->data);
}

MessageBlock& MessageBlock::operator << (const char &value)
{
    if((wr_position + sizeof(char)) > this->capacity)
    {
        this->data = (char* )realloc(this->data,wr_position + sizeof(char));

if(this->data == NULL)
        {
            return *this;
        }
        this->capacity = this->wr_position + sizeof(char);
    }

*((char* )(this->data + wr_position )) = value;
    wr_position += sizeof(char);
    len = wr_position ;

return *this;
}

MessageBlock& MessageBlock::operator <<(const short &value)
{
    if((wr_position + sizeof(short)) > this->len)
    {
        this->data = (char* )realloc(this->data,wr_position + sizeof(short));
        if(this->data == NULL)
        {
            return *this;
        }
        this->capacity = this->wr_position + sizeof(short);
    }

*((short* )( this->data + wr_position )) = value;
    wr_position += sizeof(short);
    len = wr_position;

return *this;
}

MessageBlock& MessageBlock::operator <<(const int &value)
{
    if((wr_position + sizeof(int)) > this->len)
    {
        this->data = (char *)realloc(this->data,wr_position + sizeof(int));
        if(this->data == NULL)
        {
            return *this;
        }
        this->capacity  = this->wr_position + sizeof(int);
    }

*((int* )( this->data + wr_position )) = value;
    wr_position += sizeof(int);
    this->len = wr_position;

return *this;
}

MessageBlock& MessageBlock::operator <<(const char* ss)
{

short len = strlen(ss);

if((wr_position + 2 + len) > this->len)
    {
        this->data = (char *)realloc(this->data,wr_position + 2 + strlen(ss));
        if(this->data == NULL)
        {
            return *this;
        }
        this->capacity = this->wr_position + 2 + strlen(ss);
    }

*((short* )(this->data + wr_position)) = len;
    wr_position += sizeof(len);
    this->len = wr_position;

memcpy(this->data + wr_position,ss,len);
    wr_position += len;
    this->len = wr_position;
    return *this;
}

MessageBlock& MessageBlock::operator >>(char &value)
{
    if((rd_position + sizeof(char)) > this->len)
    {
        return *this;
    }

value = *((char* )(this->data + rd_position ));
    rd_position += sizeof(char);

return *this;
}

MessageBlock& MessageBlock::operator >>(short &value)
{
    if((rd_position + sizeof(short)) > this->len)
    {
        return *this;
    }

value = *((short* )(this->data + rd_position ));
    rd_position += sizeof(short);

return *this;
}

MessageBlock& MessageBlock::operator >>(int &value)
{
    if((rd_position + sizeof(short)) > this->len)
    {
        return *this;
    }
    value = *((int* )(this->data + rd_position));
    rd_position += sizeof(int);
    return *this;
}

MessageBlock& MessageBlock::operator >>(char* ss)
{
    short len = *((short* )(this->data + rd_position));

if( (this->rd_position + sizeof(len) + len) > (this->len) )
    {
        return *this;
    }

rd_position += sizeof(len);
    memcpy(ss,this->data + rd_position,len);
    ss[len] = '\0';
    rd_position += len;
    return *this;
}

char* MessageBlock::wr_ptr()
{
    return this->data + wr_position;
}

char* MessageBlock::rd_ptr()
{
    return this->data + rd_position;
}

int MessageBlock::Capacity()
{
    return this->capacity;
}

void MessageBlock::set_len()
{
    (*(short *)(this->data)) = this->wr_position;
}

int MessageBlock::get_len()
{
    return this->len;}