basedevice.h

Go to the documentation of this file.

/*******************************************************************************
  Copyright(c) 2011-2025 Jasem Mutlaq. All rights reserved.
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Library General Public
 License version 2 as published by the Free Software Foundation.
 
 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
 Library General Public License for more details.
 
 You should have received a copy of the GNU Library General Public License
 along with this library; see the file COPYING.LIB.  If not, write to
 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 Boston, MA 02110-1301, USA.
*******************************************************************************/
 
#pragma once
 
#include "indibase.h"
#include "indiproperty.h"
#include "indiproperties.h"
 
#include <string>
#include <vector>
#include <cstdint>
 
#include "indipropertytext.h"
#include "indipropertynumber.h"
#include "indipropertyswitch.h"
#include "indipropertylight.h"
#include "indipropertyblob.h"
 
// #define MAXRBUF 2048 // #PS: defined in indibase.h
 
namespace INDI
{
 
class LilXmlElement;
class BaseDevicePrivate;
class BaseDevice
{
        DECLARE_PRIVATE(BaseDevice)
    public:
        typedef INDI::Properties Properties;
        // typedef std::vector<INDI::Property*> Properties;
 
        enum INDI_ERROR
        {
            INDI_DEVICE_NOT_FOUND    = -1, 
            INDI_PROPERTY_INVALID    = -2, 
            INDI_PROPERTY_DUPLICATED = -3, 
            INDI_DISPATCH_ERROR      = -4  
        };
 
        enum
        {
            INDI_ENABLED,
            INDI_DISABLED
        };
 
        enum WATCH
        {
            WATCH_NEW = 0,        
            WATCH_UPDATE,         
            WATCH_NEW_OR_UPDATE   
        };
 
        enum DRIVER_INTERFACE
        {
            GENERAL_INTERFACE       = 0,         
            TELESCOPE_INTERFACE     = (1 << 0),  
            CCD_INTERFACE           = (1 << 1),  
            GUIDER_INTERFACE        = (1 << 2),  
            FOCUSER_INTERFACE       = (1 << 3),  
            FILTER_INTERFACE        = (1 << 4),  
            DOME_INTERFACE          = (1 << 5),  
            GPS_INTERFACE           = (1 << 6),  
            WEATHER_INTERFACE       = (1 << 7),  
            AO_INTERFACE            = (1 << 8),  
            DUSTCAP_INTERFACE       = (1 << 9),  
            LIGHTBOX_INTERFACE      = (1 << 10), 
            DETECTOR_INTERFACE      = (1 << 11), 
            ROTATOR_INTERFACE       = (1 << 12), 
            SPECTROGRAPH_INTERFACE  = (1 << 13), 
            CORRELATOR_INTERFACE    = (1 << 14), 
            AUX_INTERFACE           = (1 << 15), 
            OUTPUT_INTERFACE        = (1 << 16), 
            INPUT_INTERFACE         = (1 << 17), 
            POWER_INTERFACE         = (1 << 18), 
            IMU_INTERFACE           = (1 << 19), 
            PAC_INTERFACE = (1 << 20), 
            SENSOR_INTERFACE        = SPECTROGRAPH_INTERFACE | DETECTOR_INTERFACE | CORRELATOR_INTERFACE
        };
    public:
        BaseDevice();
        virtual ~BaseDevice();
 
    public: // property
        void registerProperty(const INDI::Property &property);
        void registerProperty(const INDI::Property &property,
                              INDI_PROPERTY_TYPE type); // backward compatibility (PentaxCCD, PkTriggerCordCCD)
 
        int removeProperty(const char *name, char *errmsg);
 
        void watchProperty(const char *name, const std::function<void (INDI::Property)> &callback, WATCH watch = WATCH_NEW);
 
        Property getProperty(const char *name, INDI_PROPERTY_TYPE type = INDI_UNKNOWN) const;
 
        Properties getProperties();
        const Properties getProperties() const;
 
    public:
        INDI::PropertyNumber getNumber(const char *name) const;
        INDI::PropertyText getText(const char *name) const;
        INDI::PropertySwitch getSwitch(const char *name) const;
        INDI::PropertyLight getLight(const char *name) const;
        INDI::PropertyBlob getBLOB(const char *name) const;
 
    public: // deprecated
        IPState getPropertyState(const char *name) const;
        IPerm getPropertyPermission(const char *name) const;
 
        void *getRawProperty(const char *name, INDI_PROPERTY_TYPE type = INDI_UNKNOWN) const;
 
    public:
        void addMessage(const std::string &msg);
        void checkMessage(XMLEle *root);
        void doMessage(XMLEle *msg);
 
        const std::string &messageQueue(size_t index) const;
 
        const std::string &lastMessage() const;
 
    public:
        bool isValid() const;
 
        bool isSameDevice(const BaseDevice &other) const;
 
        bool isConnected() const;
 
        void attach();
 
        void detach();
 
        void setMediator(INDI::BaseMediator *mediator);
 
        INDI::BaseMediator *getMediator() const;
 
        void setDeviceName(const char *dev);
 
        const char *getDeviceName() const;
 
        bool isDeviceNameMatch(const char *otherName) const;
 
        bool isDeviceNameMatch(const std::string &otherName) const;
 
        const char *getDriverName() const;
 
        const char *getDriverExec() const;
 
        const char *getDriverVersion() const;
 
        uint16_t getDriverInterface() const;
 
    public:
        bool buildSkeleton(const char *filename);
 
        int buildProp(const INDI::LilXmlElement &root, char *errmsg, bool isDynamic = false);
 
        int setValue(const INDI::LilXmlElement &root, char *errmsg);
 
        static std::string getSharedFilePath(std::string fileName);
 
    public:
        INDI_DEPRECATED("Do not use BaseDevice as pointer.")
        operator BaseDevice*();
 
        INDI_DEPRECATED("Do not use BaseDevice as pointer.")
        BaseDevice* operator->();
 
        INDI_DEPRECATED("Use comparison to true.")
        bool operator != (std::nullptr_t) const
        {
            return  isValid();
        }
 
        INDI_DEPRECATED("Use comparison to false.")
        bool operator == (std::nullptr_t) const
        {
            return !isValid();
        }
 
        operator bool()                   const
        {
            return  isValid();
        }
        operator bool()
        {
            return  isValid();
        }
 
    protected:
        friend class AbstractBaseClientPrivate;
        std::shared_ptr<BaseDevicePrivate> d_ptr;
        BaseDevice(BaseDevicePrivate &dd);
        BaseDevice(const std::shared_ptr<BaseDevicePrivate> &dd);
};
 
}