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 {
33 
34 FieldMap::FieldMap( const message_order& order, int size )
35 : m_order(order)
36 {
37  m_fields.reserve(size);
38 }
39 
40 FieldMap::FieldMap( const message_order& order /*= message_order(message_order::normal)*/)
41 : m_order(order)
42 {
43  m_fields.reserve(DEFAULT_SIZE);
44 }
45 
46 FieldMap::FieldMap( const int order[] )
47 : m_order(message_order(order))
48 {
49  m_fields.reserve(DEFAULT_SIZE);
50 }
51 
52 FieldMap::FieldMap( const FieldMap& copy )
53 {
54  *this = copy;
55 }
56 
57 FieldMap::~FieldMap()
58 {
59  clear();
60 }
61 
62 FieldMap& FieldMap::operator=( const FieldMap& rhs )
63 {
64  clear();
65 
66  m_fields = rhs.m_fields;
67  m_order = rhs.m_order;
68 
69  Groups::const_iterator i;
70  for ( i = rhs.m_groups.begin(); i != rhs.m_groups.end(); ++i )
71  {
72  std::vector < FieldMap* > ::const_iterator j;
73  for ( j = i->second.begin(); j != i->second.end(); ++j )
74  {
75  FieldMap * pGroup = new FieldMap( **j );
76  m_groups[ i->first ].push_back( pGroup );
77  }
78  }
79 
80  return *this;
81 }
82 
83 void FieldMap::addGroup( int field, const FieldMap& group, bool setCount )
84 {
85  FieldMap * pGroup = new FieldMap( group );
86 
87  addGroupPtr( field, pGroup, setCount );
88 }
89 
90 void FieldMap::addGroupPtr( int field, FieldMap * group, bool setCount )
91 {
92  if( group == 0 )
93  return;
94 
95  std::vector< FieldMap* >& vec = m_groups[ field ];
96  vec.push_back( group );
97 
98  if( setCount )
99  setField( IntField( field, (int)vec.size() ) );
100 }
101 
102 void FieldMap::replaceGroup( int num, int field, const FieldMap& group )
103 {
104  Groups::const_iterator i = m_groups.find( field );
105  if ( i == m_groups.end() ) return;
106  if ( num <= 0 ) return;
107  if ( i->second.size() < ( unsigned ) num ) return;
108  *( *( i->second.begin() + ( num - 1 ) ) ) = group;
109 }
110 
111 void FieldMap::removeGroup( int num, int field )
112 {
113  Groups::iterator i = m_groups.find( field );
114  if ( i == m_groups.end() ) return;
115  if ( num <= 0 ) return;
116  std::vector< FieldMap* >& vector = i->second;
117  if ( vector.size() < ( unsigned ) num ) return;
118 
119  std::vector< FieldMap* >::iterator iter = vector.begin();
120  std::advance( iter, ( num - 1 ) );
121 
122  delete (*iter);
123  vector.erase( iter );
124 
125  if( vector.size() == 0 )
126  {
127  m_groups.erase( i );
128  removeField( field );
129  }
130  else
131  {
132  IntField groupCount( field, (int)vector.size() );
133  setField( groupCount );
134  }
135 }
136 
137 void FieldMap::removeGroup( int field )
138 {
139  Groups::iterator i = m_groups.find( field );
140  if ( i == m_groups.end() ) return;
141 
142  removeField( field );
143 
144  std::vector< FieldMap* > tmp;
145  tmp.swap( i->second );
146 
147  m_groups.erase( i );
148 
149  while ( !tmp.empty() )
150  {
151  delete tmp.back();
152  tmp.pop_back();
153  }
154 }
155 
156 void FieldMap::removeField( int field )
157 {
158  Fields::iterator i = findTag( field );
159  if ( i != m_fields.end() )
160  m_fields.erase( i );
161 }
162 
163 bool FieldMap::hasGroup( int num, int field ) const
164 {
165  return (int)groupCount(field) >= num;
166 }
167 
168 bool FieldMap::hasGroup( int field ) const
169 {
170  Groups::const_iterator i = m_groups.find( field );
171  return i != m_groups.end();
172 }
173 
174 size_t FieldMap::groupCount( int field ) const
175 {
176  Groups::const_iterator i = m_groups.find( field );
177  if( i == m_groups.end() )
178  return 0;
179  return i->second.size();
180 }
181 
182 void FieldMap::clear()
183 {
184  m_fields.clear();
185 
186  Groups::iterator i;
187  for ( i = m_groups.begin(); i != m_groups.end(); ++i )
188  {
189  std::vector < FieldMap* > ::iterator j;
190  for ( j = i->second.begin(); j != i->second.end(); ++j )
191  delete *j;
192  }
193  m_groups.clear();
194 }
195 
196 bool FieldMap::isEmpty()
197 {
198  return m_fields.empty();
199 }
200 
201 size_t FieldMap::totalFields() const
202 {
203  size_t result = m_fields.size();
204 
205  Groups::const_iterator i;
206  for ( i = m_groups.begin(); i != m_groups.end(); ++i )
207  {
208  std::vector < FieldMap* > ::const_iterator j;
209  for ( j = i->second.begin(); j != i->second.end(); ++j )
210  result += ( *j ) ->totalFields();
211  }
212  return result;
213 }
214 
215 std::string& FieldMap::calculateString( std::string& result ) const
216 {
217  Fields::const_iterator i;
218  for ( i = m_fields.begin(); i != m_fields.end(); ++i )
219  {
220  result += i->getFixString();
221 
222  // add groups if they exist
223  if( !m_groups.size() ) continue;
224  Groups::const_iterator j = m_groups.find( i->getTag() );
225  if ( j == m_groups.end() ) continue;
226  std::vector < FieldMap* > ::const_iterator k;
227  for ( k = j->second.begin(); k != j->second.end(); ++k )
228  ( *k ) ->calculateString( result );
229  }
230  return result;
231 }
232 
233 int FieldMap::calculateLength( int beginStringField,
234  int bodyLengthField,
235  int checkSumField ) const
236 {
237  int result = 0;
238  Fields::const_iterator i;
239  for ( i = m_fields.begin(); i != m_fields.end(); ++i )
240  {
241  int tag = i->getTag();
242  if ( tag != beginStringField
243  && tag != bodyLengthField
244  && tag != checkSumField )
245  { result += i->getLength(); }
246  }
247 
248  Groups::const_iterator j;
249  for ( j = m_groups.begin(); j != m_groups.end(); ++j )
250  {
251  std::vector < FieldMap* > ::const_iterator k;
252  for ( k = j->second.begin(); k != j->second.end(); ++k )
253  result += ( *k ) ->calculateLength();
254  }
255  return result;
256 }
257 
258 int FieldMap::calculateTotal( int checkSumField ) const
259 {
260  int result = 0;
261  Fields::const_iterator i;
262  for ( i = m_fields.begin(); i != m_fields.end(); ++i )
263  {
264  if ( i->getTag() != checkSumField )
265  result += i->getTotal();
266  }
267 
268  Groups::const_iterator j;
269  for ( j = m_groups.begin(); j != m_groups.end(); ++j )
270  {
271  std::vector < FieldMap* > ::const_iterator k;
272  for ( k = j->second.begin(); k != j->second.end(); ++k )
273  result += ( *k ) ->calculateTotal();
274  }
275  return result;
276 }
277 
278 }
FIX::FieldMap
Stores and organizes a collection of Fields.
Definition: FieldMap.h:63
FIX::FieldMap::FieldMap
FieldMap(const message_order &order, int size)
Definition: FieldMap.cpp:51
FIX::FieldMap::m_order
message_order m_order
Definition: FieldMap.h:393
FIX::FieldMap::m_groups
Groups m_groups
Definition: FieldMap.h:392
FIX::IntField
Field that contains an integer value.
Definition: Field.h:420
FIX::FieldMap::m_fields
Fields m_fields
Definition: FieldMap.h:391
FieldMap.h
FIX
Definition: Acceptor.cpp:34
FIX::FieldMap::iterator
Fields::iterator iterator
Definition: FieldMap.h:133
FIX::FieldMap::const_iterator
Fields::const_iterator const_iterator
Definition: FieldMap.h:134

Generated on Wed Apr 29 2020 19:41:30 for QuickFIX by doxygen 1.8.17 written by Dimitri van Heesch, © 1997-2001