PathElementTypes.h

Go to the documentation of this file.

// Copyright 2014 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_PathElementTypes_h_GUID_5CC817E5_C7CB_45AE_399D_0B0D39579374
#define INCLUDED_PathElementTypes_h_GUID_5CC817E5_C7CB_45AE_399D_0B0D39579374

// Internal Includes
#include <osvr/Common/Export.h>
#include <osvr/Common/PathElementTypes_fwd.h> // IWYU pragma: export
#include <osvr/Util/PortFlags.h>

// Library/third-party includes
#include <boost/mpl/contains.hpp>
#include <boost/operators.hpp>
#include <boost/variant/variant.hpp>
#include <json/value.h>

// Standard includes
#include <string>
#include <type_traits>

namespace osvr {
namespace common {
#ifndef OSVR_DOXYGEN_EXTERNAL
#endif
    namespace elements {
        template <typename Type> class ElementBase {
          public:
            typedef Type type;
            typedef ElementBase<Type> base_type;

            const char *getTypeName() const;

          protected:
            ElementBase();
        };

        template <typename Type>
        class EmptyElementBase : public ElementBase<Type>,
                                 boost::operators<Type> {
          public:

            bool operator==(EmptyElementBase<Type> const &) const {
                return true;
            }

          protected:
            EmptyElementBase() {}
        };

        class NullElement : public EmptyElementBase<NullElement> {
          public:
            NullElement() = default;
        };

        class PluginElement : public EmptyElementBase<PluginElement> {
          public:
            PluginElement() = default;
        };

        class DeviceElement : public ElementBase<DeviceElement>,
                              boost::operators<DeviceElement> {
          public:
            DeviceElement() = default;
            DeviceElement(std::string const &deviceName,
                          std::string const &server)
                : m_devName(deviceName), m_server(server) {}

            OSVR_COMMON_EXPORT static DeviceElement
            createVRPNDeviceElement(std::string const &deviceName,
                                    std::string const &server);

            OSVR_COMMON_EXPORT static DeviceElement
            createDeviceElement(std::string const &deviceName,
                                std::string const &server,
                                int port = util::UseDefaultPort);

            OSVR_COMMON_EXPORT std::string &getDeviceName();
            OSVR_COMMON_EXPORT std::string const &getDeviceName() const;
            OSVR_COMMON_EXPORT std::string &getServer();
            OSVR_COMMON_EXPORT std::string const &getServer() const;
            OSVR_COMMON_EXPORT std::string getFullDeviceName() const;

            OSVR_COMMON_EXPORT Json::Value &getDescriptor();
            OSVR_COMMON_EXPORT Json::Value const &getDescriptor() const;

            bool operator==(DeviceElement const &other) const {
                return m_devName == other.m_devName &&
                       m_server == other.m_server &&
                       m_descriptor == other.m_descriptor;
            }

          private:
            std::string m_devName;
            std::string m_server;
            Json::Value m_descriptor;
        };

        class InterfaceElement : public EmptyElementBase<InterfaceElement> {
          public:
            InterfaceElement() = default;
        };

        class SensorElement : public EmptyElementBase<SensorElement> {
          public:
            SensorElement() = default;
        };

        class AliasElement : public ElementBase<AliasElement>,
                             boost::operators<DeviceElement> {
          public:
            OSVR_COMMON_EXPORT
            AliasElement(std::string const &source, AliasPriority priority);

            OSVR_COMMON_EXPORT
            AliasElement(std::string const &source);

            AliasElement() : AliasElement("", ALIASPRIORITY_MINIMUM) {}

            OSVR_COMMON_EXPORT void setSource(std::string const &source);

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

            OSVR_COMMON_EXPORT AliasPriority &priority();
            OSVR_COMMON_EXPORT AliasPriority priority() const;

            bool operator==(AliasElement const &rhs) const {
                return m_priority == rhs.m_priority && m_source == rhs.m_source;
            }

          private:
            std::string m_source;
            AliasPriority m_priority;
        };

        class StringElement : public ElementBase<StringElement> {
          public:
            OSVR_COMMON_EXPORT
            StringElement();

            OSVR_COMMON_EXPORT
            StringElement(std::string const &s);

            OSVR_COMMON_EXPORT std::string &getString();

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

            bool operator==(StringElement const &other) const {
                return m_val == other.m_val;
            }

          private:
            std::string m_val;
        };


        class ArticulationElement : public ElementBase<ArticulationElement>,
                                    boost::operators<ArticulationElement> {
          public:
            ArticulationElement() = default;
            ArticulationElement(std::string const &articulationType,
                                std::string const &boneName,
                                std::string const &trackerPath)
                : m_articulationType(articulationType), m_boneName(boneName),
                  m_trackerPath(trackerPath) {}

            OSVR_COMMON_EXPORT void
            setArticulationType(std::string const &articulationType);

            OSVR_COMMON_EXPORT void setBoneName(std::string const &boneName);

            OSVR_COMMON_EXPORT void
            setTrackerPath(std::string const &trackerPath);

            OSVR_COMMON_EXPORT std::string &getArticulationType();
            OSVR_COMMON_EXPORT std::string const &getArticulationType() const;
            OSVR_COMMON_EXPORT std::string &getBoneName();
            OSVR_COMMON_EXPORT std::string const &getBoneName() const;
            OSVR_COMMON_EXPORT std::string &getTrackerPath();
            OSVR_COMMON_EXPORT std::string const &getTrackerPath() const;

            bool operator==(ArticulationElement const &other) const {
                return m_articulationType == other.m_articulationType &&
                       m_boneName == other.m_boneName &&
                       m_trackerPath == other.m_trackerPath;
            }

          private:
            std::string m_articulationType;
            std::string m_boneName;
            std::string m_trackerPath;
        };

        template <typename Type> inline ElementBase<Type>::ElementBase() {
            static_assert(std::is_base_of<base_type, type>::value,
                          "ElementBase<T> must be the base of an element "
                          "type T (the CRTP)!");

            static_assert(
                boost::mpl::contains<PathElement::types, type>::type::value,
                "Every element type must be a part of the PathElement variant "
                "type's bounded type list!");
        }

    } // namespace elements

} // namespace common
} // namespace osvr

#endif // INCLUDED_PathElementTypes_h_GUID_5CC817E5_C7CB_45AE_399D_0B0D39579374