NetworkClassOfService.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_NetworkClassOfService_h_GUID_5B1253E0_C690_4891_5C84_3F713099B8BE
#define INCLUDED_NetworkClassOfService_h_GUID_5B1253E0_C690_4891_5C84_3F713099B8BE

// Internal Includes
#include <osvr/Util/StdInt.h>

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

// Standard includes
#include <type_traits>
#include <stddef.h>

namespace osvr {
namespace common {
    namespace class_of_service {
        struct Reliable;

        struct FixedLatency;

        struct LowLatency;

        struct FixedThroughput;

        struct HighThroughput;

        template <typename ClassOfService> struct ClassOfServiceBase;

        template <typename T> struct IsClassOfService;

        template <typename ClassOfService>
        size_t getMessageSizeLimit(ClassOfServiceBase<ClassOfService> const &);

        template <typename ClassOfService> struct VRPNConnectionValue;

        template <>
        struct VRPNConnectionValue<Reliable>
            : std::integral_constant<uint32_t, (1 << 0)> {};
        template <>
        struct VRPNConnectionValue<FixedLatency>
            : std::integral_constant<uint32_t, (1 << 1)> {};
        template <>
        struct VRPNConnectionValue<LowLatency>
            : std::integral_constant<uint32_t, (1 << 2)> {};
        template <>
        struct VRPNConnectionValue<FixedThroughput>
            : std::integral_constant<uint32_t, (1 << 3)> {};
        template <>
        struct VRPNConnectionValue<HighThroughput>
            : std::integral_constant<uint32_t, (1 << 4)> {};

        /* -----implementation follows----- */

        namespace detail {
            struct ClassOfServiceRoot {
              protected:
                ClassOfServiceRoot() = default;
            };

            template <typename SpecificClass> struct GetMessageSizeLimit {
                static size_t get();
            };
        } // namespace detail

        template <typename ClassOfService>
        struct ClassOfServiceBase : detail::ClassOfServiceRoot {
            typedef ClassOfService type;
            typedef ClassOfServiceBase<ClassOfService> base_type;
            ClassOfServiceBase();
        };
        struct Reliable : ClassOfServiceBase<Reliable> {};

        struct FixedLatency : ClassOfServiceBase<FixedLatency> {};

        struct LowLatency : ClassOfServiceBase<LowLatency> {};

        struct FixedThroughput : ClassOfServiceBase<FixedThroughput> {};

        struct HighThroughput : ClassOfServiceBase<HighThroughput> {};

        template <typename T>
        struct IsClassOfService
            : std::is_base_of<detail::ClassOfServiceRoot, T> {};

        template <typename ClassOfService>
        inline size_t
        getMessageSizeLimit(ClassOfServiceBase<ClassOfService> const &) {
            return detail::GetMessageSizeLimit<ClassOfService>::get();
        }

        template <typename ClassOfService>
        inline ClassOfServiceBase<ClassOfService>::ClassOfServiceBase() {
            static_assert(std::is_base_of<base_type, type>::value,
                          "ClassOfServiceBase<T> must be the base of a class "
                          "of service type T (the CRTP)!");
        }

    } // namespace class_of_service
} // namespace common
} // namespace osvr
#endif // INCLUDED_NetworkClassOfService_h_GUID_5B1253E0_C690_4891_5C84_3F713099B8BE