description.hxx

/* Copyright (C) 2006-2024 J.F.Dockes
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 *   02110-1301 USA
 */
#ifndef _UPNPDEV_HXX_INCLUDED_
#define _UPNPDEV_HXX_INCLUDED_
 
#include <unordered_map>
#include <vector>
#include <string>
#include <sstream>
 
#include "libupnpp/upnppexports.hxx"
 
namespace UPnPClient {
 
class UPNPP_API UPnPServiceDesc {
public:
    std::string serviceType;
    std::string serviceId; 
    std::string SCPDURL;
    std::string controlURL; 
    std::string eventSubURL;
 
    void clear() {
        serviceType.clear();
        serviceId.clear();
        SCPDURL.clear();
        controlURL.clear();
        eventSubURL.clear();
    }
 
    std::string dump() const {
        std::ostringstream os;
        os << "SERVICE {serviceType [" << serviceType << "] serviceId [" << serviceId <<
            "] SCPDURL [" << SCPDURL << "] controlURL [" << controlURL << "] eventSubURL [" <<
            eventSubURL << "] }" << '\n';
        return os.str();
    }
 
    struct Argument {
        std::string name;
        bool todevice;
        std::string relatedVariable;
        void clear() {
            name.clear();
            todevice = true;
            relatedVariable.clear();
        }
    };
 
    struct Action {
        std::string name;
        std::vector<Argument> argList;
        void clear() {
            name.clear();
            argList.clear();
        }
    };
 
    struct StateVariable {
        std::string name;
        bool sendEvents;
        std::string dataType;
        bool hasValueRange;
        int minimum;
        int maximum;
        int step;
        void clear() {
            name.clear();
            sendEvents = false;
            dataType.clear();
            hasValueRange = false;
        }
    };
 
    struct Parsed {
        std::unordered_map<std::string, Action> actionList;
        std::unordered_map<std::string, StateVariable> stateTable;
    };
 
    bool fetchAndParseDesc(const std::string& urlbase, Parsed& parsed,
                           std::string *XMLText = 0) const;
};
 
class UPNPP_API UPnPDeviceDesc {
public:
    UPnPDeviceDesc(const std::string& url, const std::string& description);
 
    UPnPDeviceDesc() = default;
 
    bool ok{false};
    std::string deviceType;
    std::string friendlyName;
    std::string UDN;
    std::string descURL;
    std::string URLBase;
    std::string manufacturer;
    std::string modelName;
 
    std::string XMLText;
    
    std::vector<UPnPServiceDesc> services;
 
    std::vector<UPnPDeviceDesc> embedded;
 
    void clear() {
        *this = UPnPDeviceDesc();
    }
    std::string dump() const {
        std::ostringstream os;
        os << "DEVICE " << " {deviceType [" << deviceType << "] friendlyName [" << friendlyName <<
            "] UDN [" << UDN << "] URLBase [" << URLBase << "] Services:" << '\n';
        for (const auto& service : services) {
            os << "    " << service.dump();
        }
        for (const auto& it: embedded) {
            os << it.dump();
        }
        os << "}" << '\n';
        return os.str();
    }
};
 
} // namespace
 
#endif /* _UPNPDEV_HXX_INCLUDED_ */