IPCRingBuffer.h

Go to the documentation of this file.

// Copyright 2015 Sensics, Inc.
//
// 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 INCLUDED_IPCRingBuffer_h_GUID_4F33BDA7_1BEB_4E81_B96C_1ADA1CBD1997
#define INCLUDED_IPCRingBuffer_h_GUID_4F33BDA7_1BEB_4E81_B96C_1ADA1CBD1997

// Internal Includes
#include <osvr/Common/Export.h>
#include <osvr/Util/StdInt.h>
#include <osvr/Util/UniquePtr.h>
#include <osvr/Util/SharedPtr.h>

// Library/third-party includes
// - none

// Standard includes
#include <string>

namespace osvr {
namespace common {
    namespace detail {
        struct IPCPutResult;
        typedef shared_ptr<IPCPutResult> IPCPutResultPtr;
        struct IPCGetResult;
        typedef shared_ptr<IPCGetResult> IPCGetResultPtr;
    }
    // forward declaration
    class IPCRingBuffer;

    typedef shared_ptr<IPCRingBuffer> IPCRingBufferPtr;

    class IPCRingBuffer : public enable_shared_from_this<IPCRingBuffer> {
      public:
        typedef uint8_t BackendType;
        typedef uint16_t alignment_type;
        typedef uint16_t entry_count_type;
        typedef uint32_t entry_size_type;
        typedef uint32_t abi_level_type;
        class Options {
          public:
            OSVR_COMMON_EXPORT Options();
            OSVR_COMMON_EXPORT Options(std::string const &name);

            OSVR_COMMON_EXPORT Options(std::string const &name,
                                       BackendType backend);

            BackendType getBackend() const { return m_shmBackend; }

            Options &setName(std::string const &name);
            std::string const &getName() const { return m_name; }

            Options &setAlignment(alignment_type alignment);
            alignment_type getAlignment() const { return m_alignment; }

            Options &setEntries(entry_count_type entries);
            entry_count_type getEntries() const { return m_entries; }

            Options &setEntrySize(entry_size_type entrySize);
            entry_size_type getEntrySize() const { return m_entrySize; }

          private:
            std::string m_name;
            BackendType m_shmBackend;
            alignment_type m_alignment = 16;
            entry_count_type m_entries = 16;
            entry_size_type m_entrySize = 65536;
        };

        OSVR_COMMON_EXPORT static abi_level_type getABILevel();

        OSVR_COMMON_EXPORT static IPCRingBufferPtr create(Options const &opts);

        OSVR_COMMON_EXPORT static IPCRingBufferPtr find(Options const &opts);

        OSVR_COMMON_EXPORT BackendType getBackend() const;

        OSVR_COMMON_EXPORT std::string const &getName() const;

        OSVR_COMMON_EXPORT uint32_t getEntrySize() const;

        OSVR_COMMON_EXPORT uint16_t getEntries() const;

        typedef uint32_t sequence_type;

        typedef uint8_t value_type;
        typedef value_type *pointer_type;
        typedef value_type const *pointer_to_const_type;

        typedef shared_ptr<value_type> smart_pointer_type;

        class BufferWriteProxy {
          public:
            BufferWriteProxy(BufferWriteProxy const &) = delete;

            BufferWriteProxy &operator=(BufferWriteProxy const &) = delete;

            BufferWriteProxy(BufferWriteProxy &&other) {
                std::swap(m_data, other.m_data);
            }

            BufferWriteProxy &operator=(BufferWriteProxy &&other) {
                std::swap(m_data, other.m_data);
                return *this;
            }

            operator pointer_type() const { return get(); }

            pointer_type get() const { return m_buf; }

            sequence_type getSequenceNumber() const { return m_seq; }

          private:
            BufferWriteProxy(detail::IPCPutResultPtr &&data,
                             IPCRingBufferPtr &&shm);
            friend class IPCRingBuffer;
            pointer_type m_buf;
            sequence_type m_seq;
            detail::IPCPutResultPtr m_data;
        };

        class BufferReadProxy {
          public:
            explicit operator bool() const { return nullptr != m_buf; }

            pointer_to_const_type get() const { return m_buf; }

            smart_pointer_type getBufferSmartPointer() const;

            sequence_type getSequenceNumber() const { return m_seq; }

            pointer_to_const_type operator*() const { return m_buf; }
            pointer_to_const_type operator->() const { return m_buf; }

          private:
            BufferReadProxy(detail::IPCGetResultPtr &&data,
                            IPCRingBufferPtr &&shm);
            friend class IPCRingBuffer;
            pointer_type m_buf;
            sequence_type m_seq;
            detail::IPCGetResultPtr m_data;
        };

        OSVR_COMMON_EXPORT sequence_type
        put(pointer_to_const_type data, size_t len);

        OSVR_COMMON_EXPORT BufferWriteProxy put();

        OSVR_COMMON_EXPORT BufferReadProxy get(sequence_type num);

        OSVR_COMMON_EXPORT BufferReadProxy getLatest();

        OSVR_COMMON_EXPORT ~IPCRingBuffer();

      private:
        static IPCRingBufferPtr m_constructorHelper(Options const &opts,
                                                    bool doCreate);
        class Impl;
        IPCRingBuffer(unique_ptr<Impl> &&impl);
        unique_ptr<Impl> m_impl;
    };

} // namespace common
} // namespace osvr

#endif // INCLUDED_IPCRingBuffer_h_GUID_4F33BDA7_1BEB_4E81_B96C_1ADA1CBD1997