IO2GTableListener

The interface provides method signatures to process notifications about trading tables events: adding/updating/deleting of rows, and changes in a table status.

The interface can be implemented only when the application uses the IO2GTableManager.

You must specify that your session uses the table manager before a login. For example,

After the successful login, you must obtain an instance of the IO2GTableManager class. For example,

The table manager keeps in memory the trading tables and therefore allows access to the up-to-date field values and ability to capture table events.
If you want to process notifications about specific table events, you must obtain an instance of the class derived from the IO2GTable class. For example, if you need information about opened positions, write the following line:

IO2GTradesTable *tradesTable = (IO2GTradesTable *)tableManager->getTable(Trades);

THe IO2GTableListener is notified only about the trading tables updates (see O2GResponseType.TablesUpdates).
Note:In order to process the response which comes as an answer to a request execution, you application needs to implement the IO2GResponseListener interface.

If you want to use methods of the IO2GTableListener interface, you must create a class that implements the interface. For example,

In your application you must create an instance of the class that implements the interface. For example,

This instance must be subscribed to a table object event.
You must subscribe to each event individually by using different methods of the IO2GTable. For example, if you want to process notifications about updates of the Trades table, call the IO2GTable.subscribeUpdate method as follows:

Before the logout, you must unsubscribe the listener from the table object. For example,

Examples of the subscriprion/unsubscription methods syntax are listed below. These examples are based on the Trades table.

Process notifications about opened positions [hide]

    #include <ForexConnect.h>
    #include <threadlib.h>
 
    class TableListener : public IO2GTableListener
    {
    private:
        // Reference counter
        volatile long mRefCount;
 
    public:
        // Constructor
        TableListener()
        {
            mRefCount = 1;
        }
 
        // Destructor
        ~TableListener()
        {
        }
 
        // Increase reference counter
        long addRef()
        {
            // for non-Windows OS InterlockedIncrement is platform specific macro defined in threadlib.h
            return InterlockedIncrement(&mRefCount);
        }
 
        // Decrease reference counter
        long release()
        {
            // for non-Windows OS InterlockedDecrement is platform specific macro defined in threadlib.h
            long rc = InterlockedDecrement(&mRefCount);
            if (rc == 0)
                delete this;
            return rc;
        }
 
        // Implementation of IO2GTableListener interface public method onAdded
         void onAdded(const char *rowID, IO2GRow *rowData)
         {
           IO2GTradeTableRow *trade = (IO2GTradeTableRow *)(rowData);
           std::cout << "Trade information added " << rowID << std::endl;
           std::cout << "TradeID: " << trade.getTradeID() <<
                        " Close = " << trade.getClose() << std::endl;
        }
 
        // Implementation of IO2GTableListener interface public method onChanged
        void onChanged(const char *rowID, IO2GRow *rowData)
        {
           IO2GTradeTableRow *trade = (IO2GTradeTableRow *)(rowData);
           std::cout << "Trade information changed " << rowID << std::endl;
           std::cout << "TradeID: " << trade.getTradeID() <<
                        " Close = " << trade.getClose() << std::endl;
        }
 
        // Implementation of IO2GTableListener interface public method onDeleted
        void onDeleted(const char *rowID, IO2GRow *rowData)
        {
           IO2GTradeTableRow *trade = (IO2GTradeTableRow *)(rowData);
           std::cout << "Trade information deleted " << rowID);
           std::cout << "TradeID: " << trade.getTradeID() +
                        " Close = " << trade.getClose() << std::endl;
        }
 
        // Implementation of IO2GTableListener interface public method onEachRow
        void onEachRow(const char *rowID, IO2GRow *rowData)
        {
        }
 
        // Implementation of IO2GTableListener interface public method onStatus
        void onStatusChanged(O2GTableStatus status)
        {
        }
    };

Method name	Subscribe syntax	Unsubscribe syntax
`onAdded`	`tradesTable.subscribeUpdate(Insert, tableListener);`	`tradesTable.unsubscribeUpdate(OInsert, tableListener);`
`onChanged`	`tradesTable.subscribeUpdate(Update, tableListener);`	`tradesTable.unsubscribeUpdate(Update, tableListener);`
`onDeleted`	`tradesTable.subscribeUpdate(Delete, tableListener);`	`tradesTable.unsubscribeUpdate(Delete, tableListener);`
`onStatusChanged`	`tradesTable.subscribeStatus(tableListener);`	`tradesTable.unsubscribeStatus(tableListener);`

Public Methods
onAdded	Processes a notification about the row addition to a table.
onChanged	Processes a notification about the row change in a table.
onDeleted	Processes a notification about the row deletion from a table.
onStatusChanged	Processes notifications about a table status changes.

Parents
	`IAddRef`