Urn.h

Go to the documentation of this file.

/****
 * Urn.h - Construction of device/service URNs
 *
 * Copyright 2020 mikee47 <mike@sillyhouse.net>
 *
 * This file is part of the Sming SSDP Library
 *
 * This library is free software: you can redistribute it and/or modify it under the terms of the
 * GNU General Public License as published by the Free Software Foundation, version 3 or later.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along with this library.
 * If not, see <https://www.gnu.org/licenses/>.
 *
 ****/

#pragma once

#include <WString.h>
#include <Data/Uuid.h>

#define UPNP_URN_KIND_MAP(XX)                                                                                          \
    XX(none, "invalid")                                                                                                \
    XX(uuid, "uuid:{uuid}")                                                                                            \
    XX(root, "upnp:rootdevice"                                                                                         \
             "uuid:{uuid}::upnp:rootdevice")                                                                           \
    XX(device, "urn:{domain}:device:{deviceType}:{version}"                                                            \
               "uuid:{uuid}::urn:{domain}:device:{deviceType}:{version}")                                              \
    XX(service, "urn:{domain}:service:{serviceType}:{version}"                                                         \
                "uuid:{uuid}::urn:{domain}:service:{serviceType}:{version}")

class Urn
{
public:
    enum class Kind {
#define XX(tag, comment) tag,
        UPNP_URN_KIND_MAP(XX)
#undef XX
    };

    Urn(Kind kind = Kind::none) : kind(kind)
    {
    }

    Urn(const Uuid& uuid) : kind(Kind::uuid), uuid(uuid)
    {
    }

    Urn(const Urn& urn) : kind(urn.kind), uuid(urn.uuid), domain(urn.domain), type(urn.type), version(urn.version)
    {
    }

    Urn(Urn&& urn)
        : kind(urn.kind), uuid(urn.uuid), domain(std::move(urn.domain)), type(std::move(urn.type)), version(urn.version)
    {
    }

    Urn(Kind kind, const String& uuid, const String& domain, const String& type, uint8_t version)
        : kind(kind), uuid(uuid), domain(domain), type(type), version(version ?: 1)
    {
    }

    Urn(Kind kind, const Uuid& uuid, const String& domain, const String& type, uint8_t version)
        : Urn(kind, String(uuid), domain, type, version)
    {
    }

    Urn(Kind kind, const String& uuid, const String& domain, const String& type, const String& version)
        : Urn(kind, uuid, domain, type, version.toInt())
    {
    }

    explicit Urn(const char* urn)
    {
        decompose(urn);
    }

    explicit Urn(const String& urn)
    {
        decompose(urn);
    }

    Urn& operator=(const Urn& urn)
    {
        kind = urn.kind;
        uuid = urn.uuid;
        domain = urn.domain;
        type = urn.type;
        version = urn.version;
        return *this;
    }

    Urn& operator=(const String& urn)
    {
        decompose(urn);
        return *this;
    }

    bool decompose(const char* s);

    bool decompose(const String& s)
    {
        return decompose(s.c_str());
    }

    String toString() const;

    explicit operator String() const
    {
        return toString();
    }

    explicit operator bool() const
    {
        return kind != Kind::none;
    }

    bool operator==(const Urn& other) const;

    bool operator==(const String& urn) const
    {
        return urn == toString();
    }

    Kind kind{};
    String uuid;
    String domain;      
    String type;        
    uint8_t version{1}; 
};

class RootDeviceUrn : public Urn
{
public:
    RootDeviceUrn() : Urn(Kind::root)
    {
    }
};

using UuidUrn = Urn;

class DeviceUrn : public Urn
{
public:
    template <typename TVersion>
    DeviceUrn(const String& domain, const String& type, const TVersion& version)
        : Urn(Kind::device, nullptr, domain, type, version)
    {
    }

    template <typename TUuid, typename TVersion>
    DeviceUrn(const TUuid& uuid, const String& domain, const String& type, const TVersion& version)
        : Urn(Kind::device, uuid, domain, type, version)
    {
    }
};

struct ServiceUrn : public Urn {
public:
    template <typename TVersion>
    ServiceUrn(const String& domain, const String& type, const TVersion& version)
        : Urn(Kind::service, nullptr, domain, type, version)
    {
    }

    template <typename TUuid, typename TVersion>
    ServiceUrn(const TUuid& uuid, const String& domain, const String& type, const TVersion& version)
        : Urn(Kind::service, uuid, domain, type, version)
    {
    }
};

using Usn = Urn;

String toString(Urn::Kind kind);

inline String toString(const Urn& urn)
{
    return urn.toString();
}

inline bool fromString(const char* s, Urn& urn)
{
    return urn.decompose(s);
}

inline bool fromString(const String& s, Urn& urn)
{
    return fromString(s.c_str(), urn);
}