NxMSG_CATEGORY

NxMSG_CATEGORY message

The second parameter to the NxCoreCallback function, NxCoreMessage, holds the symbol and session information in pNxCoreMessage->coreHeader, and data information in pNxCoreMessage->coreData.Category, which is a NxCoreCategory data structure.

Sent for all other data types, such as fundamental information, 52 week/contract/YTD high/low data, additional trade correction information, exchange code translations, trade/quote condition code translation, trading halts, trading imbalances, open trade indications, etc. A typical trading day will have 1-2 million or so of these message types, with the bulk of them occurring at the start of each tape summarizing the previous trading session.

Importance of SessionDate

It is critical that you look at the pNxCoreMessage->coreHeader.nxSessionDate for every Category, and ensure it's the date you need. Some category messages come in multiple times per day, for the same symbol -- but the data in them is for different dates. Good example of that is the OpenInterest category.

A simple (but incomplete) way of checking if something is "too old" is something like this:

    // if this message's is for a session that's over a week old, skip it
    if (pNxCoreMessage->coreHeader.nxSessionDate.NDays + 7 < pNxCoreSys->nxDate.NDays)
    {
        // skip
    }

Importance of NxCategoryField.Set field

It is critical that you look at the NxCategoryField.Set value for every Category field, and ensure it's set to 1 to make sure the data for that field is present in the current Category message. Some category messages come in multiple times per day, for the same symbol -- but the data in them contains only the fields that changed and not every field in the entire category.

See the code example at the bottom of this page that shows a good technique for accomplishing this.

Simplest example

Here's the simplest example.

#include <NxCoreAPI.h>
int processNxCoreCategory(const NxCoreSystem* pNxCoreSys, const NxCoreMessage* pNxCoreMsg)
{
    return NxCALLBACKRETURN_CONTINUE;
}
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:     return processNxCoreCategory(pNxCoreSys, pNxCoreMsg);
        case NxMSG_SYMBOLCHANGE: break;
        case NxMSG_SYMBOLSPIN:   break;
    }
    return NxCALLBACKRETURN_CONTINUE;
}

Example

Here's an example category dumper that reflectively pretty-prints out every category

C++ Java Python

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

NxCoreClass NxCore;

void categoryDump(const NxCoreSystem* pNxCoreSys, const NxCoreMessage* pNxCoreMessage)
{
    const NxCoreHeader   &ch  = pNxCoreMessage->coreHeader;
    const NxCoreCategory &cat = pNxCoreMessage->coreData.Category;

    char symbol[128] = {0};

    if (ch.pnxOptionHdr)
    {
        if (ch.pnxOptionHdr->pnxsDateAndStrike)
        {
            // If pnxsDateAndStrike->String[0] == ' ', then this symbol is in new OSI format. 
            if (ch.pnxOptionHdr->pnxsDateAndStrike->String[0]==' ')
            {
                sprintf(symbol,"%s%02d%02d%02d%c%08d",
                    ch.pnxStringSymbol->String,
                    ch.pnxOptionHdr->nxExpirationDate.Year-2000,
                    ch.pnxOptionHdr->nxExpirationDate.Month,
                    pNxCoreMessage->coreHeader.pnxOptionHdr->nxExpirationDate.Day,
                    (ch.pnxOptionHdr->PutCall == 0) ? 'C' : 'P',
                    ch.pnxOptionHdr->strikePrice);
            }
            // Otherwise the symbol is in old OPRA format.
            else
            {
                sprintf(symbol,"%s%c%c",
                    ch.pnxStringSymbol->String,
                    ch.pnxOptionHdr->pnxsDateAndStrike->String[0],
                    ch.pnxOptionHdr->pnxsDateAndStrike->String[1]);
            }
        }
        else
            sprintf(symbol,"%s", ch.pnxStringSymbol->String);
    }

    printf("Category         : %s(%ld)\n",          cat.pnxStringCategory->String, cat.pnxStringCategory->Atom);
    printf("  nxTime         : %02d:%02d:%02d\n",   (int) pNxCoreSys->nxTime.Hour, (int) pNxCoreSys->nxTime.Minute, (int) pNxCoreSys->nxTime.Second);
    printf("  symbol         : %s\n",               symbol);
    printf("  listedExch     : %ld\n",              ch.ListedExg);
    printf("  sessionDate    : %d%02d%02d\n",       (int) ch.nxSessionDate.Year, (int) ch.nxSessionDate.Month, (int) ch.nxSessionDate.Day);
    printf("  time           : %02d:%02d:%02d\n",   (int) ch.nxExgTimestamp.Hour, (int) ch.nxExgTimestamp.Minute, (int) ch.nxExgTimestamp.Second);
    printf("  reportExch     : %ld\n",              ch.ReportingExg);
    printf("  sessionId      : %ld\n",              (int) ch.SessionID);
    printf("  permissionId   : %ld [%s]\n",         ch.PermissionID, NxCore.GetDefinedString(NxST_PERMID, ch.PermissionID));
    printf("  NFields        : %ld\n",              cat.NFields);

    for (int i = 0; i < cat.NFields; i++)
    {
        const NxCategoryField& cf = cat.pnxFields[i];

        printf("     %ld|%s|[%s] {%ld} :", i, cf.FieldName, cf.FieldInfo, (int) cf.Set);

        if (!cf.Set)
        {
            printf("  -- !Set --\n");
            continue;
        }

        switch (cf.FieldType)
        {
            case NxCFT_UNKNOWN:
            {
                printf("  -- unknown --");
                break;
            }
            case NxCFT_64BIT:
            {
                printf("  %I64d", cf.data.i64Bit);
                break;
            }
            case NxCFT_32BIT:
            {
                printf("  %ld", cf.data.i32Bit);
                break;
            }
            case NxCFT_STRINGZ:
            {
                printf("  %s", cf.data.StringZ);
                break;
            }
            case NxCFT_DOUBLE:
            {
                printf("  %lf", cf.data.Double);
                break;
            }
            case NxCFT_PRICE:
            {
                printf("  %.2lf", NxCore.PriceToDouble(cf.data.nxPrice.Price, cf.data.nxPrice.PriceType));
                break;
            }
            case NxCFT_DATE:
            {
                printf("  %d%02d%02d",  (int) cf.data.nxDate.Year, (int) cf.data.nxDate.Month, (int) cf.data.nxDate.Day);
                break;
            }
            case NxCFT_TIME:
            {
                printf("  %02d:%02d:%02d.%03d", (int) cf.data.nxTime.Hour, (int) cf.data.nxTime.Minute, (int) cf.data.nxTime.Second, (int) cf.data.nxTime.Millisecond);
                break;
            }
            case NxCFT_NxSTRING:
            {
                if (cf.data.pnxString)
                {
                    const NxString& s = (const NxString&) *cf.data.pnxString;
                    printf("  '%s'", s.String);
                }
                break;
            }
            case NxCFT_STRING_IDX:
            {
                const StringTableItem& stItem = (const StringTableItem&) cf.data.stringTableItem;
                const char* ss = NxCore.GetDefinedString(stItem.ixTable, stItem.idString);
                if (!ss)
                {
                    ss = "***NULL***";
                }
                printf("  [%ld:%ld] '%s'", stItem.ixTable, stItem.idString, ss);
                break;
            }
            case NxCFT_STRING_MAP:
            {
                const StringTableItem& stItem = (const StringTableItem&) cf.data.stringTableItem;
                bool printed = false;
                unsigned int id = stItem.idString;
                for (int iMap = 0; id; ++iMap, id >>= 1)
                {
                    if (id & 1)
                    {
                        const char* ss = NxCore.GetDefinedString(stItem.ixTable, iMap);
                        if (!ss)
                        {
                            ss = "***NULL***";
                        }
                        if (!printed)
                        {
                            printf("  [%ld:%ld] '%s'", stItem.ixTable, iMap, ss);
                            printed = true;
                        }
                        else
                        {
                            printf(",  [%ld:%ld] '%s'", stItem.ixTable, iMap, ss);
                        }
                    }
                }
                break;
            }
        }

        printf("\n");
    }
}

int __stdcall nxCoreCallback(const NxCoreSystem* pNxCoreSys, const NxCoreMessage* pNxCoreMessage)
{
    switch (pNxCoreMessage->MessageType)
    {
        case NxMSG_CATEGORY:
        {
            categoryDump(pNxCoreSys, pNxCoreMessage);
            break;
        }
    }

    return NxCALLBACKRETURN_CONTINUE;
}

int main(int argc, char** argv)
{
    if (!NxCore.LoadNxCore("NxCoreAPI64.dll") &&
        !NxCore.LoadNxCore("NxCoreAPI.dll"))
    {
        fprintf(stderr, "loading library failed\n");
        return -1;
    }
    NxCore.ProcessTape(argv[1], 0, NxCF_EXCLUDE_CRC_CHECK | NxCF_EXCLUDE_QUOTES | NxCF_EXCLUDE_QUOTES2, 0, nxCoreCallback);
    return 0;
}

import net.nanex.NxCoreClass;
class CategoryDumper extends NxCoreClass{
    void categoryDump(NxCoreSystem nxCoreSys, NxCoreMessage nxCoreMsg) {
        NxCoreHeader ch = nxCoreMsg.coreHeader;
        NxCoreCategory cat = nxCoreMsg.coreData.Category;
        String symbol;

        if (ch.pnxStringSymbol.String.charAt(0) == 'o' && ch.pnxOptionHdr != null) {// If an option....
            symbol = String.format("%s%02d%02d%02d%c%08d",
            ch.pnxStringSymbol.String,
            ch.pnxOptionHdr.nxExpirationDate.Year-2000,
            ch.pnxOptionHdr.nxExpirationDate.Month,
            ch.pnxOptionHdr.nxExpirationDate.Day,
            (ch.pnxOptionHdr.PutCall == 0) ? 'C' : 'P',
            ch.pnxOptionHdr.strikePrice);
        }
        else{// otherwise a non-option
            symbol = ch.pnxStringSymbol.String;
        }

        System.out.println(String.format("Category         : %s(%d)",          cat.pnxStringCategory.String, cat.pnxStringCategory.Atom));
        System.out.println(String.format("  nxTime         : %02d:%02d:%02d",   (int) nxCoreSys.nxTime.Hour, (int) nxCoreSys.nxTime.Minute, (int) nxCoreSys.nxTime.Second));
        System.out.println(String.format("  symbol         : %s",               symbol));
        System.out.println(String.format("  listedExch     : %d",              ch.ListedExg));
        System.out.println(String.format("  sessionDate    : %d%02d%02d",       (int) ch.nxSessionDate.Year, (int) ch.nxSessionDate.Month, (int) ch.nxSessionDate.Day));
        System.out.println(String.format("  time           : %02d:%02d:%02d",   (int) ch.nxExgTimestamp.Hour, (int) ch.nxExgTimestamp.Minute, (int) ch.nxExgTimestamp.Second));
        System.out.println(String.format("  reportExch     : %d",              ch.ReportingExg));
        System.out.println(String.format("  sessionId      : %d",              (int) ch.SessionID));
        System.out.println(String.format("  permissionId   : %d [%s]",         ch.PermissionID, GetDefinedString(defines.NxST_PERMID, ch.PermissionID)));
        System.out.println(String.format("  NFields        : %d",              cat.NFields));

        for (int i = 0; i < cat.NFields; i++)
        {
            NxCategoryField cf = cat.pnxFields[i];

            System.out.print(String.format("     %d|%s|[%s] {%d} :", i, cf.FieldName, cf.FieldInfo, (int) cf.Set));

            if (cf.Set !=0)
            {
                System.out.println("  -- !Set --");
                continue;
            }

            switch (cf.FieldType)
            {
                case defines.NxCFT_UNKNOWN:
                {
                    System.out.print("  -- unknown --");
                    break;
                }
                case defines.NxCFT_64BIT:
                {
                    System.out.print(String.format("  %d", cf.data.i64Bit));
                    break;
                }
                case defines.NxCFT_32BIT:
                {
                    System.out.print(String.format("  %d", cf.data.i32Bit));
                    break;
                }
                case defines.NxCFT_STRINGZ:
                {
                    System.out.print(String.format("  %s", cf.data.StringZ));
                    break;
                }
                case defines.NxCFT_DOUBLE:
                {
                    System.out.print(String.format("  %f", cf.data.Double));
                    break;
                }
                case defines.NxCFT_PRICE:
                {
                    System.out.print(String.format("  %.2f", PriceToDouble(cf.data.nxPrice.Price, cf.data.nxPrice.PriceType)));
                    break;
                }
                case defines.NxCFT_DATE:
                {
                    System.out.print(String.format("  %d%02d%02d",  (int) cf.data.nxDate.Year, (int) cf.data.nxDate.Month, (int) cf.data.nxDate.Day));
                    break;
                }
                case defines.NxCFT_TIME:
                {
                    System.out.print(String.format("  %02d:%02d:%02d.%03d", (int) cf.data.nxTime.Hour, (int) cf.data.nxTime.Minute, (int) cf.data.nxTime.Second, (int) cf.data.nxTime.Millisecond));
                    break;
                }
                case defines.NxCFT_NxSTRING:
                {
                    if (cf.data.pnxString != null)
                    {
                        NxString s = cf.data.pnxString;
                        System.out.print(String.format("  '%s'", s.String));
                    }
                    break;
                }
                case defines.NxCFT_STRING_IDX:
                {
                    StringTableItem stItem = cf.data.stringTableItem;
                    String ss = GetDefinedString(stItem.ixTable, stItem.idString);
                    if (ss == null)
                    {
                        ss = "***NULL***";
                    }
                    System.out.print(String.format("  [%d:%d] '%s'", stItem.ixTable, stItem.idString, ss));
                    break;
                }
                case defines.NxCFT_STRING_MAP:
                {
                    StringTableItem stItem = cf.data.stringTableItem;
                    boolean printed = false;
                    int id = stItem.idString;
                    for (int iMap = 0; id!=0; ++iMap, id >>= 1)
                    {
                        if ((id & 1) != 0)
                        {
                            String ss = GetDefinedString(stItem.ixTable, iMap);
                            if (ss == null)
                            {
                                ss = "***NULL***";
                            }
                            if (!printed)
                            {
                                System.out.print(String.format("  [%d:%d] '%s'", stItem.ixTable, iMap, ss));
                                printed = true;
                            }
                            else
                            {
                                System.out.print(String.format(",  [%d:%d] '%s'", stItem.ixTable, iMap, ss));
                            }
                        }
                    }
                    break;
                }
            }

            System.out.println("");
        }
    }
    @Override
    public int OnNxCoreCallback(NxCoreSystem nxCoreSys, NxCoreMessage nxCoreMsg) {
        switch (nxCoreMsg.MessageType)
        {
            case defines.NxMSG_EXGQUOTE:

                categoryDump(nxCoreSys,nxCoreMsg);
                break;
        }
        return defines.NxCALLBACKRETURN_CONTINUE;
    }

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

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

import NxCore

tapePath = ""
def categoryDump(nxCoreSys, nxCoreMsg):
    ch = nxCoreMsg.coreHeader
    cat = nxCoreMsg.coreData.Category

    if ch.pnxStringSymbol.String[0] == 'o' and ch.pnxOptionHdr: # If an option....
        symbol = "{}{:02d}{:02d}{:02d}{}{:08d}".format(
        ch.pnxStringSymbol.String,
        ch.pnxOptionHdr.nxExpirationDate.Year-2000,
        ch.pnxOptionHdr.nxExpirationDate.Month,
        ch.pnxOptionHdr.nxExpirationDate.Day,
        'C' if ch.pnxOptionHdr.PutCall == 0 else 'P',
        ch.pnxOptionHdr.strikePrice)
    else:# otherwise a non-option
        symbol = ch.pnxStringSymbol.String

    print("Category         : {}({})".format(cat.pnxStringCategory.String, cat.pnxStringCategory.Atom))
    print("  nxTime         : {:02d}:{:02d}:{:02d}".format( nxCoreSys.nxTime.Hour, nxCoreSys.nxTime.Minute, nxCoreSys.nxTime.Second))
    print("  symbol         : {}".format(symbol))
    print("  listedExch     : {}".format(ch.ListedExg))
    print("  sessionDate    : {}{:02d}{:02d}".format(ch.nxSessionDate.Year, ch.nxSessionDate.Month, ch.nxSessionDate.Day))
    print("  time           : {:02d}:{:02d}:{:02d}".format(ch.nxExgTimestamp.Hour, ch.nxExgTimestamp.Minute, ch.nxExgTimestamp.Second))
    print("  reportExch     : {}".format(ch.ReportingExg))
    print("  sessionId      : {}".format(ch.SessionID))
    print("  permissionId   : {} [{}]".format(ch.PermissionID, str(NxCore.GetDefinedString(NxCore.NxST_PERMID, ch.PermissionID))))
    print("  NFields        : {}".format(cat.NFields))

    for i in range(cat.NFields):
        cf = cat.pnxFields[i]

        print("     {}|{}|[{}] {{}} :".format(i, cf.FieldName, cf.FieldInfo, cf.Set), end='')

        if not cf.Set:
            print("  -- !Set --")
            continue

        if cf.FieldType == NxCore.NxCFT_UNKNOWN:
            print("  -- unknown --", end='')
        elif cf.FieldType == NxCore.NxCFT_64BIT:
            print("  {}".format(cf.data.i64Bit), end='')
        elif cf.FieldType == NxCore.NxCFT_32BIT:
            print("  {}".format(cf.data.i32Bit), end='')
        elif cf.FieldType == NxCore.NxCFT_STRINGZ:
            print("  {}".format(cf.data.StringZ), end='')
        elif cf.FieldType == NxCore.NxCFT_DOUBLE:
            print("  {:f}".format(cf.data.Double), end='')
        elif cf.FieldType == NxCore.NxCFT_PRICE:
            print("  {:.2f}".format(NxCore.PriceToFloat(cf.data.nxPrice.Price, cf.data.nxPrice.PriceType)), end='')
        elif cf.FieldType == NxCore.NxCFT_DATE:
            print("  {}{:02d}{:02d}".format(cf.data.nxDate.Year, cf.data.nxDate.Month, cf.data.nxDate.Day), end='')
        elif cf.FieldType == NxCore.NxCFT_TIME:
            print("  {:02d}:{:02d}:{:02d}.{:03d}".format( cf.data.nxTime.Hour, cf.data.nxTime.Minute, cf.data.nxTime.Second, cf.data.nxTime.Millisecond), end='')
        elif cf.FieldType == NxCore.NxCFT_NxSTRING:
            if cf.data.pnxString:
                s = cf.data.pnxString
                print("  '{}'".format(s.String), end='')
        elif cf.FieldType == NxCore.NxCFT_STRING_IDX:
            stItem = cf.data.stringTableItem
            ss = NxCore.GetDefinedString(stItem.ixTable, stItem.idString)
            if not ss:
                ss = "***NULL***"
            print("  [{}:{}] '{}'".format(stItem.ixTable, stItem.idString, ss), end='')
        elif cf.FieldType == NxCore.NxCFT_STRING_MAP:
            stItem = cf.data.stringTableItem
            printed = False
            id = stItem.idString
            iMap = 0
            while id != 0:

                if (id & 1) != 0:
                    ss = NxCore.GetDefinedString(stItem.ixTable, iMap)
                    if not ss :
                        ss = "***NULL***"
                    if not printed:
                        print("  [{}:{}] '{}'".format(stItem.ixTable, iMap, ss), end='')
                        printed = true
                    else:
                        print(",  [{}:{}] '{}'".format(stItem.ixTable, iMap, ss), end='')
                iMap+= 1
                id = id >> 1

        print("")

def OnNxCoreCallback(NxCoreSys, NxCoreMsg):
    if NxCoreMsg.MessageType == NxCore.NxMSG_EXGQUOTE:
        categoryDump(NxCoreSys, NxCoreMsg)
    return NxCore.NxCALLBACKRETURN_CONTINUE

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

API Documentation