D:/_work/fix/doc/manual/headers/B2BITS_FIXMessage.h

Go to the documentation of this file.

// <copyright>
// $Revision: 1.3 $
// 
// (c) B2BITS 2006. B2BITS is an abbreviation of
// Business to Business Information Technology Services corporation.
// "Licensor" shall mean B2BITS.
// 
// This software is for the use of the paying client of B2BITS (which may be
// a corporation, business area, business unit or single use subject to
// licence terms) to whom it was delivered (the "Licensee")and no other party,
// and any use beyond this business area is contrary to the terms of the licence grant.
// 
// The Licensee acknowledges and agrees that the Software and Documentation
// (the "Confidential Information") is confidential and proprietary to
// the Licensor and the Licensee hereby agrees to use the Confidential
// Information only as permitted by the full licence agreement betweeen
// the two parties, to maintain the confidentiality of the Confidential
// Information and not to disclose the confidential information, or any part
// thereof, to any other person, firm or corporation. The Licensee
// acknowledges that disclosure of the Confidential Information may give rise
// to an irreparable injury to the Licensor in-adequately compensable in
// damages. Accordingly the Licensor may seek (without the posting of any
// bond or other security) injunctive relief against the breach of the forgoing
// undertaking of confidentiality and non-disclosure, in addition to any other
// legal remedies which may be available, and the licensee consents to the
// obtaining of such injunctive relief. All of the undertakings and
// obligations relating to confidentiality and non-disclosure, whether
// contained in this section or elsewhere in this agreement, shall survive
// the termination or expiration of this agreement for a period of five (5)
// years.
// 
// The Licensor agrees that any information or data received from the Licensee
// in connection with the performance of the support agreement relating to this
// software shall be confidential, will be used only in connection with the
// performance of the Licensor's obligations hereunder, and will not be
// disclosed to third parties, including contractors, without the Licensor's
// express permission in writing.
// 
// Information regarding the software may be provided to the Licensee's outside
// auditors and attorneys only to the extent required by their respective
// functions.
// </copyright>


#ifndef __B2BITS_Engine_V12_FIXMessage_h__
#define __B2BITS_Engine_V12_FIXMessage_h__

#include <string>
#include <vector>
#include <set>

#include "B2BITS_V12_Defines.h"
#include "B2BITS_PubEngineDefines.h"
#include "B2BITS_TagValue.h"
#include "B2BITS_AutoPtr.h"

namespace Engine
{
  class FIXMessageEx;

  struct FIXFieldValue;

  class SecurityAttributes;

  class FIXGroup;

  class V12_API FIXMessage: public virtual TagValue
  {
  public:
    FIXMessage();

    virtual ~FIXMessage();

    virtual const std::string* getSender() const = 0;

    virtual void setSender(const std::string& senderCompID) = 0;

    virtual const std::string* getTarget() const = 0;

    virtual void setTarget(const std::string& targetCompID) = 0;

    virtual const int getSeqNum() const = 0;

    virtual const std::string* getType() const = 0;
    virtual AsciiString type() const { return *getType(); }

    virtual bool setSeqNum(int msgSeqNum) = 0;

    virtual int getHeartBeatInterval() const = 0;

    virtual bool setHeartBeatInterval(int hbi) = 0;

    virtual bool isOriginal() const = 0;

    virtual bool isBusinessMsgRejectMsg() const = 0;

    virtual bool isSessionLevelRejectMsg() const = 0;

    virtual bool isAdministrativeMsg() const = 0;

    virtual const std::string *toString(char substChar = ' ') const = 0;

    virtual const char* toRaw(int* size) const = 0;

    virtual const char* getBuffer(int* size, 
        SecurityAttributes* sa = NULL) const = 0;

    virtual FIXVersion getVer() const = 0; 

    virtual FIXVersion getApplicationVersion() const = 0; 

    virtual FIXVersion getSessionVersion() const = 0; 

    virtual void release()const = 0;

    static void release(FIXMessage const* msg);

    void *operator new(size_t size);

    void operator delete(void *obj);


    virtual FIXMessageEx* extend() = 0;

    virtual FIXMessageEx const* extend() const = 0;
  };

  void V12_API removeCustomFields(FIXMessage *msg);
}

namespace Utils{

    template <>
    class AutoPtr<Engine::FIXMessage>
    {
    public:
        typedef void (Engine::FIXMessage::*ReleaseMethod)()const;

        AutoPtr() : releaseMethod_(NULL), ptr_(NULL) { }

        AutoPtr(const Engine::FIXMessage *ptr, ReleaseMethod releaseMethod) : releaseMethod_(releaseMethod), ptr_(ptr)
        {
        }

        AutoPtr(AutoPtr<Engine::FIXMessage> & ptr)
        {
            reset(ptr.ptr_, ptr.releaseMethod_);

            ptr.ptr_ = NULL;
            ptr.releaseMethod_ = NULL;
        }

        AutoPtr & operator=(AutoPtr<Engine::FIXMessage> & ptr)
        {
            reset(ptr.ptr_, ptr.releaseMethod_);

            ptr.ptr_ = NULL;
            ptr.releaseMethod_ = NULL;

            return *this;
        }

        ~AutoPtr()
        {
            if (ptr_ != NULL)
                (ptr_->*releaseMethod_)();
        }

        Engine::FIXMessage *release()
        { 
            releaseMethod_ = NULL;

            Engine::FIXMessage *ptr = const_cast<Engine::FIXMessage *>(ptr_);
            ptr_ = NULL;

            return ptr; 
        }

        void reset(const Engine::FIXMessage *ptr, ReleaseMethod releaseMethod)
        {
            if (ptr_ != NULL)
                (ptr_->*releaseMethod_)();

            ptr_ = ptr;
            releaseMethod_ = releaseMethod;
        }

        Engine::FIXMessage *get() const
        {
            return const_cast<Engine::FIXMessage *>(ptr_);
        }

        Engine::FIXMessage & operator*()
        {
            return *const_cast<Engine::FIXMessage *>(ptr_);
        }

        Engine::FIXMessage** operator&()
        {
            return const_cast<Engine::FIXMessage **>(&ptr_);
        }

        Engine::FIXMessage *operator->()
        {
            return get();
        }

    private:
        ReleaseMethod releaseMethod_;

        const Engine::FIXMessage *ptr_;
    };

}

#endif

---