SessionSettings.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 "SessionSettings.h"
27 #include "Settings.h"
28 #include "Values.h"
29 #include <fstream>
30 
31 namespace FIX
32 {
33 SessionSettings::SessionSettings( std::istream& stream )
34 throw( ConfigError )
35 {
36  stream >> *this;
37 }
38 
39 SessionSettings::SessionSettings( const std::string& file )
40 throw( ConfigError )
41 {
42  std::ifstream fstream( file.c_str() );
43  if ( !fstream.is_open() )
44  throw ConfigError( ( "File " + file + " not found" ).c_str() );
45  fstream >> *this;
46 }
47 
48 std::istream& operator>>( std::istream& stream, SessionSettings& s )
49 throw( ConfigError )
50 {
51  Settings settings;
52  stream >> settings;
53 
54  Settings::Sections section;
55 
56  section = settings.get( "DEFAULT" );
57  Dictionary def;
58  if ( section.size() )
59  def = section[ 0 ];
60  s.set( def );
61 
62  section = settings.get( "SESSION" );
63  Settings::Sections::size_type session;
64  Dictionary dict;
65 
66  for ( session = 0; session < section.size(); ++session )
67  {
68  dict = section[ session ];
69  dict.merge( def );
70 
71  BeginString beginString
72  ( dict.getString( BEGINSTRING ) );
73  SenderCompID senderCompID
74  ( dict.getString( SENDERCOMPID ) );
75  TargetCompID targetCompID
76  ( dict.getString( TARGETCOMPID ) );
77 
78  std::string sessionQualifier;
79  if( dict.has( SESSION_QUALIFIER ) )
80  sessionQualifier = dict.getString( SESSION_QUALIFIER );
81  SessionID sessionID( beginString, senderCompID, targetCompID, sessionQualifier );
82  s.set( sessionID, dict );
83  }
84  return stream;
85 }
86 
87 std::ostream& operator<<( std::ostream& stream, const SessionSettings& s )
88 {
89  const Dictionary& defaults = s.m_defaults;
90  if( defaults.size() )
91  {
92  stream << "[DEFAULT]" << std::endl;
94  for( i = defaults.begin(); i != defaults.end(); ++i )
95  stream << i->first << "=" << i->second << std::endl;
96  stream << std::endl;
97  }
98 
99  std::set<SessionID> sessions = s.getSessions();
100  std::set<SessionID>::iterator i;
101  for( i = sessions.begin(); i != sessions.end(); ++i )
102  {
103  stream << "[SESSION]" << std::endl;
104  const Dictionary& section = s.get( *i );
105  if( !section.size() ) continue;
106 
108  for( i = section.begin(); i != section.end(); ++i )
109  {
110  if( defaults.has(i->first) && defaults.getString(i->first) == i->second )
111  continue;
112  stream << i->first << "=" << i->second << std::endl;
113  }
114  stream << std::endl;
115  }
116 
117  return stream;
118 }
119 
120 const bool SessionSettings::has( const SessionID& sessionID ) const
121 {
122  return m_settings.find( sessionID ) != m_settings.end();
123 }
124 
125 const Dictionary& SessionSettings::get( const SessionID& sessionID ) const
126 throw( ConfigError )
127 {
128  Dictionaries::const_iterator i;
129  i = m_settings.find( sessionID );
130  if ( i == m_settings.end() ) throw ConfigError( "Session not found" );
131  return i->second;
132 }
133 
134 void SessionSettings::set( const SessionID& sessionID,
135  Dictionary settings )
136 throw( ConfigError )
137 {
138  if( has(sessionID) )
139  throw ConfigError( "Duplicate Session " + sessionID.toString() );
140 
141  settings.setString( BEGINSTRING, sessionID.getBeginString() );
142  settings.setString( SENDERCOMPID, sessionID.getSenderCompID() );
143  settings.setString( TARGETCOMPID, sessionID.getTargetCompID() );
144 
145  settings.merge( m_defaults );
146  validate( settings );
147  m_settings[ sessionID ] = settings;
148 }
149 
150 void SessionSettings::set( const Dictionary& defaults ) throw( ConfigError )
151 {
152  m_defaults = defaults;
153  Dictionaries::iterator i = m_settings.begin();
154  for( i = m_settings.begin(); i != m_settings.end(); ++i )
155  i->second.merge( defaults );
156 }
157 
158 std::set < SessionID > SessionSettings::getSessions() const
159 {
160  std::set < SessionID > result;
161  Dictionaries::const_iterator i;
162  for ( i = m_settings.begin(); i != m_settings.end(); ++i )
163  result.insert( i->first );
164  return result;
165 }
166 
167 void SessionSettings::validate( const Dictionary& dictionary ) const
168 throw( ConfigError )
169 {
170  std::string beginString = dictionary.getString( BEGINSTRING );
171  if( beginString != BeginString_FIX40 &&
172  beginString != BeginString_FIX41 &&
173  beginString != BeginString_FIX42 &&
174  beginString != BeginString_FIX43 &&
175  beginString != BeginString_FIX44 &&
176  beginString != BeginString_FIXT11 )
177  {
178  throw ConfigError( std::string(BEGINSTRING) + " must be FIX.4.0 to FIX.4.4 or FIXT.1.1" );
179  }
180 
181  std::string connectionType = dictionary.getString( CONNECTION_TYPE );
182  if( connectionType != "initiator" &&
183  connectionType != "acceptor" )
184  {
185  throw ConfigError( std::string(CONNECTION_TYPE) + " must be 'initiator' or 'acceptor'" );
186  }
187 }
188 
189 }
const char BeginString_FIX44[]
Definition: Values.h:32
void merge(const Dictionary &)
Merge two dictionaries.
Definition: Dictionary.cpp:155
const char CONNECTION_TYPE[]
const char BeginString_FIX42[]
Definition: Values.h:34
const char BeginString_FIXT11[]
Definition: Values.h:30
const Dictionary & get() const
Get global default settings.
iterator end() const
Definition: Dictionary.h:85
const char SESSION_QUALIFIER[]
const char BEGINSTRING[]
const bool has(const SessionID &) const
Check if session setings are present.
bool has(const std::string &) const
Check if the dictionary contains a value for key.
Definition: Dictionary.cpp:150
const char TARGETCOMPID[]
std::set< SessionID > getSessions() const
Data::const_iterator iterator
Definition: Dictionary.h:44
std::ostream & operator<<(std::ostream &stream, const FieldBase &field)
Definition: Field.h:197
const Dictionary & get(const SessionID &) const
Get a dictionary for a session.
const char BeginString_FIX43[]
Definition: Values.h:33
Definition: Acceptor.cpp:34
void validate(const Dictionary &) const
std::istream & operator>>(std::istream &stream, SessionID &sessionID)
Definition: SessionID.h:160
Application is not configured correctly
Definition: Exceptions.h:87
Container for setting dictionaries mapped to sessions.
const int TargetCompID
iterator begin() const
Definition: Dictionary.h:84
Sections get(const std::string &name) const
Definition: Settings.cpp:92
const char BeginString_FIX41[]
Definition: Values.h:35
const int SenderCompID
const char SENDERCOMPID[]
std::vector< Dictionary > Sections
Definition: Settings.h:41
For storage and retrieval of key/value pairs.
Definition: Dictionary.h:36
std::string getString(const std::string &, bool capitalize=false) const
Get a value as a string.
Definition: Dictionary.cpp:32
const int BeginString
Unique session id consists of BeginString, SenderCompID and TargetCompID.
Definition: SessionID.h:30
const char BeginString_FIX40[]
Definition: Values.h:36
void set(const SessionID &, Dictionary)
Set a dictionary for a session.
size_t size() const
Return the number of key/value pairs.
Definition: Dictionary.h:50
Internal representation of QuickFIX configuration settings.
Definition: Settings.h:38

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