FieldMap.cpp
Go to the documentation of this file.
1 /****************************************************************************
2 ** Copyright (c) 2001-2014
3 **
4 ** This file is part of the QuickFIX FIX Engine
5 **
6 ** This file may be distributed under the terms of the quickfixengine.org
7 ** license as defined by quickfixengine.org and appearing in the file
8 ** LICENSE included in the packaging of this file.
9 **
10 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
11 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
12 **
13 ** See http://www.quickfixengine.org/LICENSE for licensing information.
14 **
15 ** Contact ask@quickfixengine.org if any conditions of this licensing are
16 ** not clear to you.
17 **
18 ****************************************************************************/
19 
20 #ifdef _MSC_VER
21 #include "stdafx.h"
22 #else
23 #include "config.h"
24 #endif
25 
26 #include "FieldMap.h"
27 #include <algorithm>
28 #include <iterator>
29 #include <deque>
30 
31 namespace FIX
32 {
34 {
35  clear();
36 }
37 
39 {
40  clear();
41 
42  m_fields = rhs.m_fields;
43 
44  Groups::const_iterator i;
45  for ( i = rhs.m_groups.begin(); i != rhs.m_groups.end(); ++i )
46  {
47  std::vector < FieldMap* > ::const_iterator j;
48  for ( j = i->second.begin(); j != i->second.end(); ++j )
49  {
50  FieldMap * pGroup = new FieldMap( **j );
51  m_groups[ i->first ].push_back( pGroup );
52  }
53  }
54 
55  return *this;
56 }
57 
58 void FieldMap::addGroup( int field, const FieldMap& group, bool setCount )
59 {
60  FieldMap * pGroup = new FieldMap( group );
61 
62  addGroupPtr( field, pGroup, setCount );
63 }
64 
65 void FieldMap::addGroupPtr( int field, FieldMap * group, bool setCount )
66 {
67  if( group == 0 )
68  return;
69 
70  std::vector< FieldMap* >& vec = m_groups[ field ];
71  vec.push_back( group );
72 
73  if( setCount )
74  setField( IntField( field, (int)vec.size() ) );
75 }
76 
77 void FieldMap::replaceGroup( int num, int field, const FieldMap& group )
78 {
79  Groups::const_iterator i = m_groups.find( field );
80  if ( i == m_groups.end() ) return;
81  if ( num <= 0 ) return;
82  if ( i->second.size() < ( unsigned ) num ) return;
83  *( *( i->second.begin() + ( num - 1 ) ) ) = group;
84 }
85 
86 void FieldMap::removeGroup( int num, int field )
87 {
88  Groups::iterator i = m_groups.find( field );
89  if ( i == m_groups.end() ) return;
90  if ( num <= 0 ) return;
91  std::vector< FieldMap* >& vector = i->second;
92  if ( vector.size() < ( unsigned ) num ) return;
93 
94  std::vector< FieldMap* >::iterator iter = vector.begin();
95  std::advance( iter, ( num - 1 ) );
96 
97  delete (*iter);
98  vector.erase( iter );
99 
100  if( vector.size() == 0 )
101  {
102  m_groups.erase( field );
103  removeField( field );
104  }
105  else
106  {
107  IntField groupCount( field, (int)vector.size() );
108  setField( groupCount, true );
109  }
110 }
111 
112 void FieldMap::removeGroup( int field )
113 {
114  removeGroup( (int)groupCount(field), field );
115 }
116 
117 void FieldMap::removeField( int field )
118 {
119  Fields::iterator i = m_fields.find( field );
120  if ( i != m_fields.end() )
121  m_fields.erase( i );
122 }
123 
124 bool FieldMap::hasGroup( int num, int field ) const
125 {
126  return (int)groupCount(field) >= num;
127 }
128 
129 bool FieldMap::hasGroup( int field ) const
130 {
131  Groups::const_iterator i = m_groups.find( field );
132  return i != m_groups.end();
133 }
134 
135 size_t FieldMap::groupCount( int field ) const
136 {
137  Groups::const_iterator i = m_groups.find( field );
138  if( i == m_groups.end() )
139  return 0;
140  return i->second.size();
141 }
142 
144 {
145  m_fields.clear();
146 
147  Groups::iterator i;
148  for ( i = m_groups.begin(); i != m_groups.end(); ++i )
149  {
150  std::vector < FieldMap* > ::iterator j;
151  for ( j = i->second.begin(); j != i->second.end(); ++j )
152  delete *j;
153  }
154  m_groups.clear();
155 }
156 
158 {
159  return m_fields.size() == 0;
160 }
161 
162 size_t FieldMap::totalFields() const
163 {
164  size_t result = m_fields.size();
165 
166  Groups::const_iterator i;
167  for ( i = m_groups.begin(); i != m_groups.end(); ++i )
168  {
169  std::vector < FieldMap* > ::const_iterator j;
170  for ( j = i->second.begin(); j != i->second.end(); ++j )
171  result += ( *j ) ->totalFields();
172  }
173  return result;
174 }
175 
176 std::string& FieldMap::calculateString( std::string& result ) const
177 {
178  Fields::const_iterator i;
179  for ( i = m_fields.begin(); i != m_fields.end(); ++i )
180  {
181  result += i->second.getFixString();
182 
183  // add groups if they exist
184  if( !m_groups.size() ) continue;
185  Groups::const_iterator j = m_groups.find( i->first );
186  if ( j == m_groups.end() ) continue;
187  std::vector < FieldMap* > ::const_iterator k;
188  for ( k = j->second.begin(); k != j->second.end(); ++k )
189  ( *k ) ->calculateString( result );
190  }
191  return result;
192 }
193 
194 int FieldMap::calculateLength( int beginStringField,
195  int bodyLengthField,
196  int checkSumField ) const
197 {
198  int result = 0;
199  Fields::const_iterator i;
200  for ( i = m_fields.begin(); i != m_fields.end(); ++i )
201  {
202  if ( i->first != beginStringField
203  && i->first != bodyLengthField
204  && i->first != checkSumField )
205  { result += i->second.getLength(); }
206  }
207 
208  Groups::const_iterator j;
209  for ( j = m_groups.begin(); j != m_groups.end(); ++j )
210  {
211  std::vector < FieldMap* > ::const_iterator k;
212  for ( k = j->second.begin(); k != j->second.end(); ++k )
213  result += ( *k ) ->calculateLength();
214  }
215  return result;
216 }
217 
218 int FieldMap::calculateTotal( int checkSumField ) const
219 {
220  int result = 0;
221  Fields::const_iterator i;
222  for ( i = m_fields.begin(); i != m_fields.end(); ++i )
223  {
224  if ( i->first != checkSumField )
225  result += i->second.getTotal();
226  }
227 
228  Groups::const_iterator j;
229  for ( j = m_groups.begin(); j != m_groups.end(); ++j )
230  {
231  std::vector < FieldMap* > ::const_iterator k;
232  for ( k = j->second.begin(); k != j->second.end(); ++k )
233  result += ( *k ) ->calculateTotal();
234  }
235  return result;
236 }
237 
238 }
int calculateTotal(int checkSumField=FIELD::CheckSum) const
Definition: FieldMap.cpp:218
bool hasGroup(int field) const
Check to see any instance of a group exists.
Definition: FieldMap.cpp:129
Fields::const_iterator iterator
Definition: FieldMap.h:59
FieldMap & operator=(const FieldMap &rhs)
Definition: FieldMap.cpp:38
void removeGroup(int num, int field)
Remove a specific instance of a group.
Definition: FieldMap.cpp:86
Definition: Acceptor.cpp:34
Stores and organizes a collection of Fields.
Definition: FieldMap.h:46
Fields m_fields
Definition: FieldMap.h:220
virtual ~FieldMap()
Definition: FieldMap.cpp:33
bool isEmpty()
Check if map contains any fields.
Definition: FieldMap.cpp:157
size_t groupCount(int field) const
Count the number of instance of a group.
Definition: FieldMap.cpp:135
Groups m_groups
Definition: FieldMap.h:221
void setField(const FieldBase &field, bool overwrite=true)
Set a field without type checking.
Definition: FieldMap.h:79
int calculateLength(int beginStringField=FIELD::BeginString, int bodyLengthField=FIELD::BodyLength, int checkSumField=FIELD::CheckSum) const
Definition: FieldMap.cpp:194
size_t totalFields() const
Definition: FieldMap.cpp:162
std::string & calculateString(std::string &) const
Definition: FieldMap.cpp:176
void removeField(int field)
Remove a field. If field is not present, this is a no-op.
Definition: FieldMap.cpp:117
void addGroup(int field, const FieldMap &group, bool setCount=true)
Add a group.
Definition: FieldMap.cpp:58
Field that contains an integer value.
Definition: Field.h:352
iterator const_iterator
Definition: FieldMap.h:60
void addGroupPtr(int field, FieldMap *group, bool setCount=true)
Acquire ownership of Group object.
Definition: FieldMap.cpp:65
FieldMap(const message_order &order=message_order(message_order::normal))
Definition: FieldMap.h:64
void replaceGroup(int num, int field, const FieldMap &group)
Replace a specific instance of a group.
Definition: FieldMap.cpp:77
void clear()
Clear all fields from the map.
Definition: FieldMap.cpp:143

Generated on Thu Sep 5 2019 11:07:58 for QuickFIX by doxygen 1.8.13 written by Dimitri van Heesch, © 1997-2001