AlpsEncoded.h

Go to the documentation of this file.

#ifndef AlpsEncoded_h
#define AlpsEncoded_h

#include <cstring>
#include <string>
#include <memory>
#include <vector>

#include "CoinError.hpp"

#include "Alps.h"

// AlpsEncoded is modified from BCP_buffer and CoinEncoded

//#############################################################################
//#############################################################################

class AlpsEncoded {  

 private:

    AlpsEncoded(const AlpsEncoded&);
    AlpsEncoded& operator=(const AlpsEncoded&);
    
 private:
    
    size_t pos_;

    size_t maxSize_;

    //std::string type_;   

    int type_;

    int size_;

    // const char* representation_;   //why const ??? XY
    char* representation_;
    
 public:
    

    AlpsEncoded() 
    : 
    pos_(0), 
    maxSize_(0x4000/*16K*/), 
    type_(0), 
    size_(0), 
    representation_(new char[maxSize_]) 
    {}
    
    AlpsEncoded(int t) 
    : 
    pos_(0),
    maxSize_(0), 
    type_(t), 
    size_(0), 
    representation_(0) 
    {}

    AlpsEncoded(int t, int s, char*& r) 
    : 
    pos_(0), 
    maxSize_(s + 4),
    type_(t),  
    size_(s),
    representation_(r) 
    { r = NULL; }                    
    
    ~AlpsEncoded() {
    if (representation_) { 
        delete [] representation_; 
        representation_ = 0; 
    }
    }
    int type() const { return type_; }
    int size() const { return size_; }
    const char* representation() const { return representation_; }

    inline void setPosition(const int pos) {
    if (pos < 0 || pos >= size()) {
        //     const char msg [100] = "Incorrest position setting.";
        //throw AlpsException(__FILE__, __LINE__, msg);
        throw CoinError("Incorrest position setting.", "setPosition",
                "AlpsEncoded");
    }
    pos_ = pos;
    }
  
    inline void setRepresentation(char*& buf) {
        //> 0x4000/*16K*/ ? (strlen(buf)+1) : 0x4000;
    maxSize_ = strlen(buf) + 1;
    representation_ = buf;
    buf = 0; 
    }

    inline void make_fit(const int addSize){
    assert(addSize > 0);
    size_t addSize1 = static_cast<size_t>(addSize);
    
    if (maxSize_ < size_ + addSize1){
        maxSize_ = 4 * (size_ + addSize1 + 0x1000/*4K*/);
        char* newRep = new char[maxSize_];
        if (size_)
        memcpy(newRep, representation_, size_);
        delete[] representation_;
        representation_ = newRep;
    }
    }

    inline void clear(){
    size_ = 0;
    pos_ = 0;
        type_ = 0;
    if (representation_ != 0) { 
        delete  representation_; 
        representation_ = 0; 
    }
    }
    
    //------------------------------------------------------
    // Following functiosn are used in parallel code only.
    //------------------------------------------------------

    template <class T> AlpsEncoded& writeRep(const T& value) {
    make_fit( sizeof(T) );
    memcpy(representation_ + size_, &value, sizeof(T));
    size_ += static_cast<int>(sizeof(T));
    return *this;
    }

    template <class T> AlpsEncoded& readRep(T& value){
#ifdef PARANOID
    if (pos_ + sizeof(T) > size_) {
        throw CoinError("Reading over the end of buffer.", 
                "readRep(const T& value)", "AlpsEncoded");
    }
#endif
    memcpy(&value, representation_ + pos_, sizeof(T));
    pos_ += sizeof(T);
    return *this;
    }


    template <class T> AlpsEncoded& writeRep(const T* const values,
                         const int length){
       make_fit( static_cast<int>(sizeof(int)) +
         static_cast<int>(sizeof(T)) * length );
    memcpy(representation_ + size_, &length, sizeof(int));
    size_ += static_cast<int>(sizeof(int));
    if (length > 0){
        memcpy(representation_ + size_, values,
           static_cast<int>(sizeof(T)) * length);
        size_ += static_cast<int>(sizeof(T)) * length;
    }
    return *this;
    }

    template <class T> AlpsEncoded& readRep(T*& values, 
                        int& length,
                        bool needAllocateMemory = true)
       {
        
    if (needAllocateMemory) {
        // Need allocate memeory for arrary "values".
            
#ifdef PARANOID
        if (pos_ + sizeof(int) > size_) {
        throw CoinError("Reading over the end of buffer.", 
                "readRep(T*& values, int& length,...", 
                "AlpsEncoded");
        }
#endif
        memcpy(&length, representation_ + pos_, sizeof(int));
        pos_ += sizeof(int);
        if (length > 0){
#ifdef PARANOID
        if (pos_ + sizeof(T)*length > size_) {
            throw CoinError("Reading over the end of buffer.", 
                    "readRep(T*& values, int& length,...",
                    "AlpsEncoded");
        }
#endif
        values = new T[length];
        memcpy(values, representation_ + pos_, sizeof(T)*length);
        pos_ += sizeof(T) * length;
        }
        
    } 
    else { /* values has been allocated memory. */

        int l;
#ifdef PARANOID
        if (pos_ + sizeof(int) > size_) {
        throw CoinError("Reading over the end of buffer.", 
                "readRep(T*& values, int& length,...",
                "AlpsEncoded");
        }
#endif
        memcpy(&l, representation_ + pos_, sizeof(int));
        pos_ += sizeof(int);
        if (l != length) {
        throw CoinError("Reading over the end of buffer.", 
                "readRep(T*& values, int& length,...", 
                "AlpsEncoded");
        }
        if (length > 0){
#ifdef PARANOID
        if (pos_ + sizeof(T)*length > size_) {
            throw CoinError("Reading over the end of buffer.", 
                    "readRep(T*& values, int& length,...",
                    "AlpsEncoded");
        }
#endif
        memcpy(values, representation_ + pos_, sizeof(T)*length);
        pos_ += sizeof(T) * length;
        }       
    }
    
    return *this;
    }

    AlpsEncoded& writeRep(std::string& value){
    // must define here, 'cos in *_message.C we have only templated members
    const int len = static_cast<const int> (value.length());
    make_fit( static_cast<int>(sizeof(int)) + len );
    memcpy(representation_ + size_, &len, static_cast<int>(sizeof(int)));
    size_ += static_cast<int>(sizeof(int));
    if (len > 0){
        memcpy(representation_ + size_, value.c_str(), len);
        size_ += len;
    }
    return *this;
    }

    AlpsEncoded& readRep(std::string& value){
    int len;
    readRep(len);
    value.assign(representation_ + pos_, len);
    pos_ += len;
    return *this;
    }
    
    template <class T> AlpsEncoded& writeRep(const std::vector<T>& vec) {
    int objnum = vec.size();
    int new_bytes = objnum * sizeof(T);
    make_fit( sizeof(int) + new_bytes );
    memcpy(representation_ + size_, &objnum, sizeof(int));
    size_ += sizeof(int);
    if (objnum > 0){
        memcpy(representation_ + size_, &vec[0], new_bytes);
        size_ += new_bytes;
    }
    return *this;
   }
    
   template <class T> AlpsEncoded& readRep(std::vector<T>& vec) {
       int objnum;
#ifdef PARANOID
       if (pos_ + sizeof(int) > size_)
       throw CoinError("Reading over the end of buffer.", 
               "AlpsEncoded", "readRep(std::vector<T>& vec");
#endif
       memcpy(&objnum, representation_ + pos_, sizeof(int));
       pos_ += sizeof(int);
       vec.clear();
       if (objnum > 0){
#ifdef PARANOID
       if (pos_ + sizeof(T)*objnum > size_)
           throw CoinError("Reading over the end of buffer.", 
                   "AlpsEncoded", "readRep(std::vector<T>& vec");
#endif
       vec.insert(vec.end(), objnum, T());
       memcpy(&vec[0], representation_ + pos_, objnum * sizeof(T));
       pos_ += objnum * sizeof(T);
       }
       return *this;
   }
};

#endif