NxMSG_STATUS

NxMSG_STATUS message

Status messages are unique in that they do not have a corresponding NxCoreMessage data structure.

Status messages are sent on initialization, whenever the NxCore millisecond clock changes, if any errors are detected, when a tape completes or restarts, on shutdown and when paused waiting for more data. Nanex Clock changes occur at 1 millisecond intervals when trading is active making this the most frequent reason for receiving a NxMSG_STATUS message.

Since NxCore API is a callback model, these frequent callbacks give your program frequent opportunity to perform tasks.

Simplest example

Here's the simplest example.


#include <NxCoreAPI.h>

int processNxCoreStatus(const NxCoreSystem* pNxCoreSys)
{
  return NxCALLBACKRETURN_CONTINUE;
}

int __stdcall OnNxCoreCallback(const NxCoreSystem* pNxCoreSys, const NxCoreMessage* pNxCoreMsg)
{
  switch( pNxCoreMsg->MessageType ) {
      case NxMSG_STATUS:       return processNxCoreStatus(pNxCoreSys);
      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;
}

In the switch statement, the case NxMSG_STATUS calls a new function we added, processNxCoreStatus, and passes the first formal parameter from the Callback function. The Status message does not use the second formal callback parameter pNxCoreMsg, other than testing to see that the message type is NxMSG_STATUS.

Example

Performing different tasks depending on the time of the callback

C++ Java Python

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include "NxCoreAPI.h"
#include "NxCoreAPI_Wrapper_C++.h"              
              
NxCoreClass NxCore;              

int processNxCoreStatus(const NxCoreSystem* pNxCoreSys)
{
    switch( pNxCoreSys->Status ) {
        case NxCORESTATUS_RUNNING:       // all is well.
            break;
        case NxCORESTATUS_INITIALIZING:  // start up code.
            break;
        case NxCORESTATUS_COMPLETE:      // tear down code.
            break;
        case NxCORESTATUS_ERROR:
            printf("Error %s (%d)\n:",pNxCoreSys->StatusDisplay,pNxCoreSys->StatusData);
            return NxCALLBACKRETURN_STOP;   // not required to return this
    }

    if( pNxCoreSys->ClockUpdateInterval >= NxCLOCK_SECOND ) {

        processOneSecondAnalysis();

        if( pNxCoreSys->ClockUpdateInterval >= NxCLOCK_MINUTE ) {  // MINUTE or HOUR
            
            // 9:00,9:01,9:02,9:03.. 9:07 another minute elapsed.. run one minute analysis procedure.
            processOneMinuteAnalysis();

            if( pNxCoreSys->nxTime.Minute % 5 == 0 ) { // on 5 minute interval. 9:00,9:05,9:10, etc
                processFiveMinuteAnalysis();
            }

            if( pNxCoreSys->ClockUpdateInterval == NxCLOCK_HOUR ) {  // HOUR
                processOneHourAnalysis();
            }
        }
    }

    return NxCALLBACKRETURN_CONTINUE;
}

int __stdcall OnNxCoreCallback(const NxCoreSystem* pNxCoreSys, const NxCoreMessage* pNxCoreMsg)
{
    switch( pNxCoreMsg->MessageType ) {
        case NxMSG_STATUS:       return processNxCoreStatus(pNxCoreSys);
        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;
}

import net.nanex.NxCoreClass;
class StatusSample extends NxCoreClass{
    
    int processNxCoreStatus(NxCoreSystem nxCoreSys)
    {
        switch( nxCoreSys.Status ) {
            case defines.NxCORESTATUS_RUNNING:       // all is well.
                break;
            case defines.NxCORESTATUS_INITIALIZING:  // start up code.
                break;
            case defines.NxCORESTATUS_COMPLETE:      // tear down code.
                break;
            case defines.NxCORESTATUS_ERROR:
                //StatusDisplay is not present in Java API
                System.out.println(String.format("Error (%d):",nxCoreSys.StatusData));
                return defines.NxCALLBACKRETURN_STOP;   // not required to return this
        }
    
        if( nxCoreSys.ClockUpdateInterval >= defines.NxCLOCK_SECOND ) {
    
            processOneSecondAnalysis();
    
            if( nxCoreSys.ClockUpdateInterval >= defines.NxCLOCK_MINUTE ) {  // MINUTE or HOUR
                
                // 9:00,9:01,9:02,9:03.. 9:07 another minute elapsed.. run one minute analysis procedure.
                processOneMinuteAnalysis();
    
                if( nxCoreSys.nxTime.Minute % 5 == 0 ) { // on 5 minute interval. 9:00,9:05,9:10, etc
                    processFiveMinuteAnalysis();
                }
    
                if( nxCoreSys.ClockUpdateInterval == defines.NxCLOCK_HOUR ) {  // HOUR
                    processOneHourAnalysis();
                }
            }
        }
    
        return defines.NxCALLBACKRETURN_CONTINUE;
    }

    @Override
    public int OnNxCoreCallback(NxCoreSystem nxCoreSys, NxCoreMessage nxCoreMsg) {
        switch (nxCoreMsg.MessageType)
        {
            case defines.NxMSG_STATUS:       return processNxCoreStatus(nxCoreSys);
            case defines.NxMSG_EXGQUOTE:     break;
            case defines.NxMSG_MMQUOTE:      break;
            case defines.NxMSG_TRADE:        break;
            case defines.NxMSG_CATEGORY:     break;
            case defines.NxMSG_SYMBOLCHANGE: break;
            case defines.NxMSG_SYMBOLSPIN:   break;
        }
        return defines.NxCALLBACKRETURN_CONTINUE;
    }

    public static void main(String args[]) {
        StatusSample nxCore = new StatusSample();

        if (nxCore.LoadNxCore("NxCoreAPI64.dll") != 0){
            nxCore.ProcessTape(args[0], 0, defines.NxCF_EXCLUDE_CRC_CHECK, 0);
        }
        else
            System.out.println("loading library failed");
    }
}

import NxCore

tapePath = ""

def processNxCoreStatus(NxCoreSys):
    if NxCoreSys.Status == NxCore.NxCORESTATUS_RUNNING:       # all is well.
        pass
    if NxCoreSys.Status == NxCore.NxCORESTATUS_INITIALIZING:  # start up code.
        pass
    if NxCoreSys.Status == NxCore.NxCORESTATUS_COMPLETE:      # tear down code.
        pass
    if NxCoreSys.Status == NxCore.NxCORESTATUS_ERROR:
        #StatusDisplay is not present in Java API
        print("Error {}:".format(NxCoreSys.StatusData))
        return NxCore.NxCALLBACKRETURN_STOP;   # not required to return this
    
    if NxCoreSys.ClockUpdateInterval >= NxCore.NxCLOCK_SECOND:
        
        processOneSecondAnalysis();
        
        if NxCoreSys.ClockUpdateInterval >= NxCore.NxCLOCK_MINUTE :  # MINUTE or HOUR
            
            # 9:00,9:01,9:02,9:03.. 9:07 another minute elapsed.. run one minute analysis procedure.
            processOneMinuteAnalysis();
            
            if NxCoreSys.nxTime.Minute % 5 == 0: # on 5 minute interval. 9:00,9:05,9:10, etc
                processFiveMinuteAnalysis();
            
            if NxCoreSys.ClockUpdateInterval == NxCore.NxCLOCK_HOUR:  # HOUR
                processOneHourAnalysis();
    return NxCore.NxCALLBACKRETURN_CONTINUE;

def OnNxCoreCallback(NxCoreSys, NxCoreMsg):
    if NxCoreMsg.MessageType == NxCore.NxMSG_STATUS:
        processNxCoreStatus(NxCoreSys)
    return NxCore.NxCALLBACKRETURN_CONTINUE

if NxCore.LoadNxCore("NxCoreAPI64.dll"):
    returnValue = NxCore.ProcessTape(tapePath, 0, NxCore.NxCF_EXCLUDE_CRC_CHECK, 0, OnNxCoreCallback)
else:
    print("loading library failed")

API Documentation