C:/Users/Pasha/_Dev/fixforge-cpp/fix/cppEngine/include/OnixS/FIX/Message.h

/*
* Copyright 2005-2011 Onix Solutions Limited [OnixS]. All rights reserved. 
* 
* This software owned by Onix Solutions Limited [OnixS] and is protected by copyright law 
* and international copyright treaties. 
* 
* Access to and use of the software is governed by the terms of the applicable ONIXS Software
* Services Agreement (the Agreement) and Customer end user license agreements granting 
* a non-assignable, non-transferable and non-exclusive license to use the software 
* for it's own data processing purposes under the terms defined in the Agreement.
* 
* Except as otherwise granted within the terms of the Agreement, copying or reproduction of any part 
* of this source code or associated reference material to any other location for further reproduction
* or redistribution, and any amendments to this copyright notice, are expressly prohibited. 
*
* Any reproduction or redistribution for sale or hiring of the Software not in accordance with 
* the terms of the Agreement is a violation of copyright law. 
*/

#if !defined(__ONIXS_MESSAGE_H__)
#define __ONIXS_MESSAGE_H__

#include <iosfwd>
#include <string>

#include "OnixS/FIX/ABI.h"
#include "OnixS/FIX/Definitions.h"
#include "OnixS/FIX/EngineException.h"
#include "OnixS/FIX/Session.h"
#include "OnixS/FIX/Engine.h"

namespace OnixS
{
    namespace FIX
    {
        namespace FAST
        {
            ONIXS_FIXENGINE_API_DECL(class, Encoder);
            ONIXS_FIXENGINE_API_DECL(class, Decoder);
        };

        ONIXS_FIXENGINE_API_DECL(class, Group);
        ONIXS_FIXENGINE_API_DECL(class, Dialect);

        struct
        ONIXS_FIXENGINE_API
        MessageStructurePolicies
        {
            enum Enum
            {
                SerializationOptimized,
                PreserveOriginalValues
            };
        };

        typedef
        MessageStructurePolicies::Enum
        MessageStructurePolicy;

        struct 
        ONIXS_FIXENGINE_API 
        MessageValidationFlags
        {
            enum Enum
            {
                VerifyBodyLength = 2, 
                VerifyCheckSum = 4
            };
        };

        typedef int MessageValidationOptions;

        struct
        ONIXS_FIXENGINE_API
        MessageStringingFlags
        {
            enum Enum
            {
                IncludeTagNumber = 1,
                IncludeTagName = 2
            };
        };

        typedef
        int
        MessageStringingOptions;

        class ONIXS_FIXENGINE_API Message
        {
        public: 
            enum ValidationOption
            {
                CHECK_LENGTH = MessageValidationFlags::VerifyBodyLength,
                CHECK_CHECK_SUM = MessageValidationFlags::VerifyCheckSum
            };

            enum FORMAT
            {
                TAG_NUMBER = MessageStringingFlags::IncludeTagNumber,
                TAG_NAME = MessageStringingFlags::IncludeTagName
            };

            Message(const std::string& nativeFixMessage);

            Message(const std::string& nativeFixMessage, MessageValidationOptions validationOptions);

            Message(const std::string& nativeFixMessage, const Dialect& dialect, MessageValidationOptions validationOptions);

            Message(const char* type, Version version, MessageStructurePolicy policy = MessageStructurePolicies::SerializationOptimized);

            Message(const char* type, const Dialect& dialect, MessageStructurePolicy policy = MessageStructurePolicies::SerializationOptimized);

            Message(const std::string& type, Version version, MessageStructurePolicy policy = MessageStructurePolicies::SerializationOptimized);

            Message(const std::string& type, const Dialect& dialect, MessageStructurePolicy policy = MessageStructurePolicies::SerializationOptimized);

            Message(const Message& source);

      Message& operator = (const Message& source);

            ~Message();

            const std::string& getType() const;   

            Version getVersion() const;

            const Dialect& dialect() const;

            const std::string& getSenderCompID() const;

            void setSenderCompID(const std::string& value);

            int getSeqNum() const;  

            void setSeqNum(int value);    

            const std::string& getTargetCompID() const;

            void setTargetCompID(const std::string& value);

            bool contain(int tag) const;

            const std::string& get(int tag) const;

            int getInteger(int tag) const;      

            int getInt32(int tag) const;

            unsigned int getUInt32(int tag) const;
            
            long long getInt64(int tag) const;

            unsigned long long getUInt64(int tag) const;

            double getDouble(int tag) const;

            Group* getGroup(int numberOfInstancesTag) const;    

            bool hasFlag(int tag) const;

            bool set(int tag, char value);

      bool set(int tag, int value);

      bool set(int tag, unsigned int value);

      bool set(int tag, long long value);

      bool set(int tag, unsigned long long value);

            bool set(int tag, double value);

            bool set(int tag, double value, size_t precision);

            bool set(int tag, const std::string& value);

      bool set(int tag, const char* value);

            void setFlag(int tag, bool value);

            Group* setGroup(int numberOfInstancesTag, int numberOfIntances);  

            bool remove(int tag);

            const std::string& toString() const;

            const std::string& toString(char delimiter) const;

            const std::string& toString(MessageStringingOptions options, char delimiter = ' ') const;

            void validate() const;

            void updateCheckSum();

            bool operator == (const Message& rh) const;

            bool operator != (const Message& rh) const;

            friend ONIXS_FIXENGINE_API std::ostream& operator<< (std::ostream& os, const Message& message);

        private:      
      struct Impl;

      Message(Impl * impl);
            Message(void* native, bool isOwner = false);              

            void init(const void* dictionary, const char* type, MessageStructurePolicy policy);
            void init(const void* dictionary, const std::string& raw, int parsingOptions);

            Impl* impl_;

            void* native_;

      friend class MessageProxy;

            friend ONIXS_FIXENGINE_API_DECL(class, Dialect);
            friend ONIXS_FIXENGINE_API_DECL(class, Session);
            friend ONIXS_FIXENGINE_API_DECL(struct, Session::Impl);
            friend ONIXS_FIXENGINE_API_DECL(struct, Engine::Impl);  
            friend ONIXS_FIXENGINE_API_DECL(class, FAST::Encoder);
            friend ONIXS_FIXENGINE_API_DECL(class, FAST::Decoder);  
        };
    }
}

#endif // __ONIXS_MESSAGE_H__