Index  Source Files  Annotated Class List  Alphabetical Class List  Class Hierarchy  Graphical Class Hierarchy

/home/orenmnero/autobuild/quickfix/src/C++/FieldMap.h

Go to the documentation of this file.

/* -*- C++ -*- */

/****************************************************************************
** Copyright (c) quickfixengine.org  All rights reserved.
**
** This file is part of the QuickFIX FIX Engine
**
** This file may be distributed under the terms of the quickfixengine.org
** license as defined by quickfixengine.org and appearing in the file
** LICENSE included in the packaging of this file.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.quickfixengine.org/LICENSE for licensing information.
**
** Contact ask@quickfixengine.org if any conditions of this licensing are
** not clear to you.
**
****************************************************************************/

#ifndef FIX_FIELDMAP
#define FIX_FIELDMAP

#ifdef _MSC_VER
#pragma warning( disable: 4786 )
#endif

#include "Field.h"
#include "MessageSorters.h"
#include "Exceptions.h"
#include "CallStack.h"
#include <map>
#include <vector>
#include <sstream>
#include <algorithm>

namespace FIX
{
class FieldMap
{
public:
  typedef std::multimap < int, FieldBase, message_order > Fields;
  typedef std::map < int, std::vector < FieldMap* > > Groups;
  typedef Fields::const_iterator iterator;
  typedef iterator const_iterator;
  typedef Groups::const_iterator g_iterator;
  typedef Groups::const_iterator g_const_iterator;

  FieldMap( const message_order& order =
              message_order( message_order::normal ) )
  : m_fields( order ) {}

  FieldMap( const int order[] )
  : m_fields( message_order(order) ) {}

  FieldMap( const FieldMap& copy )
  { *this = copy; }

  virtual ~FieldMap();

  FieldMap& operator=( const FieldMap& rhs );

  void setField( const FieldBase& field, bool overwrite = true )
  throw( RepeatedTag )
  {
    Fields::iterator i = m_fields.find( field.getField() );
    if( i == m_fields.end() )
      m_fields.insert( Fields::value_type( field.getField(), field ) );
    else
    {
      if( overwrite )
        i->second = field;
      else
        m_fields.insert( Fields::value_type( field.getField(), field ) );
    }
  }
  void setField( int field, const std::string& value )
  throw( RepeatedTag, NoTagValue )
  {
    FieldBase fieldBase( field, value );
    setField( fieldBase );
  }

  FieldBase& getField( FieldBase& field )
  const throw( FieldNotFound )
  {
    Fields::const_iterator iter = m_fields.find( field.getField() );
    if ( iter == m_fields.end() )
      throw FieldNotFound( field.getField() );
    field = iter->second;
    return field;
  }
  std::string getField( int field )
  const throw( FieldNotFound )
  {
    FieldBase fieldBase( field, "" );
    getField( fieldBase );
    return fieldBase.getString();
  }

  bool isSetField( const FieldBase& field ) const
  { return m_fields.find( field.getField() ) != m_fields.end(); }
  bool isSetField( int field ) const
  { return m_fields.find( field ) != m_fields.end(); }

  void removeField( int field );

  void addGroup( int field, const FieldMap& group, bool setCount = true );

  void replaceGroup( int num, int field, FieldMap& group );

  FieldMap& getGroup( int num, int field, FieldMap& group ) const
    throw( FieldNotFound );

  void removeGroup( int num, int field );
  void removeGroup( int field );

  bool hasGroup( int field ) const;
  bool hasGroup( int num, int field ) const;
  int groupCount( int field ) const;

  void clear();
  bool isEmpty();

  std::string& calculateString( std::string&, bool clear = true ) const;

  int calculateLength( int beginStringField = FIELD::BeginString,
                       int bodyLengthField = FIELD::BodyLength,
                       int checkSumField = FIELD::CheckSum ) const;

  int calculateTotal( int checkSumField = FIELD::CheckSum ) const;

  iterator begin() const { return m_fields.begin(); }
  iterator end() const { return m_fields.end(); }
  g_iterator g_begin() const { return m_groups.begin(); }
  g_iterator g_end() const { return m_groups.end(); }

private:
  Fields m_fields;
  Groups m_groups;
};
}

#define FIELD_SET( MAP, FIELD )           \
bool isSet( const FIELD& field ) const    \
{ return (MAP).isSetField(field); }       \
void set( const FIELD& field )            \
{ (MAP).setField(field); }                \
FIELD& get( FIELD& field ) const          \
{ return (FIELD&)(MAP).getField(field); }

#endif //FIX_FIELDMAP

---