Add first version

[ric-plt/sdl.git] / src / system.cpp

diff --git a/src/system.cpp b/src/system.cpp
new file mode 100644 (file)
index 0000000..e0852e9
--- /dev/null
+++ b/src/system.cpp
@@ -0,0 +1,129 @@
+/*
+   Copyright (c) 2018-2019 Nokia.
+
+   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 "private/system.hpp"
+#include <system_error>
+#include <cerrno>
+#include <cstring>
+#include <sstream>
+#include <sys/epoll.h>
+#include <sys/timerfd.h>
+#include <sys/eventfd.h>
+#include "private/abort.hpp"
+#include "private/createlogger.hpp"
+
+using namespace shareddatalayer;
+
+int System::poll(struct pollfd *fds, nfds_t nfds, int timeout)
+{
+    const int ret(::poll(fds, nfds, timeout));
+    if (ret == -1 && errno != EINTR)
+        throw std::system_error(errno, std::system_category(), "poll");
+    return ret;
+}
+
+int System::epoll_create1(int flags)
+{
+    const int ret(::epoll_create1(flags));
+    if (ret == -1)
+        throw std::system_error(errno, std::system_category(), "epoll_create1");
+    return ret;
+}
+
+void System::epoll_ctl(int epfd, int op, int fd, epoll_event* event)
+{
+    const int ret(::epoll_ctl(epfd, op, fd, event));
+    if (ret == -1)
+        throw std::system_error(errno, std::system_category(), "epoll_ctl");
+}
+
+int System::epoll_wait(int epfd, epoll_event* events, int maxevents, int timeout)
+{
+    const int ret(::epoll_wait(epfd, events, maxevents, timeout));
+    if ((ret == -1) && (errno != EINTR))
+        throw std::system_error(errno, std::system_category(), "epoll_wait");
+    return ret;
+}
+
+int System::timerfd_create(int clockid, int flags)
+{
+    const int ret(::timerfd_create(clockid, flags));
+    if (ret == -1)
+        throw std::system_error(errno, std::system_category(), "timerfd_create");
+    return ret;
+}
+
+void System::timerfd_settime(int fd, int flags, const itimerspec* new_value, itimerspec* old_value)
+{
+    const int ret(::timerfd_settime(fd, flags, new_value, old_value));
+    if (ret == -1)
+        throw std::system_error(errno, std::system_category(), "timerfd_settime");
+}
+
+ssize_t System::read(int fd, void* buf, size_t count)
+{
+    const ssize_t ret(::read(fd, buf, count));
+    if ((ret == -1) && (errno != EINTR) && (errno != EAGAIN))
+        throw std::system_error(errno, std::system_category(), "read");
+    return ret;
+}
+
+int System::eventfd(unsigned int initval, int flags)
+{
+    const int ret(::eventfd(initval, flags));
+    if (ret == -1)
+        throw std::system_error(errno, std::system_category(), "eventfd");
+    return ret;
+}
+
+ssize_t System::write(int fd, const void* buf, size_t count)
+{
+    ssize_t ret;
+    do
+        ret = ::write(fd, buf, count);
+    while ((ret == -1) && (errno == EINTR));
+    if (ret == -1)
+        throw std::system_error(errno, std::system_category(), "write");
+    return ret;
+}
+
+std::chrono::steady_clock::duration System::time_since_epoch()
+{
+    return std::chrono::steady_clock::now().time_since_epoch();
+}
+
+void System::close(int fd)
+{
+    if (::close(fd) == -1)
+    {
+        int errno_saved = errno;
+        std::ostringstream msg;
+        msg << "close(" << fd << ") failed: " << strerror(errno_saved);
+        logErrorOnce(msg.str());
+        SHAREDDATALAYER_ABORT("close failed");
+    }
+}
+
+const char* System::getenv(const char* name)
+{
+    return ::getenv(name);
+}
+
+System& System::getSystem() noexcept
+{
+    static System system;
+    return system;
+}