BaseObject.h

Go to the documentation of this file.

/****
 * BaseObject.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 "LinkedItem.h"
#include "ObjectClass.h"
#include <WString.h>
#include <Delegate.h>
#include <Network/SSDP/MessageSpec.h>
#include <Data/Stream/DataSourceStream.h>
#include <Network/Http/HttpServerConnection.h>
#include <Network/Http/HttpRequest.h>
#include <Network/Http/HttpResponse.h>
#include <Network/SSDP/Urn.h>

namespace UPnP
{
using namespace SSDP;

class BaseObject;

struct SearchFilter {
    using Callback = Delegate<void(BaseObject* object, SearchMatch match)>;

    SearchFilter(const MessageSpec& ms, uint32_t delayMs) : ms(ms), delayMs(delayMs)
    {
    }

    const MessageSpec& ms; 
    uint32_t delayMs;     
    String targetString;   
    Callback callback;   
};

class BaseObject : public LinkedItem
{
public:
    virtual bool formatMessage(Message& msg, MessageSpec& ms) = 0;

    virtual void sendMessage(Message& msg, MessageSpec& ms);
};

template <typename ObjectType, typename BaseObjectType> class ObjectTemplate : public BaseObjectType
{
public:
    class Iterator : public std::iterator<std::forward_iterator_tag, ObjectType>
    {
    public:
        Iterator(ObjectType* x) : o(x)
        {
        }

        Iterator(ObjectType& x) : o(&x)
        {
        }

        Iterator(const Iterator& other) : o(other.o)
        {
        }

        Iterator& operator++()
        {
            o = o->getNext();
            return *this;
        }

        Iterator operator++(int)
        {
            Iterator tmp(*this);
            operator++();
            return tmp;
        }

        bool operator==(const Iterator& rhs) const
        {
            return o == rhs.o;
        }

        bool operator!=(const Iterator& rhs) const
        {
            return o != rhs.o;
        }

        ObjectType& operator*()
        {
            return *o;
        }

        ObjectType* operator->()
        {
            return o;
        }

        operator ObjectType*()
        {
            return o;
        }

    private:
        ObjectType* o;
    };

    ObjectType* getNext() const
    {
        return reinterpret_cast<ObjectType*>(this->next());
    }

    Iterator begin() const
    {
        return Iterator(this);
    }

    Iterator end() const
    {
        return Iterator(nullptr);
    }
};

} // namespace UPnP