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