Rename MemoryBlock to MessageComposer

Change-Id: I17d181f673d76d6624c43e5e802a185bab7e124f
Signed-off-by: Jaemin Ryu <jm77.ryu@samsung.com>

diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt
index 9f860bf..217c646 100644 (file)
--- a/common/CMakeLists.txt
+++ b/common/CMakeLists.txt
@@ -26,6 +26,7 @@ SET (COMMON_SOURCES     ${DPM_COMMON}/error.cpp
                         ${DPM_COMMON}/rmi/socket.cpp
                         ${DPM_COMMON}/rmi/client.cpp
                         ${DPM_COMMON}/rmi/message.cpp
+                        ${DPM_COMMON}/rmi/message-composer.cpp
                         ${DPM_COMMON}/rmi/service.cpp
                         ${DPM_COMMON}/rmi/connection.cpp
                         ${DPM_COMMON}/rmi/notification.cpp

diff --git a/common/rmi/message-composer.cpp b/common/rmi/message-composer.cpp
new file mode 100644 (file)
index 0000000..51331b6
--- /dev/null
+++ b/common/rmi/message-composer.cpp
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "message-composer.h"
+
+namespace rmi {
+
+MessageComposer::MessageComposer(size_t caps) :
+    capacity(caps),
+    produce(0),
+    consume(0),
+    buffer(new char[caps])
+{
+}
+
+MessageComposer::MessageComposer(const MessageComposer& rhs) :
+    capacity(rhs.capacity),
+    produce(rhs.produce),
+    consume(rhs.consume),
+    buffer(new char[rhs.capacity])
+{
+    std::copy(rhs.buffer + consume, rhs.buffer + produce, buffer + consume);
+}
+
+MessageComposer::MessageComposer(MessageComposer&& rhs) :
+    capacity(0),
+    produce(0),
+    consume(0),
+    buffer(nullptr)
+{
+    buffer = rhs.buffer;
+    capacity = rhs.capacity;
+    produce = rhs.produce;
+    consume = rhs.consume;
+
+    // Release buffer pointer from the source object so that
+    // the destructor does not free the memory multiple times.
+
+    rhs.buffer = nullptr;
+    rhs.produce = 0;
+    rhs.consume = 0;
+}
+
+MessageComposer::~MessageComposer()
+{
+    if (buffer != nullptr) {
+        delete[] buffer;
+    }
+}
+
+MessageComposer& MessageComposer::operator=(const MessageComposer& rhs)
+{
+    if (this != &rhs) {
+        delete[] buffer;
+
+        capacity = rhs.capacity;
+        produce = rhs.produce;
+        consume = rhs.consume;
+        buffer = new char[capacity];
+        std::copy(rhs.buffer + consume, rhs.buffer + produce, buffer + consume);
+    }
+
+    return *this;
+}
+
+MessageComposer& MessageComposer::operator=(MessageComposer&& rhs)
+{
+    if (this != &rhs) {
+        // Free existing buffer
+        delete[] buffer;
+
+        // Copy the buffer pointer and its attributes from the
+        // source object.
+        buffer = rhs.buffer;
+        produce = rhs.produce;
+        consume = rhs.consume;
+        capacity = rhs.capacity;
+
+        // Release buffer pointer from the source object so that
+        // the destructor does not free the memory multiple times.
+        rhs.buffer = nullptr;
+        rhs.produce = 0;
+        rhs.consume = 0;
+        rhs.capacity = 0;
+    }
+
+    return *this;
+}
+
+void MessageComposer::write(const void* ptr, const size_t sz)
+{
+    size_t bytes = sz;
+    if ((produce + bytes) > capacity) {
+        bytes = capacity - produce;
+    }
+
+    ::memcpy(reinterpret_cast<char *>(buffer + produce), ptr, bytes);
+    produce += bytes;
+}
+
+void MessageComposer::read(void* ptr, const size_t sz)
+{
+    size_t bytes = sz;
+    if ((consume + bytes) > produce) {
+        bytes = produce - consume;
+    }
+
+    ::memcpy(ptr, reinterpret_cast<char *>(buffer) + consume, bytes);
+    consume += bytes;
+
+    // Reset cursors if there is no data
+    if (consume == produce) {
+        consume = produce = 0;
+    }
+}
+
+} // namespae rmi

diff --git a/common/rmi/message-composer.h b/common/rmi/message-composer.h
new file mode 100644 (file)
index 0000000..79376e6
--- /dev/null
+++ b/common/rmi/message-composer.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __RMI_MESSAGE_COMPOSER_H__
+#define __RMI_MESSAGE_COMPOSER_H__
+
+#include <cstring>
+#include <iostream>
+#include <string>
+#include <memory>
+
+namespace rmi {
+
+class MessageComposer {
+public:
+    MessageComposer(size_t caps = 1024);
+    MessageComposer(const MessageComposer& rhs);
+    MessageComposer(MessageComposer&& rhs);
+
+    ~MessageComposer();
+
+    MessageComposer& operator=(const MessageComposer& rhs);
+    MessageComposer& operator=(MessageComposer&& rhs);
+
+    void write(const void* ptr, const size_t sz);
+    void read(void* ptr, const size_t sz);
+
+    void reserve(size_t size)
+    {
+        produce = size;
+    }
+
+    void reset()
+    {
+        produce = consume = 0;
+    }
+
+    char* begin() const
+    {
+        return buffer + consume;
+    }
+
+    char* end() const
+    {
+        return buffer + produce;
+    }
+
+    size_t size() const
+    {
+        return (end() - begin());
+    }
+
+private:
+    size_t capacity;
+    size_t produce;
+    size_t consume;
+    char *buffer;
+};
+
+} // namespae rmi
+#endif //__RMI_MESSAGE_COMPOSER_H__

diff --git a/common/rmi/message.h b/common/rmi/message.h
index 215a809..41f7d35 100644 (file)
--- a/common/rmi/message.h
+++ b/common/rmi/message.h
@@ -24,155 +24,14 @@
 #include <atomic>
 #include <deque>
 
+#include "message-composer.h"
+
 #include "reflection.h"
 #include "serialize.h"
 #include "file-descriptor.h"
 
 namespace rmi {
 
-class MemoryBlock {
-public:
-    MemoryBlock(size_t caps = 1024) :
-        capacity(caps),
-        produce(0),
-        consume(0),
-        buffer(new char[caps])
-    {
-    }
-
-    MemoryBlock(const MemoryBlock& rhs) :
-        capacity(rhs.capacity),
-        produce(rhs.produce),
-        consume(rhs.consume),
-        buffer(new char[rhs.capacity])
-    {
-        std::copy(rhs.buffer + consume, rhs.buffer + produce, buffer + consume);
-    }
-
-    MemoryBlock(MemoryBlock&& rhs)
-        : capacity(0),
-          produce(0),
-          consume(0),
-          buffer(nullptr)
-    {
-        buffer = rhs.buffer;
-        capacity = rhs.capacity;
-        produce = rhs.produce;
-        consume = rhs.consume;
-
-        // Release buffer pointer from the source object so that
-        // the destructor does not free the memory multiple times.
-
-        rhs.buffer = nullptr;
-        rhs.produce = 0;
-        rhs.consume = 0;
-    }
-
-    ~MemoryBlock()
-    {
-        if (buffer != nullptr) {
-            delete[] buffer;
-        }
-    }
-
-    MemoryBlock& operator=(const MemoryBlock& rhs)
-    {
-        if (this != &rhs) {
-            delete[] buffer;
-
-            capacity = rhs.capacity;
-            produce = rhs.produce;
-            consume = rhs.consume;
-            buffer = new char[capacity];
-            std::copy(rhs.buffer + consume, rhs.buffer + produce, buffer + consume);
-        }
-
-        return *this;
-    }
-
-    MemoryBlock& operator=(MemoryBlock&& rhs)
-    {
-        if (this != &rhs) {
-            // Free existing buffer
-            delete[] buffer;
-
-            // Copy the buffer pointer and its attributes from the
-            // source object.
-            buffer = rhs.buffer;
-            produce = rhs.produce;
-            consume = rhs.consume;
-            capacity = rhs.capacity;
-
-            // Release buffer pointer from the source object so that
-            // the destructor does not free the memory multiple times.
-            rhs.buffer = nullptr;
-            rhs.produce = 0;
-            rhs.consume = 0;
-            rhs.capacity = 0;
-        }
-
-        return *this;
-    }
-
-    void write(const void* ptr, const size_t sz)
-    {
-        size_t bytes = sz;
-        if ((produce + bytes) > capacity) {
-            bytes = capacity - produce;
-        }
-
-        ::memcpy(reinterpret_cast<char *>(buffer + produce), ptr, bytes);
-        produce += bytes;
-    }
-
-    void read(void* ptr, const size_t sz)
-    {
-        size_t bytes = sz;
-        if ((consume + bytes) > produce) {
-            bytes = produce - consume;
-        }
-
-        ::memcpy(ptr, reinterpret_cast<char *>(buffer) + consume, bytes);
-        consume += bytes;
-
-        // Reset cursors if there is no data
-        if (consume == produce) {
-            consume = produce = 0;
-        }
-    }
-
-    void reserve(size_t size)
-    {
-        produce = size;
-    }
-
-    void reset()
-    {
-        produce = consume = 0;
-    }
-
-    char* begin() const
-    {
-        return buffer + consume;
-    }
-
-    char* end() const
-    {
-        return buffer + produce;
-    }
-
-    size_t size() const
-    {
-        return (end() - begin());
-    }
-
-private:
-    size_t capacity;
-    size_t produce;
-    size_t consume;
-    char *buffer;
-};
-
 class Message {
 public:
     enum Type {
@@ -291,7 +150,7 @@ private:
     };
 
     MessageSignature signature;
-    MemoryBlock buffer;
+    MessageComposer buffer;
     std::deque<FileDescriptor> fileDescriptors;
 
     static std::atomic<unsigned int> sequence;
@@ -326,7 +185,7 @@ void Message::unpackParameters(F& first, R&... rest)
 template<typename DataType>
 void Message::enclose(DataType&& data)
 {
-    runtime::Serializer<MemoryBlock> serializer(buffer);
+    runtime::Serializer<MessageComposer> serializer(buffer);
     runtime::SerializableArgument<DataType> arg(std::forward<DataType>(data));
     arg.accept(serializer);
 }
@@ -334,7 +193,7 @@ void Message::enclose(DataType&& data)
 template<typename DataType>
 void Message::disclose(DataType& data)
 {
-    runtime::Deserializer<MemoryBlock> deserializer(buffer);
+    runtime::Deserializer<MessageComposer> deserializer(buffer);
     runtime::DeserializableArgument<DataType> arg(data);
     arg.accept(deserializer);
 }