Buffer.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_Buffer_h_GUID_55EB8AAF_57A7_49A4_3A3A_49293A72211D
#define INCLUDED_Buffer_h_GUID_55EB8AAF_57A7_49A4_3A3A_49293A72211D

// Internal Includes
#include <osvr/Common/Buffer_fwd.h>
#include <osvr/Common/AlignmentPadding.h>

// Library/third-party includes
#include <boost/version.hpp>
#include <boost/type_traits.hpp>

#if BOOST_VERSION >= 105600
#include <boost/align/aligned_allocator.hpp>
#endif

// Standard includes
#include <vector>
#include <stdexcept>
#include <algorithm>

namespace osvr {
namespace common {
    typedef char BufferElement;

    struct DesiredBufferAlignment {
        static const size_t value = 16;
    };
#if BOOST_VERSION >= 105600
    // New Boost has code to handle aligned allocation. Alignment is hard to do
    // portably so we are happy to delegate.

    struct ActualBufferAlignment : DesiredBufferAlignment {};

    typedef boost::alignment::aligned_allocator<
        BufferElement, ::osvr::common::DesiredBufferAlignment::value>
        BufferAllocator;

#else
    // Fallback for older boost: unaligned buffer. Want to rely on aligned
    // buffers? Upgrade Boost and rebuild.

    struct ActualBufferAlignment {
        static const size_t value = 1;
    };

    typedef std::allocator<BufferElement> BufferAllocator;
#endif

    typedef std::vector<BufferElement, BufferAllocator> BufferByteVector;

    template <typename ElementType = BufferElement>
    class ExternalBufferReadingWrapper {
      public:
        typedef ElementType const *const_iterator;
        typedef ElementType value_type;

        ExternalBufferReadingWrapper(ElementType const *buf, size_t size)
            : m_buf(buf), m_size(size) {}

        const_iterator begin() const { return m_buf; }

        const_iterator end() const { return m_buf + m_size; }

        size_t size() const { return m_size; }

      private:
        ElementType const *m_buf;
        size_t m_size;
        static_assert(sizeof(ElementType) == 1,
                      "Container must have byte-sized elements");
    };

    template <typename ContainerType> class BufferReader {
      public:
        typedef typename ContainerType::const_iterator const_iterator;
        typedef typename ContainerType::value_type ElementType;

        BufferReader(ContainerType const &buf)
            : m_begin(buf.begin()), m_readIter(buf.begin()), m_end(buf.end()) {}

        size_t bytesRead() const { return m_readIter - m_begin; }
        size_t bytesRemaining() const { return m_end - m_readIter; }
        template <typename T> void read(T &v) {
            if (bytesRemaining() < sizeof(T)) {
                throw std::runtime_error(
                    "Not enough data in the buffer to read this type!");
            }
            ElementType *dest = reinterpret_cast<ElementType *>(&v);

            auto readEnd = m_readIter + sizeof(T);
            std::copy(m_readIter, readEnd, dest);
            m_readIter = readEnd;
        }

        const_iterator readBytes(size_t const n) {
            if (bytesRemaining() < n) {
                throw std::runtime_error(
                    "Not enough data in the buffer to read that many bytes!");
            }
            auto ret = m_readIter;
            m_readIter += n;
            return ret;
        }

        template <typename T> void readAligned(T &v, size_t const alignment) {
            skipPadding(computeAlignmentPadding(alignment, bytesRead()));
            read(v);
        }

        const_iterator readBytesAligned(size_t const n,
                                        size_t const alignment) {
            skipPadding(computeAlignmentPadding(alignment, bytesRead()));
            return readBytes(n);
        }

        void skipPadding(size_t const bytes) {
            if (bytes == 0) {
                return;
            }
            if (bytesRemaining() < bytes) {
                throw std::runtime_error("Can't skip that many padding "
                                         "bytes, not that many bytes "
                                         "left!");
            }
            m_readIter += bytes;
        }

      private:
        const_iterator m_begin;
        const_iterator m_readIter;
        const_iterator m_end;
        static_assert(sizeof(ElementType) == 1,
                      "Container must have byte-sized elements");
    };

    template <typename CharType>
    inline BufferReader<ExternalBufferReadingWrapper<CharType> >
    readExternalBuffer(const CharType *buf, size_t len) {
        return BufferReader<ExternalBufferReadingWrapper<CharType> >(
            ExternalBufferReadingWrapper<CharType>(buf, len));
    }

    template <typename ContainerType = BufferByteVector> class Buffer {
      public:
        typedef typename ContainerType::value_type ElementType;

        typedef BufferReader<ContainerType> Reader;

        Buffer() {}

        explicit Buffer(ContainerType const &buf) : m_buf(buf) {}

        template <typename InputIterator>
        Buffer(InputIterator beginIt, InputIterator endIt)
            : m_buf(beginIt, endIt) {}

        template <typename T> void append(T const v) {
            static_assert(!boost::is_pointer<T>::value,
                          "Cannot append the value of a pointer!");
            ElementType const *src = reinterpret_cast<ElementType const *>(&v);
            m_buf.insert(m_buf.end(), src, src + sizeof(T));
        }

        template <typename T>
        void appendAligned(T const v, size_t const alignment) {
            appendPadding(computeAlignmentPadding(alignment, size()));
            append(v);
        }

        void append(ElementType const *v, size_t const n) {
            m_buf.insert(m_buf.end(), v, v + n);
        }

        void appendAligned(ElementType const *v, size_t const n,
                           size_t const alignment) {
            appendPadding(computeAlignmentPadding(alignment, size()));
            append(v, n);
        }

        void appendPadding(size_t const bytes) {
            if (bytes == 0) {
                return;
            }
            m_buf.insert(m_buf.end(), bytes, '\0');
        }

        Reader startReading() const { return Reader(m_buf); }

        size_t size() const { return m_buf.size(); }

        ContainerType &getContents() { return m_buf; }

        ElementType const *data() const { return m_buf.data(); }

      private:
        ContainerType m_buf;
        static_assert(sizeof(ElementType) == 1,
                      "Container must have byte-sized elements");
    };
} // namespace common
} // namespace osvr
#endif // INCLUDED_Buffer_h_GUID_55EB8AAF_57A7_49A4_3A3A_49293A72211D