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

class
    ONIXS_FIXENGINE_API
    GroupInstance : public FieldSet
{
public:
    GroupInstance();

    GroupInstance(const GroupInstance & other);

    GroupInstance & operator = (const GroupInstance &);

    void swap(GroupInstance &);

    std::string toString(char delimiter = 0x1) const;

    void toString(std::string & str, char delimiter = 0x1) const;
 
private:
    friend class MessageOperator;
 
    GroupInstance(const Message *, void *);
};
 
inline
GroupInstance & GroupInstance::operator =(const GroupInstance & other)
{
    *static_cast<FieldSet *>(this) = static_cast<const FieldSet &>(other);
    return *this;
}
 
inline
void GroupInstance::swap(GroupInstance & other)
{
    FieldSet::swap(static_cast<FieldSet &>(other));
}
 
inline
std::string GroupInstance::toString(char delimiter) const
{
    std::string str;
 
    toString(str, delimiter);
 
    return str;
}

class ONIXS_FIXENGINE_API Group
{
public:
    Group();

    Group(const Group & other);

    bool valid() const;

    size_t size() const;

    GroupInstance at(size_t index);

    const GroupInstance at(size_t index) const;

    GroupInstance operator [](size_t index);

    const GroupInstance operator [](size_t index) const;

    Group & operator = (const Group & other);

    void swap(Group & other);

    std::string toString(char delimiter = 0x1) const;

    void toString(std::string & str, char delimiter = 0x1) const;

    class ONIXS_FIXENGINE_API Iterator
    {
    public:
 
        typedef std::forward_iterator_tag iterator_category;
        typedef GroupInstance value_type;
        typedef std::ptrdiff_t difference_type;
        typedef GroupInstance * pointer;
        typedef GroupInstance & reference;

        Iterator(Group *, size_t);
 
        GroupInstance & operator *() {
            return currentGroupInstance_;
        }
 
        GroupInstance * operator ->() {
            return &currentGroupInstance_;
        }
 
        bool operator == (const Iterator &) const;
        bool operator != (const Iterator &) const;
 
        Iterator & operator ++();
 
    private:
        Group * container_;

        size_t currentGroupInstanceIndex_;

        GroupInstance currentGroupInstance_;
    };

    Iterator begin();

    Iterator end();
 
private:
    friend class MessageOperator;
 
    void * impl_;
 
    const Message * container_;
 
    Group(const Message *, void *);
};
 
inline
std::string Group::toString(char delimiter) const
{
    std::string str;
 
    toString(str, delimiter);
 
    return str;
}

ONIXS_FIXENGINE_API
std::ostream & operator << (std::ostream & os, const Group & group);

ONIXS_FIXENGINE_API
std::ostream & operator << (std::ostream & os, const GroupInstance & instance);
 
}
}