FieldSet.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 <vector>
#include <iterator>
 
#include <OnixS/FIXEngine/Compiler.h>
#include <OnixS/FIXEngine/FIX/Tag.h>
#include <OnixS/FIXEngine/FIX/FieldValueRef.h>
 
namespace OnixS {
namespace FIX {
ONIXS_FIXENGINE_API_DECL(class, Group);
ONIXS_FIXENGINE_API_DECL(class, Message);

struct ONIXS_FIXENGINE_API Field {
    Tag tag;

    FieldValueRef value;

    Field()
        : tag(0) {
    }

    Field(
        Tag fieldTag,
        const FieldValueRef & fieldValue)
        : tag(fieldTag), value(fieldValue) {
    }
};

typedef
std::vector<Field>
Fields;

class ONIXS_FIXENGINE_API FieldSet
{
public:
    bool valid() const;

    bool contain(Tag tag) const;

    FieldValueRef get(Tag tag) const;

    Char getChar(Tag tag) const;

    Int32 getInt32(Tag tag) const;

    UInt32 getUInt32(Tag tag) const;

    Int64 getInt64(Tag tag) const;

    UInt64 getUInt64(Tag tag) const;

    Double getDouble(Tag tag) const;

    Decimal getDecimal(Tag tag) const;

    Decimal getDecimal(Tag tag, Int32 exponent) const;

    StringRef getStringRef(Tag tag) const;

    Timestamp getTimestamp(Tag tag) const;

    Timestamp getTimestamp(Tag tag, TimestampFormat::Enum) const;

    TimeSpan getTimeSpan(Tag tag) const;

    Group getGroup(Tag numberOfInstancesTag) const;

    bool hasFlag(Tag tag) const;

    FieldSet & set(Tag tag, Int32 value);

    FieldSet & setV(Tag tag, Int32 value);

    FieldSet & set(Tag tag, UInt32 value);

    FieldSet & setV(Tag tag, UInt32 value);

    FieldSet & set(Tag tag, Int64 value);

    FieldSet & setV(Tag tag, Int64 value);

    FieldSet & set(Tag tag, UInt64 value);

    FieldSet & setV(Tag tag, UInt64 value);

    FieldSet & set(Tag tag, Double value, size_t precision = 17);

    FieldSet & set(Tag tag, Double value, size_t precision, size_t length);

    FieldSet & setV(Tag tag, Double value, size_t precision = 17);

    FieldSet & setV(Tag tag, Double value, size_t precision, size_t length);

    FieldSet & set(Tag tag, const Decimal & value);

    FieldSet & set(Tag tag, const Decimal & value, size_t length);

    FieldSet & setV(Tag tag, const Decimal & value);

    FieldSet & setV(Tag tag, const Decimal & value, size_t length);

    FieldSet & set(Tag tag, char value);

    FieldSet & set(Tag tag, const std::string & value);

    FieldSet & set(Tag tag, const char * value);

    FieldSet & set(Tag tag, const StringRef & value);

    FieldSet &
    set(
        Tag tag,
        const Timestamp & value,
        TimestampFormat::Enum valueFormat =
            TimestampFormat::YYYYMMDDHHMMSSNsec);

    FieldSet &
    setV(
        Tag tag,
        const Timestamp & value,
        TimestampFormat::Enum valueFormat =
            TimestampFormat::YYYYMMDDHHMMSSNsec);

    FieldSet &
    set(
        Tag tag,
        const TimeSpan & value,
        TimeSpanFormat::Enum valueFormat =
            TimeSpanFormat::HHMMSSNsec);

    FieldSet &
    setV(
        Tag tag,
        const TimeSpan & value,
        TimeSpanFormat::Enum valueFormat =
            TimeSpanFormat::HHMMSSNsec);

    Group setGroup(Tag tag, size_t value);

    FieldSet & setFlag(Tag tag, bool value);

    FieldSet & set(Tag tag, const FieldValueRef & value);

    bool erase(Tag tag);

    size_t fields(Fields & fields) const;

    class ONIXS_FIXENGINE_API ConstIterator
    {
    public:
 
        typedef std::forward_iterator_tag iterator_category;
        typedef Field value_type;
        typedef std::ptrdiff_t difference_type;
        typedef const Field * pointer;
        typedef const Field & reference;

        ConstIterator(const FieldSet *, Tag);
 
        reference operator *() const {
            return currentField_;
        }
 
        pointer operator ->() const {
            return &currentField_;
        }
 
        bool operator == (const ConstIterator &) const;
        bool operator != (const ConstIterator &) const;
 
        ConstIterator & operator ++();
 
    private:
        const FieldSet * container_;

        Field currentField_;
    };
 
    typedef ConstIterator const_iterator;

    ConstIterator begin() const;

    ConstIterator end() const;
 
protected:
    // Policies to control the field access.
    typedef size_t AccessPolicies;
 
    // The underlying implementation.
    void * impl_;
 
    // The message to which the given set belongs to.
    const Message * container_;
 
    // Policies to control the field access.
    AccessPolicies policies_;
 
    // The uninitialized set.
    FieldSet();
 
    // The uninitialized set.
    FieldSet(const Message *, void *, AccessPolicies);
 
    // The clone construction.
    FieldSet(const FieldSet &);
 
    // The destruction available via descendants.
    ~FieldSet() = default;
 
    FieldSet & operator = (const FieldSet &);
 
    // Swaps two instances.
    void swap(FieldSet &);
 
private:
    friend class Message;
    friend class GroupInstance;
    friend class MessageOperator;
};
 
inline
bool
FieldSet::contain(Tag tag) const
{
    return get(tag).valid();
}
 
}
}