PABLO: fix markers communication

src/PABLO/ParaTree.cpp

@@ -6008,7 +6008,7 @@ namespace bitpit {
             std::size_t buffSize = nRankBorders * MARKER_ENTRY_BINARY_SIZE;
             markerCommunicator.setSend(rank, buffSize);
 
-            SendBuffer sendBuffer = markerCommunicator.getSendBuffer(rank);
+            SendBuffer &sendBuffer = markerCommunicator.getSendBuffer(rank);
             for(std::size_t i = 0; i < nRankBorders; ++i){
                 const Octant &octant = m_octree.m_octants[rankBordersPerProc[i]];
                 sendBuffer << octant.getMarker();

src/communications/communications_buffers.cpp

@@ -52,6 +52,18 @@ void SendBuffer::squeeze()
     }
 }
 
+/*!
+* Write data into the buffer.
+*
+* \param[in] data is the memory that contain the data
+* \param[in] size is the size (in bytes) of the data to be written into
+* the stream
+*/
+void SendBuffer::write(const char *data, std::size_t size)
+{
+    getFront().write(data, size);
+}
+
 /*!
     \class RecvBuffer
     \ingroup communications
@@ -67,4 +79,16 @@ RecvBuffer::RecvBuffer(size_t size, bool doubleBuffer)
 {
 }
 
+/*!
+* Read data from the buffer.
+*
+* \param[out] data is the memory location that will contain the data
+* \param[in] size is the size (in bytes) of the data to be read from the
+* stream
+*/
+void RecvBuffer::read(char *data, std::size_t size)
+{
+    getFront().read(data, size);
+}
+
 }

src/communications/communications_buffers.hpp

@@ -99,6 +99,8 @@ class SendBuffer : public CommunicationBuffer<RawSendBuffer>
 
     void squeeze();
 
+    void write(const char *data, std::size_t size);
+
 };
 
 class RecvBuffer : public CommunicationBuffer<RawRecvBuffer>
@@ -111,6 +113,8 @@ class RecvBuffer : public CommunicationBuffer<RawRecvBuffer>
 public:
     RecvBuffer(size_t size = 0, bool doubleBuffer = false);
 
+    void read(char *data, std::size_t size);
+
 };
 
 }

src/containers/binary_stream.cpp

@@ -38,11 +38,11 @@ template<>
 bitpit::IBinaryStream& operator>>(bitpit::IBinaryStream &stream, std::string &value)
 {
     int size = 0;
-    stream.read(size);
+    stream.read(reinterpret_cast<char *>(&size), sizeof(size));
 
     if (size > 0) {
         std::vector<char> buffer(size);
-        stream.read(buffer);
+        stream.read(buffer.data(), size);
         value.assign(buffer.data(), size);
     }
 
@@ -59,7 +59,7 @@ template<>
 bitpit::OBinaryStream& operator<<(bitpit::OBinaryStream &stream, const std::string &value)
 {
     int size = value.size();
-    stream.write(size);
+    stream.write(reinterpret_cast<const char *>(&size), sizeof(size));
 
     if (size > 0) {
         stream.write(value.c_str(), size);
@@ -68,7 +68,6 @@ bitpit::OBinaryStream& operator<<(bitpit::OBinaryStream &stream, const std::stri
     return stream;
 }
 
-
 namespace bitpit {
 
 /*!
@@ -423,7 +422,7 @@ void IBinaryStream::read(char *data, std::size_t size)
         throw std::runtime_error("Bad memory access!");
     }
 
-    std::memcpy(reinterpret_cast<void*>(data), m_buffer.data() + m_pos, size);
+    std::memcpy(data, m_buffer.data() + m_pos, size);
     m_pos += size;
 }
 
@@ -529,10 +528,8 @@ void OBinaryStream::write(const char *data, std::size_t size)
         setSize(bufferSize);
     }
 
-    for (std::size_t i = 0;  i < size; ++i) {
-        m_buffer[m_pos] = data[i];
-        ++m_pos;
-    }
+    std::memcpy(m_buffer.data() + m_pos, data, size);
+    m_pos += size;
 }
 
 }

src/containers/binary_stream.hpp

@@ -44,12 +44,18 @@ class OBinaryStream;
 template<typename T>
 bitpit::IBinaryStream & operator>>(bitpit::IBinaryStream &stream, T &value);
 
+template<typename T>
+bitpit::IBinaryStream& operator>>(bitpit::IBinaryStream &stream, std::vector<T> &vector);
+
 template<>
 bitpit::IBinaryStream & operator>>(bitpit::IBinaryStream &stream, std::string &value);
 
 template<typename T>
 bitpit::OBinaryStream & operator<<(bitpit::OBinaryStream &stream, const T &value);
 
+template<typename T>
+bitpit::OBinaryStream& operator<<(bitpit::OBinaryStream &stream, const std::vector<T> &vector);
+
 template<>
 bitpit::OBinaryStream & operator<<(bitpit::OBinaryStream &stream, const std::string &value);
 
@@ -112,9 +118,6 @@ friend IBinaryStream & (::operator>>)(IBinaryStream &stream, T &value);
     void open(const char *buffer, std::size_t size);
     void open(std::size_t size);
 
-private:
-    template<typename T>
-    void read(T &value);
     void read(char *data, std::size_t size);
 
 };
@@ -133,12 +136,11 @@ friend OBinaryStream & (::operator<<)(OBinaryStream &stream, const T &value);
     void setSize(std::size_t size) override;
     void squeeze();
 
+    void write(const char *data, std::size_t size);
+
 private:
     bool m_expandable;
 
-    template<typename T>
-    void write(const T &value);
-    void write(const char *data, std::size_t size);
 };
 
 }

src/containers/binary_stream.tpp

@@ -23,7 +23,7 @@
 \*---------------------------------------------------------------------------*/
 
 /*!
-* Write the specified value into the stream.
+* Read the specified value from the stream.
 *
 * \param[in] stream is the input stream
 * \param[in] value is the value to be streamed
@@ -32,48 +32,64 @@
 template<typename T>
 bitpit::IBinaryStream& operator>>(bitpit::IBinaryStream &stream, T &value)
 {
-    stream.read(value);
+    stream.read(reinterpret_cast<char *>(&value), sizeof(T));
 
     return stream;
 }
 
 /*!
-* Write the specified value into the stream.
+* Read the specified vector from the stream.
 *
-* \param[in] stream is the output stream
-* \param[in] value is the value to be streamed
-* \result Returns the updated output stream.
+* Input vector will be resized to match the size of the vector stored in the
+* stream.
+*
+* \param[in] stream is the input stream
+* \param[in] vector is the vector to be streamed
+* \result Returns the updated input stream.
 */
 template<typename T>
-bitpit::OBinaryStream& operator<<(bitpit::OBinaryStream &stream, const T &value)
+bitpit::IBinaryStream& operator>>(bitpit::IBinaryStream &stream, std::vector<T> &vector)
 {
-    stream.write(value);
+    std::size_t size;
+    stream.read(reinterpret_cast<char *>(&size), sizeof(size));
+    vector.resize(size);
+
+    stream.read(reinterpret_cast<char *>(vector.data()), size * sizeof(T));
 
     return stream;
 }
 
-namespace bitpit {
-
 /*!
-* Read the specified value from the stream.
+* Write the specified value into the stream.
 *
-* \param[in] value is the value that will be read
+* \param[in] stream is the output stream
+* \param[in] value is the value to be streamed
+* \result Returns the updated output stream.
 */
 template<typename T>
-void IBinaryStream::read(T &value)
+bitpit::OBinaryStream& operator<<(bitpit::OBinaryStream &stream, const T &value)
 {
-    read(reinterpret_cast<char *>(&value), sizeof(T));
+    stream.write(reinterpret_cast<const char *>(&value), sizeof(T));
+
+    return stream;
 }
 
 /*!
-* Write the specified value into the stream.
+* Write the specified vector into the stream.
+*
+* Along with vector data, also the size of the vector is stored into the
+* stream.
 *
-* \param[in] value is the value that will be written
+* \param[in] vector is the vector to be streamed
+* \result Returns the updated output stream.
 */
 template<typename T>
-void OBinaryStream::write(const T &value)
+bitpit::OBinaryStream& operator<<(bitpit::OBinaryStream &stream, const std::vector<T> &vector)
 {
-    write(reinterpret_cast<const char *>(&value), sizeof(T));
-}
+    std::size_t size = vector.size();
+    stream.write(reinterpret_cast<const char *>(&size), sizeof(size));
+
+    stream.write(reinterpret_cast<const char *>(vector.data()), size * sizeof(T));
 
+    return stream;
 }

src/containers/flatVector2D.hpp

@@ -68,8 +68,8 @@ friend bitpit::IBinaryStream& (::operator>>) (bitpit::IBinaryStream &buffer, Fla
 
 public:
     FlatVector2D(bool initialize = true);
-    FlatVector2D(const std::vector<int> &sizes, const T &value = T());
-    FlatVector2D(int nVectors, int size, const T &value = T());
+    FlatVector2D(const std::vector<std::size_t> &sizes, const T &value = T());
+    FlatVector2D(std::size_t nVectors, std::size_t size, const T &value = T());
     FlatVector2D(const std::vector<std::vector<T> > &vector2D);
     FlatVector2D(const FlatVector2D &other) = default;
     FlatVector2D(FlatVector2D &&other) = default;
@@ -91,12 +91,13 @@ friend bitpit::IBinaryStream& (::operator>>) (bitpit::IBinaryStream &buffer, Fla
     FlatVector2D & operator=(FlatVector2D &&other) = default;
 
     void initialize(const std::vector<int> &sizes, const T &value = T());
-    void initialize(int nVectors, int size, const T &value = T());
+    void initialize(const std::vector<std::size_t> &sizes, const T &value = T());
+    void initialize(std::size_t nVectors, std::size_t size, const T &value = T());
     void initialize(const std::vector<std::vector<T> > &vector2D);
     void initialize(const FlatVector2D<T> &other);
 
     void destroy();
-    void reserve(int nVectors, int nItems = 0);
+    void reserve(std::size_t nVectors, std::size_t nItems = 0);
     void swap(FlatVector2D &other) noexcept;
     bool operator==(const FlatVector2D& rhs) const;
     void fill(T &value);
@@ -107,58 +108,58 @@ friend bitpit::IBinaryStream& (::operator>>) (bitpit::IBinaryStream &buffer, Fla
     void shrinkToFit();
 
     const std::size_t * indices() const noexcept;
-    const std::size_t * indices(int i) const noexcept;
+    const std::size_t * indices(std::size_t i) const noexcept;
 
     T * data() noexcept;
     const T * data() const noexcept;
     const std::vector<T> & vector() const;
 
     void pushBack();
-    void pushBack(int subArraySize, const T &value = T());
+    void pushBack(std::size_t subArraySize, const T &value = T());
     void pushBack(const std::vector<T> &subArray);
-    void pushBack(int subArraySize, const T *subArray);
+    void pushBack(std::size_t subArraySize, const T *subArray);
     void pushBackItem(const T& value);
-    void pushBackItem(int i, const T& value);
+    void pushBackItem(std::size_t i, const T& value);
 
     void popBack();
     void popBackItem();
-    void popBackItem(int i);
+    void popBackItem(std::size_t i);
 
-    void erase(int i);
-    void eraseItem(int i, int j);
+    void erase(std::size_t i);
+    void eraseItem(std::size_t i, std::size_t j);
 
-    void setItem(int i, int j, const T &value);
-    T & getItem(int i, int j);
-    const T & getItem(int i, int j) const;
-    const T * get(int i) const;
-    T * get(int i);
+    void setItem(std::size_t i, std::size_t j, const T &value);
+    T & getItem(std::size_t i, std::size_t j);
+    const T & getItem(std::size_t i, std::size_t j) const;
+    const T * get(std::size_t i) const;
+    T * get(std::size_t i);
 
-    void rawSetItem(int k, const T &value);
-    T & rawGetItem(int k);
-    const T & rawGetItem(int k) const;
+    void rawSetItem(std::size_t k, const T &value);
+    T & rawGetItem(std::size_t k);
+    const T & rawGetItem(std::size_t k) const;
 
     T * back();
     T * first();
 
-    int size() const;
-    int capacity() const;
+    std::size_t size() const;
+    std::size_t capacity() const;
 
     void merge();
 
-    int getItemCount() const;
-    int getItemCount(int i) const;
-    int getItemCapacity() const;
+    std::size_t getItemCount() const;
+    std::size_t getItemCount(std::size_t i) const;
+    std::size_t getItemCapacity() const;
 
-    size_t getBinarySize() const;
+    std::size_t getBinarySize() const;
 
 private:
     std::vector<T> m_v;
     std::vector<std::size_t> m_index;
 
-    const T* operator[](int i) const;
-    T* operator[](int i);
-    bool isIndexValid(int i) const;
-    bool isIndexValid(int i, int j) const;
+    const T* operator[](std::size_t i) const;
+    T* operator[](std::size_t i);
+    bool isIndexValid(std::size_t i) const;
+    bool isIndexValid(std::size_t i, std::size_t j) const;
 
     void destroy(bool destroyIndex, bool destroyValues);