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
31namespace FIX
32{
33
34FieldMap::FieldMap( const message_order& order, int size )
35: m_order(order)
36{
37 m_fields.reserve(size);
38}
39
40FieldMap::FieldMap( const message_order& order /*= message_order(message_order::normal)*/)
41: m_order(order)
42{
43 m_fields.reserve(DEFAULT_SIZE);
44}
45
46FieldMap::FieldMap( const int order[] )
47: m_order(message_order(order))
48{
49 m_fields.reserve(DEFAULT_SIZE);
50}
51
53{
54 *this = copy;
55}
56
58{
59 clear();
60}
61
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
83void FieldMap::addGroup( int field, const FieldMap& group, bool setCount )
84{
85 FieldMap * pGroup = new FieldMap( group );
86
87 addGroupPtr( field, pGroup, setCount );
88}
89
90void 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
102void 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
111void 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() );
134 }
135}
136
137void 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
156void FieldMap::removeField( int field )
157{
158 Fields::iterator i = findTag( field );
159 if ( i != m_fields.end() )
160 m_fields.erase( i );
161}
162
163bool FieldMap::hasGroup( int num, int field ) const
164{
165 return (int)groupCount(field) >= num;
166}
167
168bool FieldMap::hasGroup( int field ) const
169{
170 Groups::const_iterator i = m_groups.find( field );
171 return i != m_groups.end();
172}
173
174size_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
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
197{
198 return m_fields.empty();
199}
200
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
215std::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
233int 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
258int 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}
Stores and organizes a collection of Fields.
Definition FieldMap.h:47
void setField(const FieldBase &field, bool overwrite=true)
Set a field without type checking.
Definition FieldMap.h:116
void replaceGroup(int num, int tag, const FieldMap &group)
Replace a specific instance of a group.
Definition FieldMap.cpp:102
Fields::iterator iterator
Definition FieldMap.h:99
bool isEmpty()
Check if map contains any fields.
Definition FieldMap.cpp:196
iterator begin()
Definition FieldMap.h:258
Fields::const_iterator findTag(int tag) const
Definition FieldMap.h:310
int calculateLength(int beginStringField=FIELD::BeginString, int bodyLengthField=FIELD::BodyLength, int checkSumField=FIELD::CheckSum) const
Definition FieldMap.cpp:233
void removeField(int tag)
Remove a field. If field is not present, this is a no-op.
Definition FieldMap.cpp:156
void clear()
Clear all fields from the map.
Definition FieldMap.cpp:182
message_order m_order
Definition FieldMap.h:359
Groups m_groups
Definition FieldMap.h:358
bool hasGroup(int tag) const
Check to see any instance of a group exists.
Definition FieldMap.cpp:168
void addGroupPtr(int tag, FieldMap *group, bool setCount=true)
Acquire ownership of Group object.
Definition FieldMap.cpp:90
Fields::const_iterator const_iterator
Definition FieldMap.h:100
FieldMap(const message_order &order, int size)
Definition FieldMap.cpp:34
std::string & calculateString(std::string &) const
Definition FieldMap.cpp:215
virtual ~FieldMap()
Definition FieldMap.cpp:57
void addGroup(int tag, const FieldMap &group, bool setCount=true)
Add a group.
Definition FieldMap.cpp:83
FieldMap & operator=(const FieldMap &rhs)
Definition FieldMap.cpp:62
int calculateTotal(int checkSumField=FIELD::CheckSum) const
Definition FieldMap.cpp:258
size_t totalFields() const
Definition FieldMap.cpp:201
Fields m_fields
Definition FieldMap.h:357
void removeGroup(int num, int tag)
Remove a specific instance of a group.
Definition FieldMap.cpp:111
size_t groupCount(int tag) const
Count the number of instance of a group.
Definition FieldMap.cpp:174
Field that contains an integer value.
Definition Field.h:404
Sorts fields in header, normal, or trailer order.

Generated on Mon Oct 14 2024 06:04:44 for QuickFIX by doxygen 1.9.8 written by Dimitri van Heesch, © 1997-2001