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

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