AlpsEncoded.h

Go to the documentation of this file.

/*===========================================================================*
 * This file is part of the Abstract Library for Parallel Search (ALPS).     *
 *                                                                           *
 * ALPS is distributed under the Eclipse Public License as part of the       *
 * COIN-OR repository (http://www.coin-or.org).                              *
 *                                                                           *
 * Authors:                                                                  *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Aykut Bulut, Lehigh University                                   *
 *          Ted Ralphs, Lehigh University                                    *
 *                                                                           *
 * Conceptual Design:                                                        *
 *                                                                           *
 *          Yan Xu, Lehigh University                                        *
 *          Ted Ralphs, Lehigh University                                    *
 *          Laszlo Ladanyi, IBM T.J. Watson Research Center                  *
 *          Matthew Saltzman, Clemson University                             *
 *                                                                           *
 *                                                                           *
 * Copyright (C) 2001-2023, Lehigh University, Yan Xu, Aykut Bulut, and      *
 *                          Ted Ralphs.                                      *
 * All Rights Reserved.                                                      *
 *===========================================================================*/
 
 
#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