remove std::string from export interface

include/ipc.h

@@ -10,7 +10,7 @@ namespace ipc {
 
 using shm::handle_t;
 
-IPC_EXPORT handle_t connect   (std::string const & name);
+IPC_EXPORT handle_t connect   (char const * name);
 IPC_EXPORT void     disconnect(handle_t h);
 
 IPC_EXPORT bool                send(handle_t h, void* data, int size);
@@ -19,7 +19,7 @@ IPC_EXPORT std::vector<byte_t> recv(handle_t h);
 class IPC_EXPORT channel {
 public:
     channel(void);
-    channel(std::string const & name);
+    channel(char const * name);
     channel(channel&& rhs);
 
     ~channel(void);
@@ -27,6 +27,8 @@ public:
     void swap(channel& rhs);
     channel& operator=(channel rhs);
 
+    bool connect(char const * name);
+
 private:
     class channel_;
     channel_* p_;

include/shm.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <string>
 #include <cstddef>
 
 #include "export.h"
@@ -10,7 +9,7 @@ namespace shm {
 
 using handle_t = void*;
 
-IPC_EXPORT handle_t acquire(std::string const & name, std::size_t size);
+IPC_EXPORT handle_t acquire(char const * name, std::size_t size);
 IPC_EXPORT void     release(handle_t h, std::size_t size);
 IPC_EXPORT void*    open   (handle_t h);
 IPC_EXPORT void     close  (void* mem);
@@ -18,7 +17,7 @@ IPC_EXPORT void     close  (void* mem);
 class IPC_EXPORT handle {
 public:
     handle(void);
-    handle(std::string const & name, std::size_t size);
+    handle(char const * name, std::size_t size);
     handle(handle&& rhs);
 
     ~handle(void);
@@ -28,9 +27,9 @@ public:
 
     bool         valid(void) const;
     std::size_t  size (void) const;
-    std::string const & name(void) const;
+    char const * name (void) const;
 
-    bool acquire(std::string const & name, std::size_t size);
+    bool acquire(char const * name, std::size_t size);
     void release(void);
 
     void* get  (void);

src/ipc.cpp

@@ -43,7 +43,7 @@ queue_t* queue_of(handle_t h) {
 
 namespace ipc {
 
-handle_t connect(std::string const & name) {
+handle_t connect(char const * name) {
     auto h = shm::acquire(name, sizeof(queue_t));
     if (h == nullptr) {
         return nullptr;
@@ -138,15 +138,16 @@ std::vector<byte_t> recv(handle_t h) {
 
 class channel::channel_ {
 public:
+    handle_t h_;
 };
 
 channel::channel(void)
     : p_(new channel_) {
 }
 
-channel::channel(std::string const & /*name*/)
+channel::channel(char const * name)
     : channel() {
-
+    connect(name);
 }
 
 channel::channel(channel&& rhs)
@@ -167,4 +168,8 @@ channel& channel::operator=(channel rhs) {
     return *this;
 }
 
+bool channel::connect(char const * name) {
+    return false;
+}
+
 } // namespace ipc

src/platform/shm_linux.cpp

@@ -9,11 +9,11 @@
 namespace ipc {
 namespace shm {
 
-handle_t acquire(std::string const & name, std::size_t size) {
+handle_t acquire(char const * name, std::size_t size) {
-    if (name.empty() || size == 0) {
+    if (name == nullptr || name[0] == '\0' || size == 0) {
         return nullptr;
     }
-    int fd = ::shm_open(name.c_str(), O_CREAT | O_RDWR,
+    int fd = ::shm_open(name, O_CREAT | O_RDWR,
                               S_IRUSR | S_IWUSR |
                               S_IRGRP | S_IWGRP |
                               S_IROTH | S_IWOTH);

src/platform/shm_win.cpp

@@ -1,24 +1,26 @@
 #include <windows.h>
 
 #include <type_traits>
+#include <string>
 #include <locale>
 #include <codecvt>
+#include <utility>
 
 #include "shm.h"
 
 namespace {
 
+template <typename T, typename S, typename R = S>
+using IsSame = std::enable_if_t<std::is_same<T, typename S::value_type>::value, R>;
+
 template <typename T = TCHAR>
-constexpr auto to_tchar(std::string const & str)
+constexpr auto to_tchar(std::string && str) -> IsSame<T, std::string, std::string &&> {
- -> std::enable_if_t<std::is_same<std::string::value_type, T>::value, std::string const &> {
+    return std::move(str);
-    return str;
 }
 
 template <typename T = TCHAR>
-inline auto to_tchar(std::string const & str)
+inline auto to_tchar(std::string && str) -> IsSame<T, std::wstring> {
- -> std::enable_if_t<std::is_same<std::wstring::value_type, T>::value, std::wstring> {
+    return std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>>{}.from_bytes(std::move(str));
-    std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
-    return converter.from_bytes(str);
 }
 
 } // internal-linkage
@@ -26,16 +28,15 @@ inline auto to_tchar(std::string const & str)
 namespace ipc {
 namespace shm {
 
-handle_t acquire(std::string const & name, std::size_t size) {
+handle_t acquire(char const * name, std::size_t size) {
-    if (name.empty() || size == 0) {
+    if (name == nullptr || name[0] == '\0' || size == 0) {
         return nullptr;
     }
     HANDLE h = ::CreateFileMapping(
-        INVALID_HANDLE_VALUE,
+        INVALID_HANDLE_VALUE, NULL,
-        NULL,
         PAGE_READWRITE | SEC_COMMIT,
         0, static_cast<DWORD>(size),
-        to_tchar("__SHM__" + name).c_str()
+        to_tchar(std::string{"__SHM__"} + name).c_str()
     );
     if (h == NULL) {
         return nullptr;

src/shm.cpp

@@ -1,3 +1,4 @@
+#include <string>
 #include <utility>
 
 #include "shm.h"
@@ -25,7 +26,7 @@ handle::handle(void)
     p_->t_ = this;
 }
 
-handle::handle(std::string const & name, std::size_t size)
+handle::handle(char const * name, std::size_t size)
     : handle() {
     acquire(name, size);
 }
@@ -56,16 +57,15 @@ std::size_t handle::size(void) const {
     return (p_ == nullptr) ? 0 : p_->s_;
 }
 
-std::string const & handle::name(void) const {
+char const * handle::name(void) const {
-    static const std::string dummy;
+    return (p_ == nullptr) ? "" : p_->n_.c_str();
-    return (p_ == nullptr) ? dummy : p_->n_;
 }
 
-bool handle::acquire(std::string const & name, std::size_t size) {
+bool handle::acquire(char const * name, std::size_t size) {
     if (p_ == nullptr) return false;
     close();
     release();
-    p_->h_ = shm::acquire(p_->n_ = name, p_->s_ = size);
+    p_->h_ = shm::acquire((p_->n_ = name).c_str(), p_->s_ = size);
     return valid();
 }
 

test/test_shm.cpp

@@ -33,15 +33,15 @@ void Unit::test_acquire(void) {
 
     QVERIFY(shm_hd__.acquire("my-test-1", 1024));
     QVERIFY(shm_hd__.size() == 1024);
-    QCOMPARE(shm_hd__.name().c_str(), "my-test-1");
+    QCOMPARE(shm_hd__.name(), "my-test-1");
 
     QVERIFY(shm_hd__.acquire("my-test-2", 2048));
     QVERIFY(shm_hd__.size() == 2048);
-    QCOMPARE(shm_hd__.name().c_str(), "my-test-2");
+    QCOMPARE(shm_hd__.name(), "my-test-2");
 
     QVERIFY(shm_hd__.acquire("my-test-3", 4096));
     QVERIFY(shm_hd__.size() == 4096);
-    QCOMPARE(shm_hd__.name().c_str(), "my-test-3");
+    QCOMPARE(shm_hd__.name(), "my-test-3");
 }
 
 void Unit::test_release(void) {