shared_memory.hpp

//
// Created by gabriele on 04/11/18.
//

#ifndef LIBFORB_SHARED_MEMORY_HPP
#define LIBFORB_SHARED_MEMORY_HPP

#include <sys/types.h>

#include <forb/stream/stream.hpp>

namespace forb {
    namespace streams {

        class shared_memory : public stream {
            /* *********************************** ALIASES AND STATIC ATTRIBUTES ************************************ */
        public:
            using index_t = stream::size_t;

            using key_t = ::key_t; // Defined in sys/types.h

            using id_t = int;

        private:
            static constexpr int PRIVILEGES = 0666;

            struct shmem_data;

            /* ********************************************* ATTRIBUTES ********************************************* */
        private:
            key_t _key = 0;

            id_t _shmem_id = 0;

            shmem_data *_pointer = nullptr;

            bool _is_owner = false;

            /* ******************************************** CONSTRUCTORS ******************************************** */
        public:

            shared_memory() = default;

            /**********************************************************************************************************/

            ~shared_memory() override {
                close();
            };

            shared_memory(const shared_memory &other) = delete;

            shared_memory &operator=(const shared_memory &other) = delete;

            shared_memory(shared_memory &&other) noexcept {
                _move_attributes(other);
            };

            shared_memory &operator=(shared_memory &&other) noexcept {
                if (this != &other) // Probably useless pointer-assignment check
                {
                    // If the same memory space is reused, the old shared
                    // memory must be released
                    close();

                    _move_attributes(other);
                }

                return *this;
            };

            /**********************************************************************************************************/

            // Following static methods are implicitly inline

            static shared_memory get(key_t key) {
                shared_memory shmem{};
                shmem._get(key);
                return shmem;
            };

            static shared_memory create(size_t size) {
                shared_memory shmem{};
                shmem._init(size);
                return shmem;
            };

            /**********************************************************************************************************/
        private:
            void _move_attributes(shared_memory &other) noexcept;

            void _get(key_t key, size_t size = 0, int flags = 0);

            void _init(size_t size);

        public:
            key_t get_key() noexcept {
                return _key;
            };

            void send(const void *buffer, size_t size) override;

            void recv(void *buffer, size_t size) override;

            void close() noexcept override;

            type get_type() const noexcept override {
                return type::SHMEM;
            };

            bool require_marshal() const override {
                return false;
            };

        };

    } // namespace streams

} // namespace forb


#endif //LIBFORB_SHARED_MEMORY_HPP