Add Freescale Nexus decoder implementation

[babeltrace.git] / converter / nexus / NxMessage.h

/*
 * Copyright (C) 2013 Freescale Semiconductor, Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 */

#ifndef NXMESSAGE_H
#define NXMESSAGE_H

#include "NxPacketSet.h"
#include "NxMessageVisitor.h"
#include "SizedAddress.h"
#include <inttypes.h>
#include <string>

using std::string;

/*!
 Base class for all types of Nexus Message structures. Type is based on a TCODE value.
 */
class NxMessage
{
public:
        /*!
         @abstract Constructor
         @param tcode Set the TCODE value. Default 0x3f which is an unused (unlikely) code value.
         */
        NxMessage(uint32_t tcode) :
                tcode_(tcode), source_id_(0), timestamp_(0)
        {
        }
        virtual ~NxMessage()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v) = 0;

        /*!
         @abstract Returns the TCODE value
         @return the tcode for this message
         */
        uint32_t tcode() const
        {
                return tcode_;
        }

        /*!
         @abstract Returns the TCODE string
         @return the tcode as a string
         */
        virtual string tcodeString() const;

        /*!
         @abstract Returns the SRC_ID value
         @return the source_id for this message
         */
        uint32_t sourceId() const
        {
                return source_id_;
        }

        /*!
         @abstract Annotates the SRC_ID as string
         @return the SRC_ID as a string
         */
        const char * sourceIdString() const;

        /*!
         @abstract Returns the TIMESTAMP value
         @return the timestamp for this message
         */
        uint32_t timestamp() const
        {
                return timestamp_;
        }

        /*!
         @abstract Determines if the TIMESTAMP value needs correction
         @return True if the timestamp needs correction
         */
        bool timestampNeedsCorrection() const;

        /*!
         @abstract Returns the corrected TIMESTAMP value
         @return the corrected timestamp for this message
         */
        uint32_t correctedTimestamp() const;

        /*!
         @abstract Output timestamp information as a string
         @return a string representing the timestamp
         */
        string timestampAsString() const;

        /*!
         @abstract Decode Nexus message info from the packet set
         @param pkt_set Reference to a NxPackageSet containing the data to be decoded
         @return True if no error
         */
        virtual bool decode(NxPacketSet &pkt_set) = 0;

        /*!
         @abstract Output message information as a string
         @return a string representing the Nexus message content
         */
        virtual string asString() const;

protected:

        /*!
         @abstract Decode the SRC ID from the packet set
         @param pkt_set Reference to a NxPackageSet containing the data to be decoded
         @return the SRC ID value
         */
        uint32_t decodeSourceId(NxPacketSet &pkt_set);

        /*!
         @abstract Decode the TIMESTAMP value from the packet set at index
         @param pkt_set Reference to a NxPackageSet containing the data to be decoded
         @param index The index of the NxPacket in the NxPacketSet collection
         @return the TIMESTAMP value
         */
        uint32_t decodeTimestamp(NxPacketSet &pkt_set, uint32_t index);

        /*! @var tcode_ contains the TCODE value which determines the type of NxMessage */
        uint32_t tcode_;

        /*! @var source_id_ contains the SRC ID value */
        uint32_t source_id_;

        /*! @var timestamp_ contains the optional TIMESTAMP value */
        uint32_t timestamp_;
};

// This type is the default for all unknown message types
class NxDefaultMessage: public NxMessage
{
public:
        NxDefaultMessage(uint32_t tcode) :
                NxMessage(tcode)
        {
        }
        ~NxDefaultMessage()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set)
        {
                return true;
        }
};

class NxDebugStatusMessage: public NxMessage
{
public:
        NxDebugStatusMessage() :
                NxMessage(0), status_(0)
        {
        }
        ~NxDebugStatusMessage()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        /*!
         @abstract Returns the TCODE string
         @return the tcode as a string
         */
        virtual string tcodeString() const
        {
                return "Debug Status Message";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

private:

        // STATUS
        uint32_t status_;
};

class NxDeviceIDMessage: public NxMessage
{
public:
        NxDeviceIDMessage() :
                NxMessage(1)
        {
        }
        ~NxDeviceIDMessage()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        /*!
         @abstract Returns the TCODE string
         @return the tcode as a string
         */
        virtual string tcodeString() const
        {
                return "Device ID Message";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

private:

};

class NxOwnershipTraceMessage: public NxMessage
{
public:
        NxOwnershipTraceMessage() :
                NxMessage(2), pid_index_(0), pid_value_(0)
        {
        }
        ~NxOwnershipTraceMessage()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        /*!
         @abstract Returns the TCODE string
         @return the tcode as a string
         */
        virtual string tcodeString() const
        {
                return "Ownership Trace Message";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

        // decode the data as a string
        const char * pidIndexString() const;

        // decode the data as a string
        const char * pidValueString() const;

private:

        // PROCESS subfields
        uint32_t pid_index_;
        uint64_t pid_value_;

};

class NxDataAcquisitionMessage: public NxMessage
{
public:
        NxDataAcquisitionMessage() :
                NxMessage(7), idtag_(0), dqdata_(0)
        {
        }
        ~NxDataAcquisitionMessage()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        /*!
         @abstract Returns the TCODE string
         @return the tcode as a string
         */
        virtual string tcodeString() const
        {
                return "Data Acquisition Message";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

        // decode the data as a string
        const char * idtagString() const;

        // decode the data as a string
        string dqdataString() const;

private:

        // IDTAG
        uint32_t idtag_;

        // DQDATA
        uint32_t dqdata_;
};

class NxErrorMessage: public NxMessage
{
public:
        NxErrorMessage() :
                NxMessage(8), etype_(0), ecode_(0)
        {
        }
        ~NxErrorMessage()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        /*!
         @abstract Returns the TCODE string
         @return the tcode as a string
         */
        virtual string tcodeString() const
        {
                return "Error Message";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

        // decode the data as a string
        const char * etypeString() const;

        // decode the data as a string
        string ecodeString() const;

private:

        // IDTAG
        uint32_t etype_;

        // DQDATA
        uint32_t ecode_;
};

// NxProgramTraceSync
class NxProgramTraceSync: public NxMessage
{
public:
        NxProgramTraceSync() :
                NxMessage(9), map_(0), icnt_(0), hist_(0)
        {
        }
        ~NxProgramTraceSync()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        /*!
         @abstract Returns the TCODE string
         @return the tcode as a string
         */
        virtual string tcodeString() const
        {
                return "Program Trace Synchronization";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

        // get the address value
        const SizedAddress& address() const
        {
                return pc_;
        }

private:

        // MAP
        uint32_t map_;

        // I-CNT
        uint32_t icnt_;

        // PC
        SizedAddress pc_;

        // HIST
        uint32_t hist_;
};

// NxDataTrace Base class
class NxDataTraceBase: public NxMessage
{
public:
        NxDataTraceBase(uint32_t tcode) :
                NxMessage(tcode),
                dsz_(0),
                addr_(0),
                data_(0)
        {
        }
        virtual ~NxDataTraceBase()
        {
        }

protected:

        // decode the data as a string
        const char * dszString() const;

        // DSZ
        uint32_t dsz_;

        // ADDR
        uint64_t addr_;

        // Data
        uint64_t data_;

};

// NxDataTraceWrite
class NxDataTraceWrite: public NxDataTraceBase
{
public:
        NxDataTraceWrite() :
                NxDataTraceBase(5)
        {
        }
        ~NxDataTraceWrite()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        /*!
         @abstract Returns the TCODE string
         @return the tcode as a string
         */
        virtual string tcodeString() const
        {
                return "Data Trace - Data Write";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

private:

};

// NxDataTraceRead
class NxDataTraceRead: public NxDataTraceBase
{
public:
        NxDataTraceRead() :
                NxDataTraceBase(6)
        {
        }
        ~NxDataTraceRead()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        /*!
         @abstract Returns the TCODE string
         @return the tcode as a string
         */
        virtual string tcodeString() const
        {
                return "Data Trace - Data Read";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

private:

};

// NxDataTraceWriteSync
class NxDataTraceWriteSync: public NxDataTraceBase
{
public:
        NxDataTraceWriteSync() :
                NxDataTraceBase(13)
        {
        }
        ~NxDataTraceWriteSync()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        /*!
         @abstract Returns the TCODE string
         @return the tcode as a string
         */
        virtual string tcodeString() const
        {
                return "Data Trace - Data Write w/sync";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

private:

};

// NxDataTraceReadSync
class NxDataTraceReadSync: public NxDataTraceBase
{
public:
        NxDataTraceReadSync() :
                NxDataTraceBase(14)
        {
        }
        ~NxDataTraceReadSync()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        /*!
         @abstract Returns the TCODE string
         @return the tcode as a string
         */
        virtual string tcodeString() const
        {
                return "Data Trace - Data Read w/sync";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

private:

};

// NxWatchpointMessage
class NxWatchpointMessage: public NxMessage
{
public:
        NxWatchpointMessage() :
                NxMessage(15), wphit_(0), wphit_size_(16)
        {
        }
        ~NxWatchpointMessage()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        /*!
         @abstract Returns the TCODE string
         @return the tcode as a string
         */
        virtual string tcodeString() const
        {
                return "Watchpoint Message";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

        // decode the data as a string
        string wphitString() const;

private:

        // Watchpoint Hit
        uint32_t wphit_;

        // Watchpoint Hit bit size
        uint32_t wphit_size_;
};

class NxResourceFullMessage: public NxMessage
{
public:
        NxResourceFullMessage() :
                NxMessage(27), rcode_(0), rdata_(0)
        {
        }
        ~NxResourceFullMessage()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        /*!
         @abstract Returns the TCODE string
         @return the tcode as a string
         */
        virtual string tcodeString() const
        {
                return "Resource Full Message";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

        // decode the data as a string
        const char * rcodeString() const;

private:

        // RCODE
        uint32_t rcode_;

        // RDATA
        uint32_t rdata_;

};

class NxProgramTraceIndirectBranch: public NxMessage
{
public:
        NxProgramTraceIndirectBranch() :
                NxMessage(28), btype_(0), icnt_(0), hist_(0)
        {
        }
        ~NxProgramTraceIndirectBranch()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        /*!
         @abstract Returns the TCODE string
         @return the tcode as a string
         */
        virtual string tcodeString() const
        {
                return "Program Trace - Indirect Branch History";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

        // decode the data as a string
        const char * btypeString() const;

        // get the address value
        const SizedAddress& address() const
        {
                return uaddr_;
        }

private:

        // BTYPE
        uint32_t btype_;

        // I-CNT
        uint32_t icnt_;

        // U-ADDR
        SizedAddress uaddr_;

        // HIST
        uint32_t hist_;
};

class NxProgramTraceIndirectBranchSync: public NxMessage
{
public:
        NxProgramTraceIndirectBranchSync() :
                NxMessage(29), btype_(0), icnt_(0), hist_(0)
        {
        }
        ~NxProgramTraceIndirectBranchSync()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        /*!
         @abstract Returns the TCODE string
         @return the tcode as a string
         */
        virtual string tcodeString() const
        {
                return "Program Trace - Indirect Branch History w/sync";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

        // decode the data as a string
        const char * btypeString() const;

        // get the address value
        const SizedAddress& address() const
        {
                return faddr_;
        }

private:

        // BTYPE
        uint32_t btype_;

        // I-CNT
        uint32_t icnt_;

        // F-ADDR
        SizedAddress faddr_;

        // HIST
        uint32_t hist_;
};

class NxProgramTraceCorrelation: public NxMessage
{
public:
        NxProgramTraceCorrelation() :
                NxMessage(33), evcode_(0), icnt_(0), cdata_(0)
        {
        }
        ~NxProgramTraceCorrelation()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        /*!
         @abstract Returns the TCODE string
         @return the tcode as a string
         */
        virtual string tcodeString() const
        {
                return "Program Trace - Program Correlation";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

        // decode the data as a string
        const char * evcodeString() const;

private:

        // EVCODE
        uint32_t evcode_;

        // I-CNT
        uint32_t icnt_;

        // CDATA
        uint32_t cdata_;
};

// Abstract base class for all ICT types
class NxInCircuitTraceBase: public NxMessage
{
public:
        NxInCircuitTraceBase(uint32_t tcode) :
                NxMessage(tcode)
        {
        }
        virtual ~NxInCircuitTraceBase()
        {
        }

        /*!
         @abstract Returns the TCODE string
         @return the tcode as a string
         */
        virtual string tcodeString() const;

        // return true if this ICT Message has a "Sync" tcode
        virtual bool isSyncMessage() const
        {
                return (tcode_ == 35);
        }
};

class NxDAMInCircuitTraceMessage: public NxInCircuitTraceBase
{
public:
        NxDAMInCircuitTraceMessage(uint32_t tcode) :
                NxInCircuitTraceBase(tcode),
                ddrmid_(0),
                ddrsid_(0),
                ddrtt_(0),
                ddrsz_(0),
                ddraddr_(0),
                dddiec_(0)
        {
        }
        ~NxDAMInCircuitTraceMessage()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        /*!
         @abstract Returns the ICT Message Type detail
         @return the ICT Message type
         */
        virtual const char * ICTMessageType() const
        {
                return "DDR Terse/Verbose Message (DAM)";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

        // decode the type data as a string
        const char * ddrttString() const;

        // decode the size data as a string
        string ddrszString() const;

private:
        uint32_t ddrmid_;
        uint32_t ddrsid_;
        uint32_t ddrtt_;
        uint32_t ddrsz_;
        uint64_t ddraddr_;
        uint32_t dddiec_;
};

// DataPath Queuing Message (DPQM) In Circuit Trace
class NxDPQMInCircuitTraceMessage: public NxInCircuitTraceBase
{
public:
        NxDPQMInCircuitTraceMessage(uint32_t tcode) :
                NxInCircuitTraceBase(tcode),
                verb_(0),
                dpdm_(0),
                fqid_(0),
                cnum_(0),
                pnum_(0),
                ptype_(0),
                qet_(0),
                orf_(0),
                erf_(0),
                err_(0),
                fmbpid_(0),
                fmsc_(0),
                fmol_(0),
                fmfmt_(0),
                fmpid_(0),
                fmaddr_(0)
        {
        }
        ~NxDPQMInCircuitTraceMessage()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        // returns the ICT Message type
        virtual const char * ICTMessageType() const
        {
                return "DataPath Queuing Message (DPQM)";
        }

        // decode the queue event type as a string
        const char * queueEventTypeString() const;

        // decode the enqueue rejection response code as a string
        const char * enqueueRejectionString() const;

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

private:
        uint32_t verb_;
        uint32_t dpdm_;
        uint32_t fqid_;
        uint32_t cnum_;
        uint32_t pnum_;
        uint32_t ptype_;
        uint32_t qet_;
        uint32_t orf_;
        uint32_t erf_;
        uint32_t err_;

        // additional verbose fields
        uint32_t fmbpid_;
        uint32_t fmsc_;
        uint32_t fmol_;
        uint32_t fmfmt_;
        uint32_t fmpid_;
        uint64_t fmaddr_;
};

// DataPath Frame Message (DPFM) In Circuit Trace
class NxDPFMInCircuitTraceMessage: public NxInCircuitTraceBase
{
public:
        NxDPFMInCircuitTraceMessage(uint32_t tcode) :
                NxInCircuitTraceBase(tcode),
                fmsel_(0),
                lbeat_(0),
                btcnt_(0)
        {
                for (int i = 0; i < 4; i++ )
                        context_[i] = 0;

        }
        ~NxDPFMInCircuitTraceMessage()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        // returns the ICT Message type
        virtual const char * ICTMessageType() const
        {
                return "DataPath Frame Message (DPFM)";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

        // acessors
        uint32_t getFmsel() const
        {
                return fmsel_;
        }
        uint32_t getLbeat() const
        {
                return lbeat_;
        }
        uint32_t getBtcnt() const
        {
                return btcnt_;
        }
        const uint32_t * getContext() const
        {
                return context_;
        }

private:
        uint32_t fmsel_;
        uint32_t lbeat_;
        uint32_t btcnt_;
        uint32_t context_[4]; // 128 bits of context

};

// Core Performance Profile Message
class NxCoreInCircuitTraceMessage: public NxInCircuitTraceBase
{
public:
        NxCoreInCircuitTraceMessage(uint32_t tcode) :
                NxInCircuitTraceBase(tcode),
                cksrc_(0),
                sync_(0),
                ckdf_(0),
                ckdata1_(0),
                ckdata2_(0)
        {
        }
        ~NxCoreInCircuitTraceMessage()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        // returns the ICT Message type
        virtual const char * ICTMessageType() const
        {
                return "Core Performance Profile Message (ICT)";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

        // decode the sync code as a string
        const char * syncString() const;

        // decode the cksrc code as a string
        const char * cksrcString() const;

private:
        uint32_t cksrc_;
        uint32_t sync_;
        uint32_t ckdf_;
        uint32_t ckdata1_;
        uint32_t ckdata2_;
};

// Prototype for a ICT message type. Also a default for an
// un-decoded type.
class NxInCircuitTraceMessage: public NxInCircuitTraceBase
{
public:
        NxInCircuitTraceMessage(uint32_t tcode) :
                NxInCircuitTraceBase(tcode)
        {
        }
        ~NxInCircuitTraceMessage()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        /*!
         @abstract Returns the ICT Message Type detail
         @return the ICT Message type
         */
        virtual const char * ICTMessageType() const
        {
                return "Generic In-Circuit Trace Message";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

private:

};

class NxTimeStampCorrelation: public NxMessage
{
public:
        NxTimeStampCorrelation() :
                NxMessage(56), tcorr_(0), ttype_(0)
        {
        }
        ~NxTimeStampCorrelation()
        {
        }

        // NxMessage implements the standard visitor pattern.
        virtual void accept(NxMessageVisitor &v)
        {
                v.visit(this);
        }

        /*!
         @abstract Returns the TCODE string
         @return the tcode as a string
         */
        virtual string tcodeString() const
        {
                return "Time Stamp Correlation";
        }

        // decode message info from the packet set
        virtual bool decode(NxPacketSet &pkt_set);

        // output message information as a string
        virtual string asString() const;

        // decode the data as a string
        const char * ttypeString() const;

private:
        uint32_t tcorr_;
        uint32_t ttype_;
};

#endif // NXMESSAGE_H