description.hxx

/* Copyright (C) 2006-2016 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 <<
            "] }" << std::endl;
        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() {}

    bool ok{false};
    std::string deviceType;
    std::string friendlyName;
    std::string UDN;
    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:" << std::endl;
        for (std::vector<UPnPServiceDesc>::const_iterator it = services.begin();
             it != services.end(); it++) {
            os << "    " << it->dump();
        }
        for (const auto& it: embedded) {
            os << it.dump();
        }
        os << "}" << std::endl;
        return os.str();
    }
};

} // namespace

#endif /* _UPNPDEV_HXX_INCLUDED_ */