jaus++/2.0/include/jaus/core/time/reporttime.h

Go to the documentation of this file.

#ifndef __JAUS_CORE_TIME_REPORT_TIME__H
#define __JAUS_CORE_TIME_REPORT_TIME__H

#include "jaus/core/corecodes.h"
#include "jaus/core/message.h"

namespace JAUS
{
    class ReportTime : public Message
    {
    public:
        class JAUS_CORE_DLL PresenceVector : public JAUS::PresenceVector
        {
        public:
            const static Byte Time = 0x01; 
            const static Byte Date = 0x02; 
        };
        ReportTime(const Address& dest = Address(), 
                   const Address& src = Address()) : Message(REPORT_TIME, dest, src)
        {
            mPresenceVector = 0;
        }
        ReportTime(const ReportTime& message) : Message(REPORT_TIME)
        {
            *this = message;
        }
        ~ReportTime() 
        {
        }
        void SetTimeStamp(const Time& time)
        {
            mTime = time;
            mPresenceVector |= PresenceVector::Time;
        }
        void SetDateStamp(const Date& date)
        {
            mDate = date;
            mPresenceVector |= PresenceVector::Date;
        }
        inline Time GetTimeStamp() const { return mTime; }
        inline Date GetDateStamp() const { return mDate; }
        // Return true if a command message, otherwise false.
        virtual bool IsCommand() const { return false; }
        // Writes message payload data to the packet at the current write position.
        virtual int WriteMessageBody(Packet& packet) const
        {
            int expected = BYTE_SIZE;
            int written = 0;

            written += packet.Write(mPresenceVector);
            if( (mPresenceVector & PresenceVector::Time) > 0)
            {
                expected += UINT_SIZE;
                written += packet.Write(mTime.ToUInt());
            }
            if( (mPresenceVector & PresenceVector::Date) > 0)
            {
                expected += USHORT_SIZE;
                written += packet.Write(mDate.ToUShort());
            }
            return expected == written ? expected : -1;
        }
        // Reads message payload data from the packets current read position.
        virtual int ReadMessageBody(const Packet& packet)
         {
            int expected = BYTE_SIZE;
            int read = 0;

            read += packet.Read(mPresenceVector);
            if( (mPresenceVector & PresenceVector::Time) > 0)
            {
                expected += UINT_SIZE;
                UInt tstamp = 0;
                read += packet.Read(tstamp);
                mTime.SetTime(tstamp);
            }
            if( (mPresenceVector & PresenceVector::Date) > 0)
            {
                expected += USHORT_SIZE;
                UShort dstamp = 0;
                read += packet.Read(dstamp);
                mDate.FromUShort(dstamp);
            }
            return expected == read ? expected : -1;
        }
        // Make a copy of the message and returns pointer to it.
        virtual Message* Clone() const { return new ReportTime(*this); }
        // Gets the presence vector data for the message.
        virtual UInt GetPresenceVector() const { return mPresenceVector; }
        // Get the size of the message presence vector. 0 value indicates no presence vector.
        virtual UInt GetPresenceVectorSize() const { return BYTE_SIZE; }
        // Get the mask associated with presence vector.  Indicates what bits are used.
        virtual UInt GetPresenceVectorMask() const { return 0x03; }
        // Gets the response type to the associated message, 0 if message is a response type.
        virtual UShort GetMessageCodeOfResponse() const { return 0; }
        // Gets the name of the message in human readable format (for logging, etc.)
        virtual std::string GetMessageName() const { return "Report Time"; }
        // Clears only message body information.
        virtual void ClearMessageBody() { mPresenceVector = 0;}
        // Return true if payload is greater than maxPaylodSize (payload == message data only).
        virtual bool IsLargeDataSet(const unsigned int maxPayloadSize) const { return false; }
        ReportTime& operator=(const ReportTime& message)
        {
            CopyHeaderData(&message);
            mPresenceVector = message.mPresenceVector;
            mTime = message.mTime;
            mDate = message.mDate;
            return *this;
        }
    protected:
        Byte mPresenceVector;   
        Time mTime;             
        Date mDate;             
    };
}

#endif
/*  End of File */