ObjectClass.h

Go to the documentation of this file.

/****
 * ObjectClass.h
 *
 * Copyright 2020 mikee47 <mike@sillyhouse.net>
 *
 * This file is part of the Sming UPnP 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 <Network/SSDP/Urn.h>
#include <WString.h>
#include <FlashString/Vector.hpp>
#include <assert.h>
 
namespace UPnP
{
class Object;
class DeviceControl;
class ServiceControl;
 
struct ObjectClass {
    using List = const FSTR::Vector<ObjectClass>&;
    using Kind = Urn::Kind;
 
    using Version = uint8_t;
 
    using CreateObject = Object* (*)(DeviceControl* owner);
 
    struct Device {
        const FlashString* friendlyName;
        const FlashString* manufacturer;
        const FlashString* manufacturerURL;
        const FlashString* modelDescription;
        const FlashString* modelName;
        const FlashString* modelNumber;
        const FlashString* modelURL;
        const FlashString* serialNumber;
        const FlashString* UDN;
    };
 
    struct Service {
        const FlashString* serviceId;
        const FlashString* schema;
    };
 
    Kind kind_;
    Version version_;
    const FlashString* domain_;
    const FlashString* type_;
    const CreateObject createObject_;
    // Both of these fields are optional and may be null
    union {
        const Device* device_;
        const Service* service_;
    };
 
    const FlashString& domain() const
    {
        return *domain_;
    }
 
    const FlashString& type() const
    {
        return *type_;
    }
 
    const Device* device() const
    {
        assert(kind() == Kind::device);
        return device_;
    }
 
    const Service* service() const
    {
        assert(kind() == Kind::service);
        return service_;
    }
 
    Version version() const
    {
        return FSTR::readValue(&version_);
    }
 
    Kind kind() const
    {
        return FSTR::readValue(&kind_);
    }
 
    DeviceControl* createRootDevice() const
    {
        assert(kind() == Kind::device);
        return reinterpret_cast<DeviceControl*>(createObject_(nullptr));
    }
 
    DeviceControl* createDevice(DeviceControl& owner) const
    {
        assert(kind() == Kind::device);
        return reinterpret_cast<DeviceControl*>(createObject_(&owner));
    }
 
    ServiceControl* createService(DeviceControl& owner) const
    {
        assert(kind() == Kind::service);
        return reinterpret_cast<ServiceControl*>(createObject_(&owner));
    }
 
    Urn objectType() const;
    bool operator==(const ObjectClass& other) const;
    bool typeIs(const Urn& objectType) const;
    bool typeIs(Urn::Kind kind, const String& type, uint8_t version) const;
 
    explicit operator bool() const
    {
        // We're always valid :-)
        return true;
    }
};
 
} // namespace UPnP