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

Go to the documentation of this file.

// <copyright>
// $Revision: 1.2 $
// 
// (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_FIXGroup_h__
#define __B2BITS_FIXGroup_h__

#include <string>
#include "B2BITS_V12_Defines.h"
#include "B2BITS_PubEngineDefines.h"
#include <B2BITS_IntDefines.h>
#include <B2BITS_Types.h>
#include <B2BITS_AutoPtr.h>

namespace Engine
{
  struct FIXFieldValue;
  class TagValue;

  class V12_API FIXGroup
  {
  public:
    FIXGroup();

    virtual ~FIXGroup();

    virtual int size() const = 0;

    virtual int leadingField() const = 0;

    virtual const std::string* get(int tag, int index) const = 0;

    virtual bool get(int tag, FIXFieldValue* value, int index) const = 0;

    virtual bool set(int tag, const FIXFieldValue& value, int index) = 0;

    virtual bool set(int tag, const std::string& value, int index) = 0;

    virtual bool remove(int tag, int index) = 0;

    virtual bool isSupported(int tag) const;

    virtual FIXGroup* getGroup(int tag, int index) = 0;
    virtual FIXGroup const* getGroup(int tag, int index) const = 0;

    static void release(FIXGroup* pGroup);

    virtual FixFieldsContainer *getFields() const = 0;

    virtual void release()const = 0;

    void *operator new(size_t size);

    void operator delete(void *obj);


    virtual void write(int tag, std::ostream& out, int index ) const = 0;
    virtual bool hasFlag(int tag, int index ) const = 0;

    virtual System::i64 getAsInt64( int tag, int index ) const = 0;
    virtual System::u64 getAsUInt64( int tag, int index ) const = 0;
    virtual System::i32 getAsInt32( int tag, int index ) const = 0;
    virtual System::u32 getAsUInt32( int tag, int index ) const = 0;
    virtual int getAsInt( int tag, int index ) const = 0;
    virtual unsigned int getAsUInt( int tag, int index ) const = 0;

    virtual double getAsDouble( int tag, int index ) const = 0;
    virtual Decimal getAsDecimal( int tag, int index ) const = 0;

    virtual char getAsChar( int tag, int index ) const = 0;

    virtual AsciiString getAsString( int tag, int index ) const  = 0;

    virtual ByteArray getAsRaw( int tag, int index ) const  = 0;

    virtual bool getAsBoolean( int tag, int index ) const  = 0;

    virtual Engine::MonthYear getAsMonthYear( int tag, int index ) const  = 0;
    virtual Engine::LocalMktDate getAsLocalMktDate( int tag, int index ) const = 0;
    virtual Engine::UTCDateOnly getAsDateOnly( int tag, int index ) const = 0;
    virtual Engine::UTCTimeOnly getAsTimeOnly( int tag, int index ) const = 0;
    virtual Engine::UTCTimestamp getAsTimestamp( int tag, int index ) const = 0;
    virtual bool isEqual( int tag, int index, TagValue const* rv, int rvTag ) const = 0;
    virtual bool isEmpty( int tag, int index ) const = 0;


    virtual bool set( int tag, Engine::MonthYear value, int index ) = 0;
    virtual bool set( int tag, Engine::LocalMktDate value, int index ) = 0;
    virtual bool set( int tag, Engine::UTCDateOnly value, int index ) = 0;
    virtual bool set( int tag, Engine::UTCTimeOnly value, int index ) = 0;
    virtual bool set( int tag, Engine::UTCTimestamp value, int index ) = 0;
    virtual bool set( int tag, System::i32 value, int index ) = 0;
    virtual bool set( int tag, System::u32 value, int index ) = 0;
    virtual bool set( int tag, System::i64 value, int index ) = 0;
    virtual bool set( int tag, System::u64 value, int index ) = 0;
    virtual bool set( int tag, double value, int index ) = 0;
    virtual bool set( int tag, Decimal value, int index ) = 0;
    virtual bool set( int tag, AsciiString value, int index ) = 0;
    virtual bool set( int tag, ByteArray value, int index ) = 0;
    virtual bool set( int tag, char value, int index ) = 0;
    virtual bool set( int tag, bool value, int index ) = 0;
    bool set( int tag, char const* value, int index ) { return set( tag, AsciiString( value ), index ); }
  };
}

namespace Utils{

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

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

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

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

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

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

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

            return *this;
        }

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

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

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

            return ptr; 
        }

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

            ptr_ = ptr;
            releaseMethod_ = releaseMethod;
        }

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

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

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

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

    private:
        const Engine::FIXGroup *ptr_;

        ReleaseMethod releaseMethod_;
    };

}


#endif // __B2BITS_FIXGroup_h__

---