Defines.h

Go to the documentation of this file.

/*
* Copyright 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.
*/
 
#pragma once
 
#include <OnixS/CboeCFE/Trading/BOE/ABI.h>
#include <OnixS/CboeCFE/Trading/BOE/Memory.h>
#include <OnixS/CboeCFE/Trading/BOE/Decimal.h>
#include <OnixS/CboeCFE/Trading/BOE/String.h>
#include <OnixS/CboeCFE/Trading/BOE/Integral.h>
 
#include <string>
#include <ostream>
 
namespace OnixS
{
    namespace CboeCFE
    {
        namespace Trading
        {
            namespace BOE
            {
                typedef unsigned short Port;
 

                struct ONIXS_CBOE_CFE_BOE_API StringTraits
                {
                    static void fillBufferAndAddSpaces(Byte* buffer, size_t size, Byte filler, const char* data, size_t dataSize);
 
                    static void fillBufferAndAddSpaces(Byte* buffer, size_t size, Byte filler, StrRef data)
                    {
                        fillBufferAndAddSpaces(buffer, size, filler, data.items(), data.size());
                    }
 
                    static void fillBufferAndAddSpaces(Byte* buffer, size_t size, Byte filler, Byte value);
                };

                template <size_t N, Byte FILLER = 0>
                struct ONIXS_CBOE_CFE_BOE_API String
                {
                    Byte data[N];

                    size_t size() const
                    {
                        return N;
                    }
 
                    String()
                    {
                        StringTraits::fillBufferAndAddSpaces(data, N, FILLER, constructStrRef(""));
                    }
 
                    String(const std::string& value)
                    {
                        StringTraits::fillBufferAndAddSpaces(data, N, FILLER, value);
                    }
 
                    String(Byte value)
                    {
                        StringTraits::fillBufferAndAddSpaces(data, N, FILLER, value);
                    }

                    std::string toString () const
                    {
                        return std::string ((const char*)data, strnlen((const char*)data, N));
                    }

                    StrRef toStrRef() const ONIXS_BATS_BOE_NOEXCEPT
                    {
                        return StrRef((const char*)data, strnlen((const char*)data, N));
                    }
                    
                    operator StrRef() const ONIXS_BATS_BOE_NOEXCEPT
                    {
                        return toStrRef();
                    }

                    String<N>& operator =(const StrRef value)
                    {
                        StringTraits::fillBufferAndAddSpaces(data, N, FILLER, value.items(), value.size());
 
                        return *this;
                    }

                    bool operator == (const String<N>& other) const
                    {
                        return ( 0 == memcmp(data, other.data, N));
                    }

                    bool operator != (const String<N>& other) const
                    {
                        return ( 0 != memcmp(data, other.data, N));
                    }
                };
                
                template <size_t N>
                bool operator == (const String<N>& ref, const std::string& str)
                {
                    return ref == String<N>(str);
                }
 
                template <size_t N>
                bool operator != (const String<N>& ref, const std::string& str)
                {
                    return ref != String<N>(str);
                }
 
                template <size_t N>
                bool operator == (const String<N>& ref, Byte ch)
                {
                    return ref.size() == 1 && ref == String<N>(ch);
                }
 
                template <size_t N>
                bool operator != (const String<N>& ref, Byte ch)
                {
                    return ref.size() != 1 || ref != String<N>(ch);
                }
 
                template <size_t N>
                std::ostream& operator << (std::ostream& stream, const String<N>& value)
                {
                    stream << '\'' << value.toString () << '\'';
                    return stream;
                }

                template <size_t N>
                void toStr(std::string& str, const String<N>& value)
                {
                    str.append((const char*)value.data, strnlen((const char*)value.data, N));
                }

                template <size_t N>
                inline std::string toStr(const String<N>& value)
                {
                    std::string str;
 
                    toStr(str, value);
 
                    return str;
                }
 
                typedef UInt8 Binary1;
                typedef UInt16 Binary2;
                typedef UInt32 Binary4;
                typedef UInt64 Binary8;
 
                typedef Int32 SignedBinary4;

                typedef
                FixedPointDecimal
                <
                    Int64,
                    IntegralConstant<Int8, -4>
                >
                BinaryPrice;
 
                template <size_t N>
                struct ONIXS_CBOE_CFE_BOE_API Alpha : public String<N>
                {
                    using String<N>::operator=;
                };
 
                template <size_t N>
                struct ONIXS_CBOE_CFE_BOE_API Alphanumeric : public String<N>
                {
                    using String<N>::operator=;
                };
 
                template <size_t N>
                struct ONIXS_CBOE_CFE_BOE_API Text : public String<N>
                {
                    using String<N>::operator=;
                };
 
                typedef UInt64 DateTime;
                typedef UInt32 Date;
 
                struct ONIXS_CBOE_CFE_BOE_API Unit
                {
                    Unit();
                    Unit(Binary1 number, Binary4 sequence);
 
                    Binary1 number() const
                    {
                        return number_;
                    }
 
                    Binary4 sequence() const
                    {
                        return sequence_;
                    }
 
                    Binary1 number_;
                    Binary4 sequence_;
 
                    size_t serializeTo(unsigned char*) const ONIXS_BATS_BOE_NOEXCEPT;
                };
 
                ONIXS_CBOE_CFE_BOE_DECLARE_T0_STR_FUNCTIONS(Unit)
 
                struct NotImplementedException : public std::runtime_error
                {
                    NotImplementedException()
                      : std::runtime_error("Not implemented")
                    {}
                };
 
                typedef Binary4 SeqNumber;
 
                struct SeqNumberTraits
                {
                    static const SeqNumber InvalidValue = SeqNumber(-1);
                };
            }
        }
    }
}