yocto_network.h

Go to the documentation of this file.

/*********************************************************************
 *
 * $Id: yocto_network.h 28748 2017-10-03 08:23:39Z seb $
 *
 * Declares yFindNetwork(), the high-level API for Network functions
 *
 * - - - - - - - - - License information: - - - - - - - - -
 *
 *  Copyright (C) 2011 and beyond by Yoctopuce Sarl, Switzerland.
 *
 *  Yoctopuce Sarl (hereafter Licensor) grants to you a perpetual
 *  non-exclusive license to use, modify, copy and integrate this
 *  file into your software for the sole purpose of interfacing
 *  with Yoctopuce products.
 *
 *  You may reproduce and distribute copies of this file in
 *  source or object form, as long as the sole purpose of this
 *  code is to interface with Yoctopuce products. You must retain
 *  this notice in the distributed source file.
 *
 *  You should refer to Yoctopuce General Terms and Conditions
 *  for additional information regarding your rights and
 *  obligations.
 *
 *  THE SOFTWARE AND DOCUMENTATION ARE PROVIDED 'AS IS' WITHOUT
 *  WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING
 *  WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS
 *  FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO
 *  EVENT SHALL LICENSOR BE LIABLE FOR ANY INCIDENTAL, SPECIAL,
 *  INDIRECT OR CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA,
 *  COST OF PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR
 *  SERVICES, ANY CLAIMS BY THIRD PARTIES (INCLUDING BUT NOT
 *  LIMITED TO ANY DEFENSE THEREOF), ANY CLAIMS FOR INDEMNITY OR
 *  CONTRIBUTION, OR OTHER SIMILAR COSTS, WHETHER ASSERTED ON THE
 *  BASIS OF CONTRACT, TORT (INCLUDING NEGLIGENCE), BREACH OF
 *  WARRANTY, OR OTHERWISE.
 *
 *********************************************************************/


#ifndef YOCTO_NETWORK_H
#define YOCTO_NETWORK_H

#include "yocto_api.h"
#include <cfloat>
#include <cmath>
#include <map>

//--- (YNetwork return codes)
//--- (end of YNetwork return codes)
//--- (YNetwork definitions)
class YNetwork; // forward declaration

typedef void (*YNetworkValueCallback)(YNetwork *func, const string& functionValue);
#ifndef _Y_READINESS_ENUM
#define _Y_READINESS_ENUM
typedef enum {
    Y_READINESS_DOWN = 0,
    Y_READINESS_EXISTS = 1,
    Y_READINESS_LINKED = 2,
    Y_READINESS_LAN_OK = 3,
    Y_READINESS_WWW_OK = 4,
    Y_READINESS_INVALID = -1,
} Y_READINESS_enum;
#endif
#ifndef _Y_DISCOVERABLE_ENUM
#define _Y_DISCOVERABLE_ENUM
typedef enum {
    Y_DISCOVERABLE_FALSE = 0,
    Y_DISCOVERABLE_TRUE = 1,
    Y_DISCOVERABLE_INVALID = -1,
} Y_DISCOVERABLE_enum;
#endif
#ifndef _Y_CALLBACKMETHOD_ENUM
#define _Y_CALLBACKMETHOD_ENUM
typedef enum {
    Y_CALLBACKMETHOD_POST = 0,
    Y_CALLBACKMETHOD_GET = 1,
    Y_CALLBACKMETHOD_PUT = 2,
    Y_CALLBACKMETHOD_INVALID = -1,
} Y_CALLBACKMETHOD_enum;
#endif
#ifndef _Y_CALLBACKENCODING_ENUM
#define _Y_CALLBACKENCODING_ENUM
typedef enum {
    Y_CALLBACKENCODING_FORM = 0,
    Y_CALLBACKENCODING_JSON = 1,
    Y_CALLBACKENCODING_JSON_ARRAY = 2,
    Y_CALLBACKENCODING_CSV = 3,
    Y_CALLBACKENCODING_YOCTO_API = 4,
    Y_CALLBACKENCODING_JSON_NUM = 5,
    Y_CALLBACKENCODING_EMONCMS = 6,
    Y_CALLBACKENCODING_AZURE = 7,
    Y_CALLBACKENCODING_INFLUXDB = 8,
    Y_CALLBACKENCODING_MQTT = 9,
    Y_CALLBACKENCODING_YOCTO_API_JZON = 10,
    Y_CALLBACKENCODING_INVALID = -1,
} Y_CALLBACKENCODING_enum;
#endif
#define Y_MACADDRESS_INVALID            (YAPI_INVALID_STRING)
#define Y_IPADDRESS_INVALID             (YAPI_INVALID_STRING)
#define Y_SUBNETMASK_INVALID            (YAPI_INVALID_STRING)
#define Y_ROUTER_INVALID                (YAPI_INVALID_STRING)
#define Y_IPCONFIG_INVALID              (YAPI_INVALID_STRING)
#define Y_PRIMARYDNS_INVALID            (YAPI_INVALID_STRING)
#define Y_SECONDARYDNS_INVALID          (YAPI_INVALID_STRING)
#define Y_NTPSERVER_INVALID             (YAPI_INVALID_STRING)
#define Y_USERPASSWORD_INVALID          (YAPI_INVALID_STRING)
#define Y_ADMINPASSWORD_INVALID         (YAPI_INVALID_STRING)
#define Y_HTTPPORT_INVALID              (YAPI_INVALID_UINT)
#define Y_DEFAULTPAGE_INVALID           (YAPI_INVALID_STRING)
#define Y_WWWWATCHDOGDELAY_INVALID      (YAPI_INVALID_UINT)
#define Y_CALLBACKURL_INVALID           (YAPI_INVALID_STRING)
#define Y_CALLBACKCREDENTIALS_INVALID   (YAPI_INVALID_STRING)
#define Y_CALLBACKINITIALDELAY_INVALID  (YAPI_INVALID_UINT)
#define Y_CALLBACKSCHEDULE_INVALID      (YAPI_INVALID_STRING)
#define Y_CALLBACKMINDELAY_INVALID      (YAPI_INVALID_UINT)
#define Y_CALLBACKMAXDELAY_INVALID      (YAPI_INVALID_UINT)
#define Y_POECURRENT_INVALID            (YAPI_INVALID_UINT)
//--- (end of YNetwork definitions)

//--- (YNetwork declaration)
class YOCTO_CLASS_EXPORT YNetwork: public YFunction {
#ifdef __BORLANDC__
#pragma option push -w-8022
#endif
//--- (end of YNetwork declaration)
protected:
    //--- (YNetwork attributes)
    // Attributes (function value cache)
    Y_READINESS_enum _readiness;
    string          _macAddress;
    string          _ipAddress;
    string          _subnetMask;
    string          _router;
    string          _ipConfig;
    string          _primaryDNS;
    string          _secondaryDNS;
    string          _ntpServer;
    string          _userPassword;
    string          _adminPassword;
    int             _httpPort;
    string          _defaultPage;
    Y_DISCOVERABLE_enum _discoverable;
    int             _wwwWatchdogDelay;
    string          _callbackUrl;
    Y_CALLBACKMETHOD_enum _callbackMethod;
    Y_CALLBACKENCODING_enum _callbackEncoding;
    string          _callbackCredentials;
    int             _callbackInitialDelay;
    string          _callbackSchedule;
    int             _callbackMinDelay;
    int             _callbackMaxDelay;
    int             _poeCurrent;
    YNetworkValueCallback _valueCallbackNetwork;

    friend YNetwork *yFindNetwork(const string& func);
    friend YNetwork *yFirstNetwork(void);

    // Function-specific method for parsing of JSON output and caching result
    virtual int     _parseAttr(YJSONObject* json_val);

    // Constructor is protected, use yFindNetwork factory function to instantiate
    YNetwork(const string& func);
    //--- (end of YNetwork attributes)

public:
    ~YNetwork();
    //--- (YNetwork accessors declaration)

    static const Y_READINESS_enum READINESS_DOWN = Y_READINESS_DOWN;
    static const Y_READINESS_enum READINESS_EXISTS = Y_READINESS_EXISTS;
    static const Y_READINESS_enum READINESS_LINKED = Y_READINESS_LINKED;
    static const Y_READINESS_enum READINESS_LAN_OK = Y_READINESS_LAN_OK;
    static const Y_READINESS_enum READINESS_WWW_OK = Y_READINESS_WWW_OK;
    static const Y_READINESS_enum READINESS_INVALID = Y_READINESS_INVALID;
    static const string MACADDRESS_INVALID;
    static const string IPADDRESS_INVALID;
    static const string SUBNETMASK_INVALID;
    static const string ROUTER_INVALID;
    static const string IPCONFIG_INVALID;
    static const string PRIMARYDNS_INVALID;
    static const string SECONDARYDNS_INVALID;
    static const string NTPSERVER_INVALID;
    static const string USERPASSWORD_INVALID;
    static const string ADMINPASSWORD_INVALID;
    static const int HTTPPORT_INVALID = YAPI_INVALID_UINT;
    static const string DEFAULTPAGE_INVALID;
    static const Y_DISCOVERABLE_enum DISCOVERABLE_FALSE = Y_DISCOVERABLE_FALSE;
    static const Y_DISCOVERABLE_enum DISCOVERABLE_TRUE = Y_DISCOVERABLE_TRUE;
    static const Y_DISCOVERABLE_enum DISCOVERABLE_INVALID = Y_DISCOVERABLE_INVALID;
    static const int WWWWATCHDOGDELAY_INVALID = YAPI_INVALID_UINT;
    static const string CALLBACKURL_INVALID;
    static const Y_CALLBACKMETHOD_enum CALLBACKMETHOD_POST = Y_CALLBACKMETHOD_POST;
    static const Y_CALLBACKMETHOD_enum CALLBACKMETHOD_GET = Y_CALLBACKMETHOD_GET;
    static const Y_CALLBACKMETHOD_enum CALLBACKMETHOD_PUT = Y_CALLBACKMETHOD_PUT;
    static const Y_CALLBACKMETHOD_enum CALLBACKMETHOD_INVALID = Y_CALLBACKMETHOD_INVALID;
    static const Y_CALLBACKENCODING_enum CALLBACKENCODING_FORM = Y_CALLBACKENCODING_FORM;
    static const Y_CALLBACKENCODING_enum CALLBACKENCODING_JSON = Y_CALLBACKENCODING_JSON;
    static const Y_CALLBACKENCODING_enum CALLBACKENCODING_JSON_ARRAY = Y_CALLBACKENCODING_JSON_ARRAY;
    static const Y_CALLBACKENCODING_enum CALLBACKENCODING_CSV = Y_CALLBACKENCODING_CSV;
    static const Y_CALLBACKENCODING_enum CALLBACKENCODING_YOCTO_API = Y_CALLBACKENCODING_YOCTO_API;
    static const Y_CALLBACKENCODING_enum CALLBACKENCODING_JSON_NUM = Y_CALLBACKENCODING_JSON_NUM;
    static const Y_CALLBACKENCODING_enum CALLBACKENCODING_EMONCMS = Y_CALLBACKENCODING_EMONCMS;
    static const Y_CALLBACKENCODING_enum CALLBACKENCODING_AZURE = Y_CALLBACKENCODING_AZURE;
    static const Y_CALLBACKENCODING_enum CALLBACKENCODING_INFLUXDB = Y_CALLBACKENCODING_INFLUXDB;
    static const Y_CALLBACKENCODING_enum CALLBACKENCODING_MQTT = Y_CALLBACKENCODING_MQTT;
    static const Y_CALLBACKENCODING_enum CALLBACKENCODING_YOCTO_API_JZON = Y_CALLBACKENCODING_YOCTO_API_JZON;
    static const Y_CALLBACKENCODING_enum CALLBACKENCODING_INVALID = Y_CALLBACKENCODING_INVALID;
    static const string CALLBACKCREDENTIALS_INVALID;
    static const int CALLBACKINITIALDELAY_INVALID = YAPI_INVALID_UINT;
    static const string CALLBACKSCHEDULE_INVALID;
    static const int CALLBACKMINDELAY_INVALID = YAPI_INVALID_UINT;
    static const int CALLBACKMAXDELAY_INVALID = YAPI_INVALID_UINT;
    static const int POECURRENT_INVALID = YAPI_INVALID_UINT;

    Y_READINESS_enum    get_readiness(void);

    inline Y_READINESS_enum readiness(void)
    { return this->get_readiness(); }

    string              get_macAddress(void);

    inline string       macAddress(void)
    { return this->get_macAddress(); }

    string              get_ipAddress(void);

    inline string       ipAddress(void)
    { return this->get_ipAddress(); }

    string              get_subnetMask(void);

    inline string       subnetMask(void)
    { return this->get_subnetMask(); }

    string              get_router(void);

    inline string       router(void)
    { return this->get_router(); }

    string              get_ipConfig(void);

    inline string       ipConfig(void)
    { return this->get_ipConfig(); }

    int             set_ipConfig(const string& newval);
    inline int      setIpConfig(const string& newval)
    { return this->set_ipConfig(newval); }

    string              get_primaryDNS(void);

    inline string       primaryDNS(void)
    { return this->get_primaryDNS(); }

    int             set_primaryDNS(const string& newval);
    inline int      setPrimaryDNS(const string& newval)
    { return this->set_primaryDNS(newval); }

    string              get_secondaryDNS(void);

    inline string       secondaryDNS(void)
    { return this->get_secondaryDNS(); }

    int             set_secondaryDNS(const string& newval);
    inline int      setSecondaryDNS(const string& newval)
    { return this->set_secondaryDNS(newval); }

    string              get_ntpServer(void);

    inline string       ntpServer(void)
    { return this->get_ntpServer(); }

    int             set_ntpServer(const string& newval);
    inline int      setNtpServer(const string& newval)
    { return this->set_ntpServer(newval); }

    string              get_userPassword(void);

    inline string       userPassword(void)
    { return this->get_userPassword(); }

    int             set_userPassword(const string& newval);
    inline int      setUserPassword(const string& newval)
    { return this->set_userPassword(newval); }

    string              get_adminPassword(void);

    inline string       adminPassword(void)
    { return this->get_adminPassword(); }

    int             set_adminPassword(const string& newval);
    inline int      setAdminPassword(const string& newval)
    { return this->set_adminPassword(newval); }

    int                 get_httpPort(void);

    inline int          httpPort(void)
    { return this->get_httpPort(); }

    int             set_httpPort(int newval);
    inline int      setHttpPort(int newval)
    { return this->set_httpPort(newval); }

    string              get_defaultPage(void);

    inline string       defaultPage(void)
    { return this->get_defaultPage(); }

    int             set_defaultPage(const string& newval);
    inline int      setDefaultPage(const string& newval)
    { return this->set_defaultPage(newval); }

    Y_DISCOVERABLE_enum get_discoverable(void);

    inline Y_DISCOVERABLE_enum discoverable(void)
    { return this->get_discoverable(); }

    int             set_discoverable(Y_DISCOVERABLE_enum newval);
    inline int      setDiscoverable(Y_DISCOVERABLE_enum newval)
    { return this->set_discoverable(newval); }

    int                 get_wwwWatchdogDelay(void);

    inline int          wwwWatchdogDelay(void)
    { return this->get_wwwWatchdogDelay(); }

    int             set_wwwWatchdogDelay(int newval);
    inline int      setWwwWatchdogDelay(int newval)
    { return this->set_wwwWatchdogDelay(newval); }

    string              get_callbackUrl(void);

    inline string       callbackUrl(void)
    { return this->get_callbackUrl(); }

    int             set_callbackUrl(const string& newval);
    inline int      setCallbackUrl(const string& newval)
    { return this->set_callbackUrl(newval); }

    Y_CALLBACKMETHOD_enum get_callbackMethod(void);

    inline Y_CALLBACKMETHOD_enum callbackMethod(void)
    { return this->get_callbackMethod(); }

    int             set_callbackMethod(Y_CALLBACKMETHOD_enum newval);
    inline int      setCallbackMethod(Y_CALLBACKMETHOD_enum newval)
    { return this->set_callbackMethod(newval); }

    Y_CALLBACKENCODING_enum get_callbackEncoding(void);

    inline Y_CALLBACKENCODING_enum callbackEncoding(void)
    { return this->get_callbackEncoding(); }

    int             set_callbackEncoding(Y_CALLBACKENCODING_enum newval);
    inline int      setCallbackEncoding(Y_CALLBACKENCODING_enum newval)
    { return this->set_callbackEncoding(newval); }

    string              get_callbackCredentials(void);

    inline string       callbackCredentials(void)
    { return this->get_callbackCredentials(); }

    int             set_callbackCredentials(const string& newval);
    inline int      setCallbackCredentials(const string& newval)
    { return this->set_callbackCredentials(newval); }

    int             callbackLogin(string username,string password);

    int                 get_callbackInitialDelay(void);

    inline int          callbackInitialDelay(void)
    { return this->get_callbackInitialDelay(); }

    int             set_callbackInitialDelay(int newval);
    inline int      setCallbackInitialDelay(int newval)
    { return this->set_callbackInitialDelay(newval); }

    string              get_callbackSchedule(void);

    inline string       callbackSchedule(void)
    { return this->get_callbackSchedule(); }

    int             set_callbackSchedule(const string& newval);
    inline int      setCallbackSchedule(const string& newval)
    { return this->set_callbackSchedule(newval); }

    int                 get_callbackMinDelay(void);

    inline int          callbackMinDelay(void)
    { return this->get_callbackMinDelay(); }

    int             set_callbackMinDelay(int newval);
    inline int      setCallbackMinDelay(int newval)
    { return this->set_callbackMinDelay(newval); }

    int                 get_callbackMaxDelay(void);

    inline int          callbackMaxDelay(void)
    { return this->get_callbackMaxDelay(); }

    int             set_callbackMaxDelay(int newval);
    inline int      setCallbackMaxDelay(int newval)
    { return this->set_callbackMaxDelay(newval); }

    int                 get_poeCurrent(void);

    inline int          poeCurrent(void)
    { return this->get_poeCurrent(); }

    static YNetwork*    FindNetwork(string func);

    virtual int         registerValueCallback(YNetworkValueCallback callback);
    using YFunction::registerValueCallback;

    virtual int         _invokeValueCallback(string value);

    virtual int         useDHCP(string fallbackIpAddr,int fallbackSubnetMaskLen,string fallbackRouter);

    virtual int         useDHCPauto(void);

    virtual int         useStaticIP(string ipAddress,int subnetMaskLen,string router);

    virtual string      ping(string host);

    virtual int         triggerCallback(void);

    virtual int         set_periodicCallbackSchedule(string interval,int offset);


    inline static YNetwork* Find(string func)
    { return YNetwork::FindNetwork(func); }

           YNetwork        *nextNetwork(void);
    inline YNetwork        *next(void)
    { return this->nextNetwork();}

           static YNetwork* FirstNetwork(void);
    inline static YNetwork* First(void)
    { return YNetwork::FirstNetwork();}
#ifdef __BORLANDC__
#pragma option pop
#endif
    //--- (end of YNetwork accessors declaration)
};

//--- (YNetwork functions declaration)

inline YNetwork* yFindNetwork(const string& func)
{ return YNetwork::FindNetwork(func);}
inline YNetwork* yFirstNetwork(void)
{ return YNetwork::FirstNetwork();}

//--- (end of YNetwork functions declaration)

#endif