why a class anymore

7 years ago · 0293edca01
3 changed files with 137 additions and 157 deletions
--- a/Adapter.cc
+++ b/Adapter.cc
@ -7,8 +7,25 @@
 #include <assert.h>

 namespace pEp {
+    namespace Adapter {
        using namespace std;

+        static messageToSend_t _messageToSend = nullptr;
+        static notifyHandshake_t _notifyHandshake = nullptr;
+        static std::thread *_sync_thread = nullptr;
+
+        static ::utility::locked_queue< SYNC_EVENT >& queue()
+        {
+            static ::utility::locked_queue< SYNC_EVENT > q;
+            return q;
+        }
+
+        static std::mutex& mtx()
+        {
+            static std::mutex m;
+            return m;
+        }
+
        void throw_status(PEP_STATUS status)
        {
            if (status == PEP_STATUS_OK)
@ -25,17 +42,59 @@ namespace pEp {
            throw runtime_error(build.str());
        }

-    messageToSend_t Adapter::_messageToSend = nullptr;
-    notifyHandshake_t Adapter::_notifyHandshake = nullptr;
-    std::thread *Adapter::_sync_thread = nullptr;
+        static int _inject_sync_event(SYNC_EVENT ev, void *management)
+        {
+            if (is_sync_thread(session())) {
+                PEP_STATUS status = do_sync_protocol_step(session(), nullptr, ev);
+                return status == PEP_STATUS_OK ? 0 : 1;
+            }

-    Adapter::Adapter(messageToSend_t messageToSend,
-            notifyHandshake_t notifyHandshake, void *obj)
+            try {
+                queue().push_front(ev);
+            }
+            catch (exception&) {
+                return 1;
+            }
+            return 0;
+        }
+
+        static SYNC_EVENT _retrieve_next_sync_event(void *management, time_t threshold)
        {
-        startup(messageToSend, notifyHandshake, obj);
+            time_t started = time(nullptr);
+            bool timeout = false;
+
+            while (queue().empty()) {
+                int i = 0;
+                ++i;
+                if (i > 10) {
+                    if (time(nullptr) > started + threshold) {
+                        timeout = true;
+                        break;
                    }
+                    i = 0;
+                }
+                nanosleep((const struct timespec[]){{0, 100000000L}}, NULL);
+            }
+
+            if (timeout)
+                return new_sync_timeout_event();

-    void Adapter::startup(messageToSend_t messageToSend,
+            return queue().pop_front();
+        }
+
+        static void sync_thread(void *obj)
+        {
+            PEP_STATUS status = register_sync_callbacks(session(), nullptr,
+                    _notifyHandshake, _retrieve_next_sync_event);
+            throw_status(status);
+
+            do_sync_protocol(session(), obj);
+            unregister_sync_callbacks(session());
+
+            session(release);
+        }
+
+        void startup(messageToSend_t messageToSend,
                notifyHandshake_t notifyHandshake, void *obj)
        {
            if (messageToSend)
@ -49,12 +108,12 @@ namespace pEp {
            {
                lock_guard<mutex> lock(mtx());

-            if (!Adapter::_sync_thread)
-                Adapter::_sync_thread = new thread(sync_thread, obj);
+                if (!_sync_thread)
+                    _sync_thread = new thread(sync_thread, obj);
            }
        }

-    PEP_SESSION Adapter::session(session_action action)
+        PEP_SESSION session(session_action action)
        {
            lock_guard<mutex> lock(mtx());

@ -82,67 +141,16 @@ namespace pEp {
            return _session;
        }

-    void Adapter::shutdown()
+        void shutdown()
        {
-        if (Adapter::_sync_thread) {
+            if (_sync_thread) {
                _inject_sync_event(nullptr, nullptr);
-            Adapter::_sync_thread->join();
-            delete Adapter::_sync_thread;
-            Adapter::_sync_thread = nullptr;
+                _sync_thread->join();
+                delete _sync_thread;
+                _sync_thread = nullptr;
            }
            session(release);
        }
-
-    int Adapter::_inject_sync_event(SYNC_EVENT ev, void *management)
-    {
-        if (is_sync_thread(session())) {
-            PEP_STATUS status = do_sync_protocol_step(session(), nullptr, ev);
-            return status == PEP_STATUS_OK ? 0 : 1;
-        }
-
-        try {
-            queue().push_front(ev);
-        }
-        catch (exception&) {
-            return 1;
-        }
-        return 0;
-    }
-
-    SYNC_EVENT Adapter::_retrieve_next_sync_event(void *management, time_t threshold)
-    {
-        time_t started = time(nullptr);
-        bool timeout = false;
-
-        while (queue().empty()) {
-            int i = 0;
-            ++i;
-            if (i > 10) {
-                if (time(nullptr) > started + threshold) {
-                    timeout = true;
-                    break;
-                }
-                i = 0;
-            }
-            nanosleep((const struct timespec[]){{0, 100000000L}}, NULL);
-        }
-
-        if (timeout)
-            return new_sync_timeout_event();
-
-        return queue().pop_front();
-    }
-
-    void Adapter::sync_thread(void *obj)
-    {
-        PEP_STATUS status = register_sync_callbacks(session(), nullptr,
-                _notifyHandshake, _retrieve_next_sync_event);
-        throw_status(status);
-
-        do_sync_protocol(session(), obj);
-        unregister_sync_callbacks(session());
-
-        session(release);
    }
 }

--- a/Adapter.hh
+++ b/Adapter.hh
@ -10,47 +10,19 @@
 namespace pEp {
    void throw_status(PEP_STATUS status);

-    class Adapter {
-            static messageToSend_t _messageToSend;
-            static notifyHandshake_t _notifyHandshake;
-            static std::thread *_sync_thread;
-
-        public:
-            Adapter(messageToSend_t messageToSend,
-                    notifyHandshake_t notifyHandshake, void *obj = nullptr);
+    namespace Adapter {
+        void throw_status(PEP_STATUS status);

-            static void startup(messageToSend_t messageToSend,
+        void startup(messageToSend_t messageToSend,
                notifyHandshake_t notifyHandshake, void *obj = nullptr);

        enum session_action {
            init,
            release
        };
-            static PEP_SESSION session(session_action action = init);
-            static void release_session()
-            {
-                session(release);
-            }
-
-            static void shutdown();
+        PEP_SESSION session(session_action action = init);

-        protected:
-            static int _inject_sync_event(SYNC_EVENT ev, void *management);
-            static SYNC_EVENT _retrieve_next_sync_event(void *management, time_t threshold);
-            static void sync_thread(void *obj);
-
-        private:
-            static ::utility::locked_queue< SYNC_EVENT >& queue()
-            {
-                static ::utility::locked_queue< SYNC_EVENT > q;
-                return q;
-            }
-
-            static std::mutex& mtx()
-            {
-                static std::mutex m;
-                return m;
+        void shutdown();
    }
-    };
 }

--- a/test_adapter.cc
+++ b/test_adapter.cc
@ -7,8 +7,8 @@
 #include <unistd.h>
 #include <pEp/keymanagement.h>

-using namespace pEp;
 using namespace std;
+using namespace pEp::Adapter;

 PEP_STATUS messageToSend(struct _message *msg)
 {
@ -27,15 +27,15 @@ int main()
    cout << "updating or creating identity for me\n";
    pEp_identity *me = new_identity("alice@peptest.ch", NULL, "23", "Who the F* is Alice");
    assert(me);
-    PEP_STATUS status = myself(Adapter::session(), me);
+    PEP_STATUS status = myself(session(), me);
+    free_identity(me);
    throw_status(status);

    cout << "starting the adapter including sync\n";
-    Adapter::startup(messageToSend, notifyHandshake);
+    startup(messageToSend, notifyHandshake);
    sleep(3);
-    Adapter::shutdown();
+    shutdown();

-    free_identity(me);
    return 0;
 }