API Documentation

Reminder about the const keyword modifier

Note in the code examples that the first formal parameter, pNxCoreSys, is a pointer to a structure of type NxCoreSystem. The c keyword const appears before the two formal variables pNxCoreSys and pNxCoreMsg instructing the compiler the data pointed to by the pointer will not be modified. That is, the data pointed to by pNxCoreSys and pNxCoreMsg will not be modified by your callback function. And here, we come to one of the few rules of processing the NxCoreAPI Feed:

Rule #1. Never change the data in the structures passed to your callback function.

The const keywords are added for your convenience. Should you write code that attempts to modify the data structures NxCoreSystem or NxCoreMessage, the compiler, at compile time, will generate an error. When you pass these pointers, or data members within the structures to other functions, you need to include the const keyword to keep the compiler quiet. As you can see in the sample code, the function we added, processNxCoreStatus also uses the const keyword in the formal parameter list: if it did not, the compiler would have generated an compile-time error. Propagating this const keyword further ensures the other functions don't make the mistake of modifying the contents of these structures.

Callback Return Values

Previously, we learned how to dynamically link to the NxCoreAPI.dll and initiate the processing of NxCore Feed in our call back. We now examine the basic form and function of the callback function. Our callback function looked like this:

int __stdcall OnNxCoreCallback(const NxCoreSystem* pNxCoreSys, const NxCoreMessage* pNxCoreMsg)
{
    printf("Hello World\n");
    return NxCALLBACKRETURN_STOP;
}

If you had run this callback code, you would have received only one callback and then the call you made to nxapiProcessTape would have returned. The quick termination was result of our example callback returning NxCALLBACKRETURN_STOP. The other possible callback return values are defined in NxCoreAPI.h as:

Skeleton Callback

After removing "Hello World", changing the return value, and adding a switch statement with a case for each possible message type, we have a callback which looks like this:

#include "NxCoreAPI.h"
int __stdcall OnNxCoreCallback(const NxCoreSystem* pNxCoreSys, const NxCoreMessage* pNxCoreMsg)
{
    switch( pNxCoreMsg->MessageType ) {
        case NxMSG_STATUS:       break;
        case NxMSG_EXGQUOTE:     break;
        case NxMSG_MMQUOTE:      break;
        case NxMSG_TRADE:        break;
        case NxMSG_CATEGORY:     break;
        case NxMSG_SYMBOLCHANGE: break;
        case NxMSG_SYMBOLSPIN:   break;
    }
    return NxCALLBACKRETURN_CONTINUE;
}

The 7 Message Types

As you can see from the code and defined in NxCoreAPI.h, there are 7 different message types. The second parameter to the callback, pNxCoreMsg, points to a structure of type NxCoreMessage which has the data member MessageType. The switch statement in our callback selects a case statement based on the message type. Briefly, the 7 message types are:

Setting the Callback

The simple example shows how to set the callback function:

#include <windows.h>
#include "NxCoreAPI.h"
#include "NxCoreAPI_class.h" 			 
 			 
NxCoreClass nxCoreClass; 			 
 			 

// The callback
int __stdcall nxCoreCallback(const NxCoreSystem* pNxCoreSys, const NxCoreMessage* pNxCoreMessage)
{
    switch( pNxCoreMsg->MessageType ) {
        case NxMSG_STATUS:       break;
        case NxMSG_EXGQUOTE:     break;
        case NxMSG_MMQUOTE:      break;
        case NxMSG_TRADE:        break;
        case NxMSG_CATEGORY:     break;
        case NxMSG_SYMBOLCHANGE: break;
    }
    return NxCALLBACKRETURN_CONTINUE;
} 			 
 			 
int main(int argc, char** argv)
{
    if (!nxCoreClass.LoadNxCore("NxCoreAPI.dll") &&
        !nxCoreClass.LoadNxCore("C:\\Program Files\\Nanex\\NxCoreAPI\\NxCoreAPI.dll"))
    {
        fprintf(stderr, "Can't find NxCoreAPI.dll\n");
        return -1;
    } 			 
 			 

    // Set the callback function
    nxCoreClass.ProcessTape(argv[1], 0, NxCF_EXCLUDE_CRC_CHECK, 0, nxCoreCallback);
    return 0;
}