INvSIPLDeviceInterfaceProvider.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2020-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
 *
 * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
 * property and proprietary rights in and to this material, related
 * documentation and any modifications thereto. Any use, reproduction,
 * disclosure or distribution of this material and related documentation
 * without an express license agreement from NVIDIA CORPORATION or
 * its affiliates is strictly prohibited.
 */
#ifndef NVSIPLDEVICEINTERFACEPROVIDERINTERFACE_HPP
#define NVSIPLDEVICEINTERFACEPROVIDERINTERFACE_HPP
 
#include <cstring>
#include <cstdint>
namespace nvsipl
{
 
class UUID
{
public:
    uint32_t time_low;
    uint16_t time_mid;
    uint16_t time_hi_and_version;
    uint16_t clock_seq;
    uint8_t  node[6];
 
    constexpr UUID(uint32_t const low, uint16_t const mid,
         uint16_t const high, uint16_t const seq,
         uint8_t const n0, uint8_t const n1, uint8_t const n2,
         uint8_t const n3, uint8_t const n4, uint8_t const n5)
        : time_low(low)
        , time_mid(mid)
        , time_hi_and_version(high)
        , clock_seq(seq)
        , node{n0,n1,n2,n3,n4,n5}
    { }
 
    UUID() : UUID(0U,0U,0U,0U,0U,0U,0U,0U,0U,0U)
    { }
 
    friend bool operator==(const UUID &l, const UUID &r) noexcept
    {
        if (l.time_low != r.time_low){
            return false;
        } else if (l.time_mid != r.time_mid){
            return false;
        } else if (l.time_hi_and_version != r.time_hi_and_version){
            return false;
        } else if (l.clock_seq != r.clock_seq){
            return false;
        } else if (l.node[0] != r.node[0]){
            return false;
        } else if (l.node[1] != r.node[1]){
            return false;
        } else if (l.node[2] != r.node[2]){
            return false;
        } else if (l.node[3] != r.node[3]){
            return false;
        } else if (l.node[4] != r.node[4]){
            return false;
        } else if (l.node[5] != r.node[5]){
            return false;
        } else {
            return true;
        }
    };
};
 
static_assert(sizeof(UUID) ==
              sizeof(uint32_t) +
              sizeof(uint16_t) +
              sizeof(uint16_t) +
              sizeof(uint16_t) +
              sizeof(uint8_t) * 6,
              "Missing check in == operator as Structure shall not have padding");
 
class NonCopyable
{
public:
    NonCopyable() = default;
 
    NonCopyable(NonCopyable& other) = delete;
 
    NonCopyable& operator=(NonCopyable& other) & = delete;
 
    NonCopyable(NonCopyable&& other) = delete;
 
    NonCopyable& operator=(NonCopyable&& other) & = delete;
 
protected:
    ~NonCopyable() = default;
};
 
class Interface : public NonCopyable
{
public:
    virtual const UUID &getInstanceInterfaceID() const noexcept = 0;
 
protected:
    Interface() = default;
 
    Interface(Interface &) = delete;
 
    Interface(Interface &&) = delete;
 
    Interface& operator=(Interface &) & = delete;
 
    Interface& operator=(Interface &&) & = delete;
 
    ~Interface() = default;
};
 
class IInterfaceProvider
{
public:
    virtual Interface* GetInterface(const UUID &interfaceId) = 0;
 
protected:
    IInterfaceProvider() = default;
 
    IInterfaceProvider(IInterfaceProvider &) = delete;
 
    IInterfaceProvider(IInterfaceProvider &&) = delete;
 
    IInterfaceProvider& operator=(IInterfaceProvider &) & = delete;
 
    IInterfaceProvider& operator=(IInterfaceProvider &&) & = delete;
 
    virtual ~IInterfaceProvider() = default;
};
 
} // end of namespace nvsipl
#endif //NVSIPLDEVICEINTERFACEPROVIDERINTERFACE_HPP