/*********************************************************************
 *
 *  $Id: svn_id $
 *
 *  Declares yFindRfidReader(), the high-level API for RfidReader 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_RFIDREADER_H
#define YOCTO_RFIDREADER_H

#include <cfloat>
#include <cmath>

#include "yocto_api.h"

#ifdef YOCTOLIB_NAMESPACE
namespace YOCTOLIB_NAMESPACE
{
#endif

//--- (generated code: YRfidTagInfo return codes)
//--- (end of generated code: YRfidTagInfo return codes)
//--- (generated code: YRfidTagInfo yapiwrapper)
//--- (end of generated code: YRfidTagInfo yapiwrapper)
//--- (generated code: YRfidTagInfo definitions)
//--- (end of generated code: YRfidTagInfo definitions)

//--- (generated code: YRfidTagInfo declaration)
/**
 * YRfidTagInfo Class: RFID tag description, used by class YRfidReader
 *
 * YRfidTagInfo objects are used to describe RFID tag attributes,
 * such as the tag type and its storage size. These objects are returned by
 * method get_tagInfo() of class YRfidReader.
 */
class YOCTO_CLASS_EXPORT YRfidTagInfo {
#ifdef __BORLANDC__
#pragma option push -w-8022
#endif
//--- (end of generated code: YRfidTagInfo declaration)
protected:
    //--- (generated code: YRfidTagInfo attributes)
    // Attributes (function value cache)
    string          _tagId;
    int             _tagType;
    string          _typeStr;
    int             _nfcType;
    int             _size;
    int             _usable;
    int             _blksize;
    int             _fblk;
    int             _lblk;
    //--- (end of generated code: YRfidTagInfo attributes)

public:
    YRfidTagInfo();
    virtual ~YRfidTagInfo();
    //--- (generated code: YRfidTagInfo accessors declaration)

    static const int IEC_15693 = 1;
    static const int IEC_14443 = 2;
    static const int IEC_14443_MIFARE_ULTRALIGHT = 3;
    static const int IEC_14443_MIFARE_CLASSIC1K = 4;
    static const int IEC_14443_MIFARE_CLASSIC4K = 5;
    static const int IEC_14443_MIFARE_DESFIRE = 6;
    static const int IEC_14443_NTAG_213 = 7;
    static const int IEC_14443_NTAG_215 = 8;
    static const int IEC_14443_NTAG_216 = 9;
    static const int IEC_14443_NTAG_424_DNA = 10;
    static const int IEC_15693_ST25DV = 11;
    static const int IEC_15693_ST25TV = 12;
    static const int IEC_15693_TAGIT_HFI = 13;
    static const int IEC_15693_MB89R = 14 ;
    static const int IEC_15693_ICODE_DNA = 15;
    static const int IEC_15693_ICODE_SLI = 16;

    /**
     * Returns the RFID tag identifier.
     *
     * @return a string with the RFID tag identifier.
     */
    virtual string      get_tagId(void);

    /**
     * Returns the type of the RFID tag, as a numeric constant.
     * (IEC_14443_MIFARE_CLASSIC1K, ...).
     *
     * @return an integer corresponding to the RFID tag type
     */
    virtual int         get_tagType(void);

    /**
     * Returns the type of the RFID tag, as a string.
     *
     * @return a string corresponding to the RFID tag type
     */
    virtual string      get_tagTypeStr(void);

    /**
     * Returns the type of NFC type usable on the RFID tag, between 1 and 5.
     * If no known NFC type is know for the RFID tag, returns zero.
     *
     * @return an integer corresponding to the RFID tag type
     */
    virtual int         get_tagNFCtype(void);

    /**
     * Returns the total memory size of the RFID tag, in bytes.
     *
     * @return the total memory size of the RFID tag
     */
    virtual int         get_tagMemorySize(void);

    /**
     * Returns the usable storage size of the RFID tag, in bytes.
     *
     * @return the usable storage size of the RFID tag
     */
    virtual int         get_tagUsableSize(void);

    /**
     * Returns the block size of the RFID tag, in bytes.
     *
     * @return the block size of the RFID tag
     */
    virtual int         get_tagBlockSize(void);

    /**
     * Returns the index of the block available for data storage on the RFID tag.
     * Some tags have special block used to configure the tag behavior, these
     * blocks must be handled with precaution. However, the  block return by
     * get_tagFirstBlock() can be locked, use get_tagLockState()
     * to find out  which block are locked.
     *
     * @return the index of the first usable storage block on the RFID tag
     */
    virtual int         get_tagFirstBlock(void);

    /**
     * Returns the index of the last last black available for data storage on the RFID tag,
     * However, this block can be locked, use get_tagLockState() to find out
     * which block are locked.
     *
     * @return the index of the last usable storage block on the RFID tag
     */
    virtual int         get_tagLastBlock(void);

    virtual void        imm_init(string tagId,int tagType,int size,int usable,int blksize,int fblk,int lblk);

#ifdef __BORLANDC__
#pragma option pop
#endif
    //--- (end of generated code: YRfidTagInfo accessors declaration)
};

//--- (generated code: YRfidTagInfo functions declaration)
//--- (end of generated code: YRfidTagInfo functions declaration)


//--- (generated code: YRfidOptions definitions)
//--- (end of generated code: YRfidOptions definitions)

//--- (generated code: YRfidOptions declaration)
/**
 * YRfidOptions Class: Additional parameters for operations on RFID tags.
 *
 * The YRfidOptions objects are used to specify additional
 * optional parameters to RFID commands that interact with tags,
 * including security keys. When instantiated,the parameters of
 * this object are pre-initialized to a value  which corresponds
 * to the most common usage.
 */
class YOCTO_CLASS_EXPORT YRfidOptions {
#ifdef __BORLANDC__
#pragma option push -w-8022
#endif
//--- (end of generated code: YRfidOptions declaration)

public:
    YRfidOptions();
    virtual ~YRfidOptions();

    //--- (generated code: YRfidOptions attributes)

    // Public Attributes
    /**
     * Type of security key to be used to access the RFID tag.
     * For MIFARE Classic tags, allowed values are
     * Y_MIFARE_KEY_A or Y_MIFARE_KEY_B.
     * The default value is Y_NO_RFID_KEY, in that case
     * the reader will use the most common default key for the
     * tag type.
     * When a security key is required, it must be provided
     * using property HexKey.
     */
    int             KeyType;
    /**
     * Security key to be used to access the RFID tag, as an
     * hexadecimal string. The key will only be used if you
     * also specify which type of key it is, using property
     * KeyType.
     */
    string          HexKey;
    /**
     * Forces the use of single-block commands to access RFID tag memory blocks.
     * By default, the Yoctopuce library uses the most efficient access strategy
     * generally available for each tag type, but you can force the use of
     * single-block commands if the RFID tags you are using do not support
     * multi-block commands. If operation speed is not a priority, choose
     * single-block mode as it will work with any mode.
     */
    bool            ForceSingleBlockAccess;
    /**
     * Forces the use of multi-block commands to access RFID tag memory blocks.
     * By default, the Yoctopuce library uses the most efficient access strategy
     * generally available for each tag type, but you can force the use of
     * multi-block commands if you know for sure that the RFID tags you are using
     * do support multi-block commands. Be  aware that even if a tag allows multi-block
     * operations, the maximum number of blocks that can be written or read at the same
     * time can be (very) limited. If the tag does not support multi-block mode
     * for the wanted operation, the option will be ignored.
     */
    bool            ForceMultiBlockAccess;
    /**
     * Enables direct access to RFID tag control blocks.
     * By default, Yoctopuce library read and write functions only work
     * on data blocks and automatically skip special blocks, as specific functions are provided
     * to configure security parameters found in control blocks.
     * If you need to access control blocks in your own way using
     * read/write functions, enable this option.  Use this option wisely,
     * as overwriting a special block migth very well irreversibly alter your
     * tag behavior.
     */
    bool            EnableRawAccess;
    /**
     * Disables the tag memory overflow test. By default, the Yoctopuce
     * library's read/write functions detect overruns and do not run
     * commands that are likely to fail. If you nevertheless wish to
     * try to access more memory than the tag announces, you can try to use
     * this option.
     */
    bool            DisableBoundaryChecks;
    /**
     * Enables simulation mode to check the affected block range as well
     * as access rights. When this option is active, the operation is
     * not fully applied to the RFID tag but the affected block range
     * is determined and the optional access key is tested on these blocks.
     * The access key rights are not tested though. This option applies to
     * write / configure operations only, it is ignored for read operations.
     */
    bool            EnableDryRun;

    // Constants used as attribute values
    static const int NO_RFID_KEY = 0;
    static const int MIFARE_KEY_A = 1;
    static const int MIFARE_KEY_B = 2;
    static const int ST25DV_CONFIG_PWD = 3;
    static const int ST25DV_PWD1 = 4;
    static const int ST25DV_PWD2 = 5;
    static const int ST25DV_PWD3 = 6;
    static const int ST25TV_CONFIG_PWD = 7;
    static const int ST25TV_PWD1 = 8;
    static const int ST25TV_PWD2 = 9;

    //--- (end of generated code: YRfidOptions attributes)

    //--- (generated code: YRfidOptions accessors declaration)

    virtual string      imm_getParams(void);

#ifdef __BORLANDC__
#pragma option pop
#endif
    //--- (end of generated code: YRfidOptions accessors declaration)
};

//--- (generated code: YRfidOptions functions declaration)
//--- (end of generated code: YRfidOptions functions declaration)


//--- (generated code: YRfidStatus return codes)
//--- (end of generated code: YRfidStatus return codes)
//--- (generated code: YRfidStatus yapiwrapper)
//--- (end of generated code: YRfidStatus yapiwrapper)
//--- (generated code: YRfidStatus definitions)
//--- (end of generated code: YRfidStatus definitions)

//--- (generated code: YRfidStatus declaration)
/**
 * YRfidStatus Class: Detailled information about the result of RFID tag operations, allowing to find
 * out what happened exactly after a tag operation failure.
 *
 * YRfidStatus objects provide additional information about
 * operations on RFID tags, including the range of blocks affected
 * by read/write operations and possible errors when communicating
 * with RFID tags.
 * This makes it possible, for example, to distinguish communication
 * errors that can be recovered by an additional attempt, from
 * security or other errors on the tag.
 * Combined with the EnableDryRun option in RfidOptions,
 * this structure can be used to predict which blocks will be affected
 * by a write operation.
 */
class YOCTO_CLASS_EXPORT YRfidStatus {
#ifdef __BORLANDC__
#pragma option push -w-8022
#endif
//--- (end of generated code: YRfidStatus declaration)
protected:
    //--- (generated code: YRfidStatus attributes)
    // Attributes (function value cache)
    string          _tagId;
    int             _errCode;
    int             _errBlk;
    string          _errMsg;
    int             _yapierr;
    int             _fab;
    int             _lab;
    //--- (end of generated code: YRfidStatus attributes)

public:
    YRfidStatus();
    virtual ~YRfidStatus();
    //--- (generated code: YRfidStatus accessors declaration)

    static const int SUCCESS = 0;
    static const int COMMAND_NOT_SUPPORTED = 1;
    static const int COMMAND_NOT_RECOGNIZED = 2;
    static const int COMMAND_OPTION_NOT_RECOGNIZED = 3;
    static const int COMMAND_CANNOT_BE_PROCESSED_IN_TIME = 4;
    static const int UNDOCUMENTED_ERROR = 15;
    static const int BLOCK_NOT_AVAILABLE = 16;
    static const int BLOCK_ALREADY_LOCKED = 17;
    static const int BLOCK_LOCKED = 18;
    static const int BLOCK_NOT_SUCESSFULLY_PROGRAMMED = 19;
    static const int BLOCK_NOT_SUCESSFULLY_LOCKED = 20;
    static const int BLOCK_IS_PROTECTED = 21;
    static const int CRYPTOGRAPHIC_ERROR = 64;
    static const int READER_BUSY = 1000;
    static const int TAG_NOTFOUND = 1001;
    static const int TAG_LEFT = 1002;
    static const int TAG_JUSTLEFT = 1003;
    static const int TAG_COMMUNICATION_ERROR = 1004;
    static const int TAG_NOT_RESPONDING = 1005;
    static const int TIMEOUT_ERROR = 1006;
    static const int COLLISION_DETECTED = 1007;
    static const int INVALID_CMD_ARGUMENTS = -66;
    static const int UNKNOWN_CAPABILITIES = -67;
    static const int MEMORY_NOT_SUPPORTED = -68;
    static const int INVALID_BLOCK_INDEX = -69;
    static const int MEM_SPACE_UNVERRUN_ATTEMPT = -70;
    static const int BROWNOUT_DETECTED = -71     ;
    static const int BUFFER_OVERFLOW = -72;
    static const int CRC_ERROR = -73;
    static const int COMMAND_RECEIVE_TIMEOUT = -75;
    static const int DID_NOT_SLEEP = -76;
    static const int ERROR_DECIMAL_EXPECTED = -77;
    static const int HARDWARE_FAILURE = -78;
    static const int ERROR_HEX_EXPECTED = -79;
    static const int FIFO_LENGTH_ERROR = -80;
    static const int FRAMING_ERROR = -81;
    static const int NOT_IN_CNR_MODE = -82;
    static const int NUMBER_OU_OF_RANGE = -83;
    static const int NOT_SUPPORTED = -84;
    static const int NO_RF_FIELD_ACTIVE = -85;
    static const int READ_DATA_LENGTH_ERROR = -86;
    static const int WATCHDOG_RESET = -87;
    static const int UNKNOW_COMMAND = -91;
    static const int UNKNOW_ERROR = -92;
    static const int UNKNOW_PARAMETER = -93;
    static const int UART_RECEIVE_ERROR = -94;
    static const int WRONG_DATA_LENGTH = -95;
    static const int WRONG_MODE = -96;
    static const int UNKNOWN_DWARFxx_ERROR_CODE = -97;
    static const int RESPONSE_SHORT = -98;
    static const int UNEXPECTED_TAG_ID_IN_RESPONSE = -99;
    static const int UNEXPECTED_TAG_INDEX = -100;
    static const int READ_EOF = -101;
    static const int READ_OK_SOFAR = -102;
    static const int WRITE_DATA_MISSING = -103;
    static const int WRITE_TOO_MUCH_DATA = -104;
    static const int TRANSFER_CLOSED = -105;
    static const int COULD_NOT_BUILD_REQUEST = -106;
    static const int INVALID_OPTIONS = -107;
    static const int UNEXPECTED_RESPONSE = -108;
    static const int AFI_NOT_AVAILABLE = -109;
    static const int DSFID_NOT_AVAILABLE = -110;
    static const int TAG_RESPONSE_TOO_SHORT = -111;
    static const int DEC_EXPECTED = -112 ;
    static const int HEX_EXPECTED = -113;
    static const int NOT_SAME_SECOR = -114;
    static const int MIFARE_AUTHENTICATED = -115;
    static const int NO_DATABLOCK = -116;
    static const int KEYB_IS_READABLE = -117;
    static const int OPERATION_NOT_EXECUTED = -118;
    static const int BLOK_MODE_ERROR = -119;
    static const int BLOCK_NOT_WRITABLE = -120;
    static const int BLOCK_ACCESS_ERROR = -121;
    static const int BLOCK_NOT_AUTHENTICATED = -122;
    static const int ACCESS_KEY_BIT_NOT_WRITABLE = -123;
    static const int USE_KEYA_FOR_AUTH = -124;
    static const int USE_KEYB_FOR_AUTH = -125;
    static const int KEY_NOT_CHANGEABLE = -126;
    static const int BLOCK_TOO_HIGH = -127;
    static const int AUTH_ERR = -128;
    static const int NOKEY_SELECT = -129;
    static const int CARD_NOT_SELECTED = -130;
    static const int BLOCK_TO_READ_NONE = -131;
    static const int NO_TAG = -132;
    static const int TOO_MUCH_DATA = -133;
    static const int CON_NOT_SATISFIED = -134;
    static const int BLOCK_IS_SPECIAL = -135;
    static const int READ_BEYOND_ANNOUNCED_SIZE = -136;
    static const int BLOCK_ZERO_IS_RESERVED = -137;
    static const int VALUE_BLOCK_BAD_FORMAT = -138;
    static const int ISO15693_ONLY_FEATURE = -139;
    static const int ISO14443_ONLY_FEATURE = -140;
    static const int MIFARE_CLASSIC_ONLY_FEATURE = -141;
    static const int BLOCK_MIGHT_BE_PROTECTED = -142;
    static const int NO_SUCH_BLOCK = -143;
    static const int COUNT_TOO_BIG = -144;
    static const int UNKNOWN_MEM_SIZE = -145;
    static const int MORE_THAN_2BLOCKS_MIGHT_NOT_WORK = -146;
    static const int READWRITE_NOT_SUPPORTED = -147;
    static const int UNEXPECTED_VICC_ID_IN_RESPONSE = -148;
    static const int LOCKBLOCK_NOT_SUPPORTED = -150;
    static const int INTERNAL_ERROR_SHOULD_NEVER_HAPPEN = -151;
    static const int INVLD_BLOCK_MODE_COMBINATION = -152;
    static const int INVLD_ACCESS_MODE_COMBINATION = -153;
    static const int INVALID_SIZE = -154;
    static const int BAD_PASSWORD_FORMAT = -155;
    static const int RADIO_IS_OFF = -156;
    static const int NOT_AVAILABLE_ON_THIS_TAG = -157;
    static const int PASSWORD_FEATURE_NOT_SUPPORTED = -158;
    static const int BAD_PASSWORD_LENGTH = -159 ;
    static const int BAD_PASSWORD_TYPE = -160;
    static const int BAD_PASSWORD = -161;
    static const int PASSWORD_REQUIRED = -162;
    static const int MULTIWRITE_NOT_SUPPORTED = -163;
    static const int MULTIREAD_NOT_SUPPORTED = -164;

    /**
     * Returns RFID tag identifier related to the status.
     *
     * @return a string with the RFID tag identifier.
     */
    virtual string      get_tagId(void);

    /**
     * Returns the detailled error code, or 0 if no error happened.
     *
     * @return a numeric error code
     */
    virtual int         get_errorCode(void);

    /**
     * Returns the RFID tag memory block number where the error was encountered, or -1 if the
     * error is not specific to a memory block.
     *
     * @return an RFID tag block number
     */
    virtual int         get_errorBlock(void);

    /**
     * Returns a string describing precisely the RFID commande result.
     *
     * @return an error message string
     */
    virtual string      get_errorMessage(void);

    virtual int         get_yapiError(void);

    /**
     * Returns the block number of the first RFID tag memory block affected
     * by the operation. Depending on the type of operation and on the tag
     * memory granularity, this number may be smaller than the requested
     * memory block index.
     *
     * @return an RFID tag block number
     */
    virtual int         get_firstAffectedBlock(void);

    /**
     * Returns the block number of the last RFID tag memory block affected
     * by the operation. Depending on the type of operation and on the tag
     * memory granularity, this number may be bigger than the requested
     * memory block index.
     *
     * @return an RFID tag block number
     */
    virtual int         get_lastAffectedBlock(void);

    virtual void        imm_init(string tagId,int errCode,int errBlk,int fab,int lab);

#ifdef __BORLANDC__
#pragma option pop
#endif
    //--- (end of generated code: YRfidStatus accessors declaration)
};

//--- (generated code: YRfidStatus functions declaration)
//--- (end of generated code: YRfidStatus functions declaration)


//--- (generated code: YRfidReader return codes)
//--- (end of generated code: YRfidReader return codes)
//--- (generated code: YRfidReader yapiwrapper)
//--- (end of generated code: YRfidReader yapiwrapper)
//--- (generated code: YRfidReader definitions)
class YRfidReader; // forward declaration

typedef void (*YRfidReaderValueCallback)(YRfidReader *func, const string& functionValue);
typedef void (*YEventCallback)(YRfidReader *obj, double timestamp, const string& eventType, const string& eventData);

#define Y_NTAGS_INVALID                 (YAPI_INVALID_UINT)
#define Y_REFRESHRATE_INVALID           (YAPI_INVALID_UINT)
//--- (end of generated code: YRfidReader definitions)

//--- (generated code: YRfidReader declaration)
/**
 * YRfidReader Class: RfidReader function interface
 *
 * The YRfidReader class allows you to detect RFID tags, as well as
 * read and write on these tags if the security settings allow it.
 *
 * Short reminder:
 *
 * - A tag's memory is generally organized in fixed-size blocks.
 * - At tag level, each block must be read and written in its entirety.
 * - Some blocks are special configuration blocks, and may alter the tag's behavior
 * if they are rewritten with arbitrary data.
 * - Data blocks can be set to read-only mode, but on many tags, this operation is irreversible.
 *
 *
 * By default, the RfidReader class automatically manages these blocks so that
 * arbitrary size data  can be manipulated of  without risk and without knowledge of
 * tag architecture.
 */
class YOCTO_CLASS_EXPORT YRfidReader: public YFunction {
#ifdef __BORLANDC__
#pragma option push -w-8022
#endif
//--- (end of generated code: YRfidReader declaration)
protected:
    static void yInternalEventCallback(YRfidReader *obj, const string& value);

    //--- (generated code: YRfidReader attributes)
    // Attributes (function value cache)
    int             _nTags;
    int             _refreshRate;
    YRfidReaderValueCallback _valueCallbackRfidReader;
    YEventCallback  _eventCallback;
    bool            _isFirstCb;
    int             _prevCbPos;
    int             _eventPos;
    int             _eventStamp;

    friend YRfidReader *yFindRfidReader(const string& func);
    friend YRfidReader *yFirstRfidReader(void);

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

    // Constructor is protected, use yFindRfidReader factory function to instantiate
    YRfidReader(const string& func);
    //--- (end of generated code: YRfidReader attributes)

public:
    virtual ~YRfidReader();
    //--- (generated code: YRfidReader accessors declaration)

    static const int NTAGS_INVALID = YAPI_INVALID_UINT;
    static const int REFRESHRATE_INVALID = YAPI_INVALID_UINT;

    /**
     * Returns the number of RFID tags currently detected.
     *
     * @return an integer corresponding to the number of RFID tags currently detected
     *
     * On failure, throws an exception or returns YRfidReader::NTAGS_INVALID.
     */
    int                 get_nTags(void);

    inline int          nTags(void)
    { return this->get_nTags(); }

    /**
     * Returns the tag list refresh rate, measured in Hz.
     *
     * @return an integer corresponding to the tag list refresh rate, measured in Hz
     *
     * On failure, throws an exception or returns YRfidReader::REFRESHRATE_INVALID.
     */
    int                 get_refreshRate(void);

    inline int          refreshRate(void)
    { return this->get_refreshRate(); }

    /**
     * Changes the present tag list refresh rate, measured in Hz. The reader will do
     * its best to respect it. Note that the reader cannot detect tag arrival or removal
     * while it is  communicating with a tag.  Maximum frequency is limited to 100Hz,
     * but in real life it will be difficult to do better than 50Hz.  A zero value
     * will power off the device radio.
     * Remember to call the saveToFlash() method of the module if the
     * modification must be kept.
     *
     * @param newval : an integer corresponding to the present tag list refresh rate, measured in Hz
     *
     * @return YAPI::SUCCESS if the call succeeds.
     *
     * On failure, throws an exception or returns a negative error code.
     */
    int             set_refreshRate(int newval);
    inline int      setRefreshRate(int newval)
    { return this->set_refreshRate(newval); }

    /**
     * Retrieves a RFID reader for a given identifier.
     * The identifier can be specified using several formats:
     *
     * - FunctionLogicalName
     * - ModuleSerialNumber.FunctionIdentifier
     * - ModuleSerialNumber.FunctionLogicalName
     * - ModuleLogicalName.FunctionIdentifier
     * - ModuleLogicalName.FunctionLogicalName
     *
     *
     * This function does not require that the RFID reader is online at the time
     * it is invoked. The returned object is nevertheless valid.
     * Use the method isOnline() to test if the RFID reader is
     * indeed online at a given time. In case of ambiguity when looking for
     * a RFID reader by logical name, no error is notified: the first instance
     * found is returned. The search is performed first by hardware name,
     * then by logical name.
     *
     * If a call to this object's is_online() method returns FALSE although
     * you are certain that the matching device is plugged, make sure that you did
     * call registerHub() at application initialization time.
     *
     * @param func : a string that uniquely characterizes the RFID reader, for instance
     *         MyDevice.rfidReader.
     *
     * @return a YRfidReader object allowing you to drive the RFID reader.
     */
    static YRfidReader* FindRfidReader(string func);

    /**
     * Registers the callback function that is invoked on every change of advertised value.
     * The callback is then invoked only during the execution of ySleep or yHandleEvents.
     * This provides control over the time when the callback is triggered. For good responsiveness,
     * remember to call one of these two functions periodically. The callback is called once juste after beeing
     * registered, passing the current advertised value  of the function, provided that it is not an empty string.
     * To unregister a callback, pass a NULL pointer as argument.
     *
     * @param callback : the callback function to call, or a NULL pointer. The callback function should take two
     *         arguments: the function object of which the value has changed, and the character string describing
     *         the new advertised value.
     * @noreturn
     */
    virtual int         registerValueCallback(YRfidReaderValueCallback callback);
    using YFunction::registerValueCallback;

    virtual int         _invokeValueCallback(string value);

    virtual int         _chkerror(string tagId,string json,YRfidStatus& status);

    virtual int         reset(void);

    /**
     * Returns the list of RFID tags currently detected by the reader.
     *
     * @return a list of strings, corresponding to each tag identifier (UID).
     *
     * On failure, throws an exception or returns an empty list.
     */
    virtual vector<string> get_tagIdList(void);

    /**
     * Returns a description of the properties of an existing RFID tag.
     * This function can cause communications with the tag.
     *
     * @param tagId : identifier of the tag to check
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return a YRfidTagInfo object.
     *
     * On failure, throws an exception or returns an empty YRfidTagInfo objact.
     * When it happens, you can get more information from the status object.
     */
    virtual YRfidTagInfo get_tagInfo(string tagId,YRfidStatus& status);

    /**
     * Changes an RFID tag configuration to prevents any further write to
     * the selected blocks. This operation is definitive and irreversible.
     * Depending on the tag type and block index, adjascent blocks may become
     * read-only as well, based on the locking granularity.  Note that some tags
     * may allow only a few blocks to be locked, for instance ST25DVxxx  tags
     * allows a lock on block 0 and 1 only.
     *
     *
     *
     * @param tagId : identifier of the tag to use
     * @param firstBlock : first block to lock
     * @param nBlocks : number of blocks to lock
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return YAPI::SUCCESS if the call succeeds.
     *
     * On failure, throws an exception or returns a negative error code. When it
     * happens, you can get more information from the status object.
     */
    virtual int         tagLockBlocks(string tagId,int firstBlock,int nBlocks,YRfidOptions options,YRfidStatus& status);

    /**
     * Reads the locked state for RFID tag memory data blocks.
     * FirstBlock cannot be a special block, and any special
     * block encountered in the middle of the read operation will be
     * skipped automatically.
     *
     * @param tagId : identifier of the tag to use
     * @param firstBlock : number of the first block to check
     * @param nBlocks : number of blocks to check
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return a list of booleans with the lock state of selected blocks
     *
     * On failure, throws an exception or returns an empty list. When it
     * happens, you can get more information from the status object.
     */
    virtual vector<bool> get_tagLockState(string tagId,int firstBlock,int nBlocks,YRfidOptions options,YRfidStatus& status);

    /**
     * Tells which block of a RFID tag memory are special and cannot be used
     * to store user data. Mistakely writing a special block can lead to
     * an irreversible alteration of the tag.
     *
     * @param tagId : identifier of the tag to use
     * @param firstBlock : number of the first block to check
     * @param nBlocks : number of blocks to check
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return a list of booleans with the lock state of selected blocks
     *
     * On failure, throws an exception or returns an empty list. When it
     * happens, you can get more information from the status object.
     */
    virtual vector<bool> get_tagSpecialBlocks(string tagId,int firstBlock,int nBlocks,YRfidOptions options,YRfidStatus& status);

    /**
     * Reads data from an RFID tag memory, as an hexadecimal string.
     * The read operation may span accross multiple blocks if the requested
     * number of bytes is larger than the RFID tag block size. By default
     * firstBlock cannot be a special block, and any special block encountered
     * in the middle of the read operation will be skipped automatically.
     * If you rather want to read special blocks, use the EnableRawAccess
     * field from the options parameter.
     *
     * @param tagId : identifier of the tag to use
     * @param firstBlock : block number where read should start
     * @param nBytes : total number of bytes to read
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return an hexadecimal string if the call succeeds.
     *
     * On failure, throws an exception or returns an empty binary buffer. When it
     * happens, you can get more information from the status object.
     */
    virtual string      tagReadHex(string tagId,int firstBlock,int nBytes,YRfidOptions options,YRfidStatus& status);

    /**
     * Reads data from an RFID tag memory, as a binary buffer. The read operation
     * may span accross multiple blocks if the requested number of bytes
     * is larger than the RFID tag block size.  By default
     * firstBlock cannot be a special block, and any special block encountered
     * in the middle of the read operation will be skipped automatically.
     * If you rather want to read special blocks, use the EnableRawAccess
     * field frrm the options parameter.
     *
     * @param tagId : identifier of the tag to use
     * @param firstBlock : block number where read should start
     * @param nBytes : total number of bytes to read
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return a binary object with the data read if the call succeeds.
     *
     * On failure, throws an exception or returns an empty binary buffer. When it
     * happens, you can get more information from the status object.
     */
    virtual string      tagReadBin(string tagId,int firstBlock,int nBytes,YRfidOptions options,YRfidStatus& status);

    /**
     * Reads data from an RFID tag memory, as a byte list. The read operation
     * may span accross multiple blocks if the requested number of bytes
     * is larger than the RFID tag block size.  By default
     * firstBlock cannot be a special block, and any special block encountered
     * in the middle of the read operation will be skipped automatically.
     * If you rather want to read special blocks, use the EnableRawAccess
     * field from the options parameter.
     *
     * @param tagId : identifier of the tag to use
     * @param firstBlock : block number where read should start
     * @param nBytes : total number of bytes to read
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return a byte list with the data read if the call succeeds.
     *
     * On failure, throws an exception or returns an empty list. When it
     * happens, you can get more information from the status object.
     */
    virtual vector<int> tagReadArray(string tagId,int firstBlock,int nBytes,YRfidOptions options,YRfidStatus& status);

    /**
     * Reads data from an RFID tag memory, as a text string. The read operation
     * may span accross multiple blocks if the requested number of bytes
     * is larger than the RFID tag block size.  By default
     * firstBlock cannot be a special block, and any special block encountered
     * in the middle of the read operation will be skipped automatically.
     * If you rather want to read special blocks, use the EnableRawAccess
     * field from the options parameter.
     *
     * @param tagId : identifier of the tag to use
     * @param firstBlock : block number where read should start
     * @param nChars : total number of characters to read
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return a text string with the data read if the call succeeds.
     *
     * On failure, throws an exception or returns an empty string. When it
     * happens, you can get more information from the status object.
     */
    virtual string      tagReadStr(string tagId,int firstBlock,int nChars,YRfidOptions options,YRfidStatus& status);

    /**
     * Writes data provided as a binary buffer to an RFID tag memory.
     * The write operation may span accross multiple blocks if the
     * number of bytes to write is larger than the RFID tag block size.
     * By default firstBlock cannot be a special block, and any special block
     * encountered in the middle of the write operation will be skipped
     * automatically. The last data block affected by the operation will
     * be automatically padded with zeros if neccessary.  If you rather want
     * to rewrite special blocks as well,
     * use the EnableRawAccess field from the options parameter.
     *
     * @param tagId : identifier of the tag to use
     * @param firstBlock : block number where write should start
     * @param buff : the binary buffer to write
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return YAPI::SUCCESS if the call succeeds.
     *
     * On failure, throws an exception or returns a negative error code. When it
     * happens, you can get more information from the status object.
     */
    virtual int         tagWriteBin(string tagId,int firstBlock,string buff,YRfidOptions options,YRfidStatus& status);

    /**
     * Writes data provided as a list of bytes to an RFID tag memory.
     * The write operation may span accross multiple blocks if the
     * number of bytes to write is larger than the RFID tag block size.
     * By default firstBlock cannot be a special block, and any special block
     * encountered in the middle of the write operation will be skipped
     * automatically. The last data block affected by the operation will
     * be automatically padded with zeros if neccessary.
     * If you rather want to rewrite special blocks as well,
     * use the EnableRawAccess field from the options parameter.
     *
     * @param tagId : identifier of the tag to use
     * @param firstBlock : block number where write should start
     * @param byteList : a list of byte to write
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return YAPI::SUCCESS if the call succeeds.
     *
     * On failure, throws an exception or returns a negative error code. When it
     * happens, you can get more information from the status object.
     */
    virtual int         tagWriteArray(string tagId,int firstBlock,vector<int> byteList,YRfidOptions options,YRfidStatus& status);

    /**
     * Writes data provided as an hexadecimal string to an RFID tag memory.
     * The write operation may span accross multiple blocks if the
     * number of bytes to write is larger than the RFID tag block size.
     * By default firstBlock cannot be a special block, and any special block
     * encountered in the middle of the write operation will be skipped
     * automatically. The last data block affected by the operation will
     * be automatically padded with zeros if neccessary.
     * If you rather want to rewrite special blocks as well,
     * use the EnableRawAccess field from the options parameter.
     *
     * @param tagId : identifier of the tag to use
     * @param firstBlock : block number where write should start
     * @param hexString : a string of hexadecimal byte codes to write
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return YAPI::SUCCESS if the call succeeds.
     *
     * On failure, throws an exception or returns a negative error code. When it
     * happens, you can get more information from the status object.
     */
    virtual int         tagWriteHex(string tagId,int firstBlock,string hexString,YRfidOptions options,YRfidStatus& status);

    /**
     * Writes data provided as an ASCII string to an RFID tag memory.
     * The write operation may span accross multiple blocks if the
     * number of bytes to write is larger than the RFID tag block size.
     * Note that only the characters present in the provided string
     * will be written, there is no notion of string length. If your
     * string data have variable length, you'll have to encode the
     * string length yourself, with a terminal zero for instannce.
     *
     * This function only works with ISO-latin characters, if you wish to
     * write strings encoded with alternate character sets, you'll have to
     * use tagWriteBin() function.
     *
     * By default firstBlock cannot be a special block, and any special block
     * encountered in the middle of the write operation will be skipped
     * automatically. The last data block affected by the operation will
     * be automatically padded with zeros if neccessary.
     * If you rather want to rewrite special blocks as well,
     * use the EnableRawAccess field from the options parameter
     * (definitely not recommanded).
     *
     * @param tagId : identifier of the tag to use
     * @param firstBlock : block number where write should start
     * @param text : the text string to write
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return YAPI::SUCCESS if the call succeeds.
     *
     * On failure, throws an exception or returns a negative error code. When it
     * happens, you can get more information from the status object.
     */
    virtual int         tagWriteStr(string tagId,int firstBlock,string text,YRfidOptions options,YRfidStatus& status);

    /**
     * Writes data provided as a binary object to an RFID tag, using NFC
     * compatible encoding.
     * The function will automatically create a NFC Capability Container,
     * and encapsulate the content with the required NDEF header corresponding
     * to the given content type.
     *
     * @param tagId : identifier of the tag to use
     * @param ndefType : the content type, either "U" for a URL, or a
     *         generic MIME type like "text/vcard"
     * @param payload : the payload of the NDEF record
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return YAPI::SUCCESS if the call succeeds.
     *
     * On failure, throws an exception or returns a negative error code. When it
     * happens, you can get more information from the status object.
     */
    virtual int         tagWriteBinNFC(string tagId,string ndefType,string payload,YRfidOptions options,YRfidStatus& status);

    /**
     * Writes an URL to an RFID tag using NFC compatible encoding, so that
     * mobile phones with NFC support automatically offer to open
     * the URL when reading the tag.
     *
     * @param tagId : identifier of the tag to use
     * @param url : the URL to write on the tag
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return YAPI::SUCCESS if the call succeeds.
     *
     * On failure, throws an exception or returns a negative error code. When it
     * happens, you can get more information from the status object.
     */
    virtual int         tagWriteUrlNFC(string tagId,string url,YRfidOptions options,YRfidStatus& status);

    /**
     * Writes WiFi settings to an RFID tag using NFC compatible encoding, so that
     * mobile phones with NFC support automatically offer to connect to this WiFi
     * network.
     *
     * @param tagId : identifier of the tag to use
     * @param ssid : the SSID of the WiFi network to connect to
     * @param auth : the network authentication type (currently always "WPA2")
     * @param secret : the network password
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return YAPI::SUCCESS if the call succeeds.
     *
     * On failure, throws an exception or returns a negative error code. When it
     * happens, you can get more information from the status object.
     */
    virtual int         tagWriteWifiConfigNFC(string tagId,string ssid,string auth,string secret,YRfidOptions options,YRfidStatus& status);

    /**
     * Reads an RFID tag AFI byte (ISO 15693 only).
     *
     * @param tagId : identifier of the tag to use
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return the AFI value (0...255)
     *
     * On failure, throws an exception or returns a negative error code. When it
     * happens, you can get more information from the status object.
     */
    virtual int         tagGetAFI(string tagId,YRfidOptions options,YRfidStatus& status);

    /**
     * Reads a byte from the Tag configuration (ISO 15693 ST25DVxx only).
     * This function is actually a call to the 0xA0 RFID command and is specific to
     * ST25DVxx tags. Check ST25DVxx datasheet for more information about
     * the data organisation of ST25DVxx tags configuration.
     *
     * @param tagId : identifier of the tag to use
     * @param addr  : offset of the byte in the tag configuation
     *
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return the requested byte value (0...255)
     *
     * On failure, throws an exception or returns a negative error code. When it
     * happens, you can get more information from the status object.
     */
    virtual int         tagGetConfigByte(string tagId,int addr,YRfidOptions options,YRfidStatus& status);

    /**
     * Changes a byte in the tag's configuration (ISO 15693 ST25DVxx only).
     * Warning: modifing the tag configation may alter its behavior in a non-reversible way.
     * This operation requires the CONFIG_PWD password to be set in the options,
     * default value is "0000000000000000" (16 zeros). This function is actually
     * a call to the 0xA1 RFID command and is specific to ST25DVxx tags. Check
     * ST25DVxx datasheet for more information about the data organisation
     * of ST25DVxx tags configuration.
     *
     * @param tagId : identifier of the tag to use
     * @param addr  : address of the byte to write
     * @param value : the value to write (0...255)
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return YAPI::SUCCESS if the call succeeds.
     *
     * On failure, throws an exception or returns a negative error code. When it
     * happens, you can get more information from the status object.
     */
    virtual int         tagSetConfigByte(string tagId,int addr,int value,YRfidOptions options,YRfidStatus& status);

    /**
     * Set a password that will be required to access the tag  (ISO 15693 ST25DVxx only).
     * The password must be a string of characters representing 8 bytes in hexadecimal.
     * There are several types of password for the same tag; please consult your tags
     * documentation to understand their respective applications. Once the password
     * has been configured, operations requiring this password must be initiated with
     * the password defined in the KeyType and HexKey fields of the
     * options parameter for the operations in question. It is not necessarily
     * required to consistently provide the same password for every operation during the
     * same session with a tag.
     *
     * @param tagId : identifier of the tag to use
     * @param passwordType  : type of password to be set (YRfidOptions.ST25D_CONFIG_PWD,YRfidOptions.ST25D_PWD1,YRfidOptions.ST25D_PWD2..)
     * @param password : the password (16 characters hex string encoding 8 bytes)
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return YAPI::SUCCESS if the call succeeds.
     *
     * On failure, throws an exception or returns a negative error code. When it
     * happens, you can get more information from the status object.
     */
    virtual int         tagSetPassword(string tagId,int passwordType,string password,YRfidOptions options,YRfidStatus& status);

    /**
     * Changes an RFID tag AFI byte (ISO 15693 only).
     *
     * @param tagId : identifier of the tag to use
     * @param afi : the AFI value to write (0...255)
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return YAPI::SUCCESS if the call succeeds.
     *
     * On failure, throws an exception or returns a negative error code. When it
     * happens, you can get more information from the status object.
     */
    virtual int         tagSetAFI(string tagId,int afi,YRfidOptions options,YRfidStatus& status);

    /**
     * Locks the RFID tag AFI byte (ISO 15693 only).
     * This operation is definitive and irreversible.
     *
     * @param tagId : identifier of the tag to use
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return YAPI::SUCCESS if the call succeeds.
     *
     * On failure, throws an exception or returns a negative error code. When it
     * happens, you can get more information from the status object.
     */
    virtual int         tagLockAFI(string tagId,YRfidOptions options,YRfidStatus& status);

    /**
     * Reads an RFID tag DSFID byte (ISO 15693 only).
     *
     * @param tagId : identifier of the tag to use
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return the DSFID value (0...255)
     *
     * On failure, throws an exception or returns a negative error code. When it
     * happens, you can get more information from the status object.
     */
    virtual int         tagGetDSFID(string tagId,YRfidOptions options,YRfidStatus& status);

    /**
     * Changes an RFID tag DSFID byte (ISO 15693 only).
     *
     * @param tagId : identifier of the tag to use
     * @param dsfid : the DSFID value to write (0...255)
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return YAPI::SUCCESS if the call succeeds.
     *
     * On failure, throws an exception or returns a negative error code. When it
     * happens, you can get more information from the status object.
     */
    virtual int         tagSetDSFID(string tagId,int dsfid,YRfidOptions options,YRfidStatus& status);

    /**
     * Locks the RFID tag DSFID byte (ISO 15693 only).
     * This operation is definitive and irreversible.
     *
     * @param tagId : identifier of the tag to use
     * @param options : an YRfidOptions object with the optional
     *         command execution parameters, such as security key
     *         if required
     * @param status : an RfidStatus object that will contain
     *         the detailled status of the operation
     *
     * @return YAPI::SUCCESS if the call succeeds.
     *
     * On failure, throws an exception or returns a negative error code. When it
     * happens, you can get more information from the status object.
     */
    virtual int         tagLockDSFID(string tagId,YRfidOptions options,YRfidStatus& status);

    /**
     * Returns a string with last tag arrival/removal events observed.
     * This method return only events that are still buffered in the device memory.
     *
     * @return a string with last events observed (one per line).
     *
     * On failure, throws an exception or returns  YAPI::INVALID_STRING.
     */
    virtual string      get_lastEvents(void);

    /**
     * Registers a callback function to be called each time that an RFID tag appears or
     * disappears. The callback is invoked only during the execution of
     * ySleep or yHandleEvents. This provides control over the time when
     * the callback is triggered. For good responsiveness, remember to call one of these
     * two functions periodically. To unregister a callback, pass a NULL pointer as argument.
     *
     * @param callback : the callback function to call, or a NULL pointer.
     *         The callback function should take four arguments:
     *         the YRfidReader object that emitted the event, the
     *         UTC timestamp of the event, a character string describing
     *         the type of event ("+" or "-") and a character string with the
     *         RFID tag identifier.
     *         On failure, throws an exception or returns a negative error code.
     */
    virtual int         registerEventCallback(YEventCallback callback);

    virtual int         _internalEventHandler(string cbVal);


    inline static YRfidReader *Find(string func)
    { return YRfidReader::FindRfidReader(func); }

    /**
     * Continues the enumeration of RFID readers started using yFirstRfidReader().
     * Caution: You can't make any assumption about the returned RFID readers order.
     * If you want to find a specific a RFID reader, use RfidReader.findRfidReader()
     * and a hardwareID or a logical name.
     *
     * @return a pointer to a YRfidReader object, corresponding to
     *         a RFID reader currently online, or a NULL pointer
     *         if there are no more RFID readers to enumerate.
     */
           YRfidReader     *nextRfidReader(void);
    inline YRfidReader     *next(void)
    { return this->nextRfidReader();}

    /**
     * Starts the enumeration of RFID readers currently accessible.
     * Use the method YRfidReader::nextRfidReader() to iterate on
     * next RFID readers.
     *
     * @return a pointer to a YRfidReader object, corresponding to
     *         the first RFID reader currently online, or a NULL pointer
     *         if there are none.
     */
           static YRfidReader *FirstRfidReader(void);
    inline static YRfidReader *First(void)
    { return YRfidReader::FirstRfidReader();}
#ifdef __BORLANDC__
#pragma option pop
#endif
    //--- (end of generated code: YRfidReader accessors declaration)
};

//--- (generated code: YRfidReader functions declaration)

/**
 * Retrieves a RFID reader for a given identifier.
 * The identifier can be specified using several formats:
 *
 * - FunctionLogicalName
 * - ModuleSerialNumber.FunctionIdentifier
 * - ModuleSerialNumber.FunctionLogicalName
 * - ModuleLogicalName.FunctionIdentifier
 * - ModuleLogicalName.FunctionLogicalName
 *
 *
 * This function does not require that the RFID reader is online at the time
 * it is invoked. The returned object is nevertheless valid.
 * Use the method isOnline() to test if the RFID reader is
 * indeed online at a given time. In case of ambiguity when looking for
 * a RFID reader by logical name, no error is notified: the first instance
 * found is returned. The search is performed first by hardware name,
 * then by logical name.
 *
 * If a call to this object's is_online() method returns FALSE although
 * you are certain that the matching device is plugged, make sure that you did
 * call registerHub() at application initialization time.
 *
 * @param func : a string that uniquely characterizes the RFID reader, for instance
 *         MyDevice.rfidReader.
 *
 * @return a YRfidReader object allowing you to drive the RFID reader.
 */
inline YRfidReader *yFindRfidReader(const string& func)
{ return YRfidReader::FindRfidReader(func);}
/**
 * Starts the enumeration of RFID readers currently accessible.
 * Use the method YRfidReader::nextRfidReader() to iterate on
 * next RFID readers.
 *
 * @return a pointer to a YRfidReader object, corresponding to
 *         the first RFID reader currently online, or a NULL pointer
 *         if there are none.
 */
inline YRfidReader *yFirstRfidReader(void)
{ return YRfidReader::FirstRfidReader();}

//--- (end of generated code: YRfidReader functions declaration)

#ifdef YOCTOLIB_NAMESPACE
// end of namespace definition
}
#endif

#endif
