quickfix

README

QuickFIX/Go

Open Source FIX Protocol library implemented in Go

FIX versions 4.0-5.0

Example Apps

See examples for some simple examples of using QuickFIX/Go.

Build and Test

The default make target runs go vet and unit tests.

QuickFIX/Go acceptance tests depend on ruby in path.

To run acceptance tests,

	# build acceptance test rig
	make build_accept

	# run acceptance tests
	make accept

Documentation

Overview

Package quickfix is a full featured messaging engine for the FIX protocol. It is a 100% Go open source implementation of the popular C++ QuickFIX engine (http://quickfixengine.org).

Creating your QuickFIX Application

Creating a FIX application is as easy as implementing the QuickFIX Application interface. By implementing these interface methods in your derived type, you are requesting to be notified of events that occur on the FIX engine. The function that you should be most aware of is fromApp.

Here are explanations of what these functions provide for you.

OnCreate(sessionID SessionID)

This method is called when quickfix creates a new session. A session comes into and remains in existence for the life of the application. Sessions exist whether or not a counter party is connected to it. As soon as a session is created, you can begin sending messages to it. If no one is logged on, the messages will be sent at the time a connection is established with the counterparty.

OnLogon(sessionID SessionID)

This callback notifies you when a valid logon has been established with a counter party. This is called when a connection has been established and the FIX logon process has completed with both parties exchanging valid logon messages.

OnLogout(sessionID SessionID)

This callback notifies you when an FIX session is no longer online. This could happen during a normal logout exchange or because of a forced termination or a loss of network connection.

ToAdmin(message Message, sessionID SessionID)

This callback provides you with a peak at the administrative messages that are being sent from your FIX engine to the counter party. This is normally not useful for an application however it is provided for any logging you may wish to do. Notice that the Message is not const. This allows you to add fields before an adminstrative message before it is sent out.

ToApp(message Message, sessionID SessionID) error

This is a callback for application messages that you are being sent to a counterparty. Notice that the Message is not const. This allows you to add fields before an application message before it is sent out.

FromAdmin(message Message, sessionID SessionID) MessageRejectError

This callback notifies you when an administrative message is sent from a counterparty to your FIX engine. This can be usefull for doing extra validation on logon messages such as for checking passwords.

FromApp(msg Message, sessionID SessionID) MessageRejectError

This is one of the core entry points for your FIX application. Every application level request will come through here. If, for example, your application is a sell-side OMS, this is where you will get your new order requests. If you were a buy side, you would get your execution reports here.

The sample code below shows how you might start up a FIX acceptor which listens on a socket. If you wanted an initiator, you would simply replace NewAcceptor in this code fragment with NewInitiator.

 package main

 import (
	"flag"
	"github.com/quickfixgo/quickfix"
	"os"
 )

 func main() {
	flag.Parse()
	fileName := flag.Arg(0)

	//FooApplication is your type that implements the Application interface
	var app FooApplication

	cfg, _ := os.Open(fileName)
	appSettings, _ := quickfix.ParseSettings(cfg)
	storeFactory := quickfix.NewMemoryStoreFactory()
	logFactory, _ := quickfix.NewFileLogFactory(appSettings)
	acceptor, _ := quickfix.NewAcceptor(app, storeFactory, appSettings, logFactory)

	acceptor.Start()
	//for condition == true { do something }
	acceptor.Stop()
 }

Configuring QuickFIX

A QuickFIXGo acceptor or initiator can maintain as many FIX sessions as you would like. A FIX session is identified by a group of settings defined within the configuration section for a session (or inherited from the default section). The identification settings are:

| Setting      | Required? |
|--------------|-----------|
| BeginString  |     Y     |
| SenderCompID |     Y     |
| SenderSubID  |     N     |
| TargetCompID |     Y     |
| TargetSubID  |     N     |

The sender settings are your identification and the target settings are for the counterparty. A SessionQualifier can also be use to disambiguate otherwise identical sessions.

Each of the sessions can have several settings associated with them. Some of these settings may not be known at compile time and are therefore passed around in a struct called SessionSettings.

SessionSettings can be read in from any input stream such as a file stream. If you decide to write your own components, (storage for a particular database, a new kind of connector etc...), you may also use the session settings to store settings for your custom component.

A settings file is set up with two types of heading, a [DEFAULT] and a [SESSION] heading. [SESSION] tells QuickFIX/Go that a new Session is being defined. [DEFAULT] is a place that you can define settings which will be inherited by sessions that don't explicitly define them. If you do not provide a setting that QuickFIX/Go needs, it will return an error indicating that a setting is missing or improperly formatted.

See the quickfix/config package for settings you can associate with a session based on the default components provided with QuickFIX/Go.

Here is a typical initiator settings file you might find for a firm that wants to connect to several ECNs.

# default settings for sessions
[DEFAULT]
FileLogPath=log
SenderCompID=TW

# session definition
[SESSION]
# inherit FileLogPath, SenderCompID from default
BeginString=FIX.4.1
TargetCompID=ARCA
HeartBtInt=20
SocketConnectPort=9823
SocketConnectHost=123.123.123.123
DataDictionary=somewhere/FIX41.xml

[SESSION]
BeginString=FIX.4.0
TargetCompID=ISLD
HeartBtInt=30
SocketConnectPort=8323
SocketConnectHost=23.23.23.23
DataDictionary=somewhere/FIX40.xml

[SESSION]
BeginString=FIX.4.2
TargetCompID=INCA
HeartBtInt=30
SocketConnectPort=6523
SocketConnectHost=3.3.3.3
DataDictionary=somewhere/FIX42.xml

Receiving Messages

Most of the messages you will be interested in looking at will be arriving in your FromApp function of your application. All messages have a header and trailer. If you want to get Header or Trailer fields, you must access those fields from the Header or Trailer embedded Struct. All other fields are accessible in the Body embedded struct.

QuickFIX/Go has a type for all messages, components, and fields defined in the standard spec. The easiest and most typesafe method of receiving messages is by using the quickfix MessageRouter generated message types.

 import "github.com/quickfixgo/quickfix/fix42/newordersingle"

 type MyApplication struct {
	*quickfix.MessageRouter
 }

 func (m *MyApplication) init() {
	m.MessageRouter=quickfix.NewMessageRouter()
	m.AddRoute(newordersingle.Route(m.onNewOrderSingle))
 }

 func (m *MyApplication) FromApp(msg quickfix.Message, sessionID quickfix.SessionID) (err quickfix.MessageRejectError) {
	return m.Route(msg, sessionID)
 }

 func (m *MyApplication) onNewOrderSingle(msg newordersingle.Message, sessionID quickfix.SessionID) (err quickfix.MessageRejectError) {
	price:=msg.Price
	clordID:=msg.ClOrdID

	return
 }

You can also bypass the MessageRouter and type safe classes by inspecting the Message directly. The preferred way of doing this is to use the quickfix generated Field types.

 import "github.com/quickfixgo/quickfix/field"

 func (m *MyApplication) FromApp(msg quickfix.Message, sessionID quickfix.SessionID) (err quickfix.MessageRejectError) {
	price:=new(field.PriceField)
	if err=msg.Body.Get(field); err!=nil {
		return
	}

	clordid:=new(field.ClOrdID)
	err=msg.Body.Get(field)
	return
 }

Or you can go the least type safe route.

 func (m *MyApplication) FromApp(msg quickfix.Message, sessionID quickfix.SessionID) (err quickfix.MessageRejectError) {
	field:=new(quickfix.FIXString)
	err:=msg.Body.GetField(quickfix.Tag(44), field)
	return
 }

Sending Messages

Messages can be sent to the counter party with the Send and SendToTarget functions.

//Send determines the session to send Marshaler using header fields BeginString, TargetCompID, SenderCompID
func Send(m Marshaler) error

//SendToTarget sends a message based on the sessionID. Convenient for use in FromApp since it provides a session ID for incoming messages
func SendToTarget(m Marshaler, sessionID SessionID) error

Index

• func Send(m Marshaler) (err error)
• func SendToTarget(m Marshaler, sessionID SessionID) error
• type Acceptor
  • func NewAcceptor(app Application, storeFactory MessageStoreFactory, settings *Settings, ...) (*Acceptor, error)
  • func (a *Acceptor) Start() (e error)
  • func (a *Acceptor) Stop()
• type Application
• type FIXBoolean
  • func NewFIXBoolean(val bool) *FIXBoolean
  • func (f *FIXBoolean) Read(bytes []byte) error
  • func (f FIXBoolean) Write() []byte
• type FIXFloat
  • func NewFIXFloat(val float64) *FIXFloat
  • func (f *FIXFloat) Read(bytes []byte) error
  • func (f FIXFloat) Write() []byte
• type FIXInt
  • func NewFIXInt(val int) *FIXInt
  • func (f *FIXInt) Read(bytes []byte) error
  • func (f FIXInt) Write() []byte
• type FIXString
  • func NewFIXString(val string) *FIXString
  • func (f *FIXString) Read(bytes []byte) (err error)
  • func (f FIXString) String() string
  • func (f FIXString) Write() []byte
• type FIXUTCTimestamp
  • func (f *FIXUTCTimestamp) Read(bytes []byte) error
  • func (f FIXUTCTimestamp) Write() []byte
• type Field
• type FieldMap
  • func (m *FieldMap) Clear()
  • func (m FieldMap) Get(parser Field) MessageRejectError
  • func (m FieldMap) GetField(tag Tag, parser FieldValueReader) MessageRejectError
  • func (m FieldMap) GetGroup(parser *RepeatingGroup) MessageRejectError
  • func (m FieldMap) Has(tag Tag) bool
  • func (m FieldMap) Set(field FieldWriter) FieldMap
  • func (m FieldMap) SetField(tag Tag, field FieldValueWriter) FieldMap
  • func (m FieldMap) SetGroup(field RepeatingGroup) FieldMap
  • func (m FieldMap) Tags() []Tag
• type FieldValue
• type FieldValueReader
• type FieldValueWriter
• type FieldWriter
• type Group
• type GroupItem
  • func GroupElement(tag Tag) GroupItem
• type GroupTemplate
• type Initiator
  • func NewInitiator(app Application, storeFactory MessageStoreFactory, appSettings *Settings, ...) (*Initiator, error)
  • func (i *Initiator) Start() error
  • func (i *Initiator) Stop()
• type Log
• type LogFactory
  • func NewFileLogFactory(settings *Settings) (LogFactory, error)
  • func NewNullLogFactory() LogFactory
  • func NewScreenLogFactory() LogFactory
• type Marshaler
• type Message
  • func Marshal(v interface{}) Message
  • func NewMessage() (m Message)
  • func (m *Message) Build() ([]byte, error)
  • func (m *Message) Init()
  • func (m Message) Marshal() Message
  • func (m *Message) String() string
• type MessageRejectError
  • func ConditionallyRequiredFieldMissing(tag Tag) MessageRejectError
  • func NewBusinessMessageRejectError(err string, rejectReason int, refTagID *Tag) MessageRejectError
  • func NewMessageRejectError(err string, rejectReason int, refTagID *Tag) MessageRejectError
  • func Unmarshal(m Message, v interface{}) MessageRejectError
  • func ValueIsIncorrect(tag Tag) MessageRejectError
• type MessageRoute
• type MessageRouter
  • func NewMessageRouter() *MessageRouter
  • func (c MessageRouter) AddRoute(beginString string, msgType string, router MessageRoute)
  • func (c MessageRouter) Route(msg Message, sessionID SessionID) MessageRejectError
• type MessageStore
• type MessageStoreFactory
  • func NewMemoryStoreFactory() MessageStoreFactory
• type RepeatingGroup
  • func (f *RepeatingGroup) Add() Group
• type SessionID
  • func (s SessionID) String() string
• type SessionSettings
  • func NewSessionSettings() *SessionSettings
  • func (s SessionSettings) BoolSetting(setting string) (bool, error)
  • func (s *SessionSettings) HasSetting(setting string) bool
  • func (s *SessionSettings) Init()
  • func (s *SessionSettings) IntSetting(setting string) (int, error)
  • func (s *SessionSettings) Set(setting string, val string)
  • func (s *SessionSettings) Setting(setting string) (string, error)
• type Settings
  • func NewSettings() *Settings
  • func ParseSettings(reader io.Reader) (*Settings, error)
  • func (s *Settings) AddSession(sessionSettings *SessionSettings) (SessionID, error)
  • func (s *Settings) GlobalSettings() *SessionSettings
  • func (s *Settings) Init()
  • func (s *Settings) SessionSettings() map[SessionID]*SessionSettings
• type Tag
  • func (t Tag) IsHeader() bool
  • func (t Tag) IsTrailer() bool

Functions

func Send

func Send(m Marshaler) (err error)

Send determines the session to send Marshaler using header fields BeginString, TargetCompID, SenderCompID

func SendToTarget

func SendToTarget(m Marshaler, sessionID SessionID) error

SendToTarget sends a message based on the sessionID. Convenient for use in FromApp since it provides a session ID for incoming messages

Types

type Acceptor

type Acceptor struct {
	// contains filtered or unexported fields
}

Acceptor accepts connections from FIX clients and manages the associated sessions.

func NewAcceptor

func NewAcceptor(app Application, storeFactory MessageStoreFactory, settings *Settings, logFactory LogFactory) (*Acceptor, error)

NewAcceptor creates and initializes a new Acceptor.

func (*Acceptor) Start

func (a *Acceptor) Start() (e error)

Start accepting connections.

func (*Acceptor) Stop

func (a *Acceptor) Stop()

Stop logs out existing sessions, close their connections, and stop accepting new connections.

type Application

type Application interface {
	//Notification of a session begin created.
	OnCreate(sessionID SessionID)

	//Notification of a session successfully logging on.
	OnLogon(sessionID SessionID)

	//Notification of a session logging off or disconnecting.
	OnLogout(sessionID SessionID)

	//Notification of admin message being sent to target.
	ToAdmin(message Message, sessionID SessionID)

	//Notification of app message being sent to target.
	ToApp(message Message, sessionID SessionID) error

	//Notification of admin message being received from target.
	FromAdmin(message Message, sessionID SessionID) MessageRejectError

	//Notification of app message being received from target.
	FromApp(message Message, sessionID SessionID) MessageRejectError
}

The Application interface should be implemented by FIX Applications. This is the primary interface for processing messages from a FIX Session.

type FIXBoolean

type FIXBoolean bool

FIXBoolean is a FIX Boolean value, implements FieldValue.

func NewFIXBoolean

func NewFIXBoolean(val bool) *FIXBoolean

NewFIXBoolean returns an initialized FIXBoolean

func (*FIXBoolean) Read

func (f *FIXBoolean) Read(bytes []byte) error

func (FIXBoolean) Write

func (f FIXBoolean) Write() []byte

type FIXFloat

type FIXFloat float64

FIXFloat is a FIX Float Value, implements FieldValue

func NewFIXFloat

func NewFIXFloat(val float64) *FIXFloat

NewFIXFloat returns an initialized FIXFloat

func (*FIXFloat) Read

func (f *FIXFloat) Read(bytes []byte) error

func (FIXFloat) Write

func (f FIXFloat) Write() []byte

type FIXInt

type FIXInt int

FIXInt is a FIX Int Value, implements FieldValue

func NewFIXInt

func NewFIXInt(val int) *FIXInt

NewFIXInt returns an initialized FIXInt

func (*FIXInt) Read

func (f *FIXInt) Read(bytes []byte) error

func (FIXInt) Write

func (f FIXInt) Write() []byte

type FIXString

type FIXString string

FIXString is a FIX String Value, implements FieldValue

func NewFIXString

func NewFIXString(val string) *FIXString

NewFIXString returns an initialized FIXString

func (*FIXString) Read

func (f *FIXString) Read(bytes []byte) (err error)

func (FIXString) String

func (f FIXString) String() string

func (FIXString) Write

func (f FIXString) Write() []byte

type FIXUTCTimestamp

type FIXUTCTimestamp struct {
	Value    time.Time
	NoMillis bool
}

FIXUTCTimestamp is a FIX UTC Timestamp value, implements FieldValue

func (*FIXUTCTimestamp) Read

func (f *FIXUTCTimestamp) Read(bytes []byte) error

func (FIXUTCTimestamp) Write

func (f FIXUTCTimestamp) Write() []byte

type Field

type Field interface {
	FieldWriter
	FieldValueReader
}

Field is the interface implemented by all typed Fields in a Message

type FieldMap

type FieldMap struct {
	// contains filtered or unexported fields
}

FieldMap is a collection of fix fields that make up a fix message.

func (*FieldMap) Clear

func (m *FieldMap) Clear()

Clear purges all fields from field map

func (FieldMap) Get

func (m FieldMap) Get(parser Field) MessageRejectError

func (FieldMap) GetField

func (m FieldMap) GetField(tag Tag, parser FieldValueReader) MessageRejectError

func (FieldMap) GetGroup

func (m FieldMap) GetGroup(parser *RepeatingGroup) MessageRejectError

func (FieldMap) Has

func (m FieldMap) Has(tag Tag) bool

func (FieldMap) Set

func (m FieldMap) Set(field FieldWriter) FieldMap

func (FieldMap) SetField

func (m FieldMap) SetField(tag Tag, field FieldValueWriter) FieldMap

func (FieldMap) SetGroup

func (m FieldMap) SetGroup(field RepeatingGroup) FieldMap

func (FieldMap) Tags

func (m FieldMap) Tags() []Tag

type FieldValue

type FieldValue interface {
	FieldValueWriter
	FieldValueReader
}

The FieldValue interface is used to write/extract typed field values to/from raw bytes

type FieldValueReader

type FieldValueReader interface {
	//Reads the contents of the []byte into FieldValue.  Returns an error if there are issues in the data processing
	Read([]byte) error
}

FieldValueReader is an interface for reading field values

type FieldValueWriter

type FieldValueWriter interface {
	//Writes out the contents of the FieldValue to a []byte
	Write() []byte
}

FieldValueWriter is an interface for writing field values

type FieldWriter

type FieldWriter interface {
	Tag() Tag
	FieldValueWriter
}

FieldWriter is an interface for a writing a field

type Group

type Group struct{ FieldMap }

type GroupItem

type GroupItem interface {
	//Tag returns the tag identifying this GroupItem
	Tag() Tag
	// contains filtered or unexported methods
}

GroupItem interface is used to construct repeating group templates

func GroupElement

func GroupElement(tag Tag) GroupItem

GroupElement returns a GroupItem made up of a single field

type GroupTemplate

type GroupTemplate []GroupItem

GroupTemplate specifies the group item order for a RepeatingGroup

type Initiator

type Initiator struct {
	// contains filtered or unexported fields
}

Initiator initiates connections and processes messages for all sessions.

func NewInitiator

func NewInitiator(app Application, storeFactory MessageStoreFactory, appSettings *Settings, logFactory LogFactory) (*Initiator, error)

NewInitiator creates and initializes a new Initiator.

func (*Initiator) Start

func (i *Initiator) Start() error

Start Initiator.

func (*Initiator) Stop

func (i *Initiator) Stop()

Stop Initiator.

type Log

type Log interface {
	//log incoming fix message
	OnIncoming(string)

	//log outgoing fix message
	OnOutgoing(string)

	//log fix event
	OnEvent(string)

	//log fix event according to format specifier
	OnEventf(string, ...interface{})
}

Log is a generic interface for logging FIX messages and events.

type LogFactory

type LogFactory interface {
	//global log
	Create() (Log, error)

	//session specific log
	CreateSessionLog(sessionID SessionID) (Log, error)
}

The LogFactory interface creates global and session specific Log instances

func NewFileLogFactory

func NewFileLogFactory(settings *Settings) (LogFactory, error)

NewFileLogFactory creates an instance of LogFactory that writes messages and events to file. The location of global and session log files is configured via FileLogPath.

func NewNullLogFactory

func NewNullLogFactory() LogFactory

NewNullLogFactory creates an instance of LogFactory that returns no-op loggers.

func NewScreenLogFactory

func NewScreenLogFactory() LogFactory

NewScreenLogFactory creates an instance of LogFactory that writes messages and events to stdout.

type Marshaler

type Marshaler interface {
	Marshal() Message
}

Marshaler Marshals self to quickfix.Message type

type Message

type Message struct {
	Header  FieldMap
	Trailer FieldMap
	Body    FieldMap

	//ReceiveTime is the time that this message was read from the socket connection
	ReceiveTime time.Time
	// contains filtered or unexported fields
}

Message is a FIX Message abstraction.

func Marshal

func Marshal(v interface{}) Message

Marshal returns the Message encoding of v

func NewMessage

func NewMessage() (m Message)

NewMessage returns a newly initialized Message instance

func (*Message) Build

func (m *Message) Build() ([]byte, error)

Build constructs a []byte from a Message instance

func (*Message) Init

func (m *Message) Init()

Init initializes the Message instance

func (Message) Marshal

func (m Message) Marshal() Message

Message marshals itself

func (*Message) String

func (m *Message) String() string

type MessageRejectError

type MessageRejectError interface {
	error

	//RejectReason, tag 373 for session rejects, tag 380 for business rejects.
	RejectReason() int
	RefTagID() *Tag
	IsBusinessReject() bool
}

MessageRejectError is a type of error that can correlate to a message reject.

func ConditionallyRequiredFieldMissing

func ConditionallyRequiredFieldMissing(tag Tag) MessageRejectError

ConditionallyRequiredFieldMissing indicates that the requested field could not be found in the FIX message.

func NewBusinessMessageRejectError

func NewBusinessMessageRejectError(err string, rejectReason int, refTagID *Tag) MessageRejectError

NewBusinessMessageRejectError returns a MessageRejectError with the given error mesage, reject reason, and optional reftagid. Reject is treated as a business level reject

func NewMessageRejectError

func NewMessageRejectError(err string, rejectReason int, refTagID *Tag) MessageRejectError

NewMessageRejectError returns a MessageRejectError with the given error message, reject reason, and optional reftagid

func Unmarshal

func Unmarshal(m Message, v interface{}) MessageRejectError

Unmarshal populates v from a Message

func ValueIsIncorrect

func ValueIsIncorrect(tag Tag) MessageRejectError

ValueIsIncorrect returns an error indicating a field with value that is not valid.

type MessageRoute

type MessageRoute func(msg Message, sessionID SessionID) MessageRejectError

A MessageRoute is a function can process a fromApp/fromAdmin callback

type MessageRouter

type MessageRouter struct {
	// contains filtered or unexported fields
}

A MessageRouter is a mutex for MessageRoutes

func NewMessageRouter

func NewMessageRouter() *MessageRouter

NewMessageRouter returns an initialized MessageRouter instance

func (MessageRouter) AddRoute

func (c MessageRouter) AddRoute(beginString string, msgType string, router MessageRoute)

AddRoute adds a route to the MessageRouter instance keyed to begin string and msgType.

func (MessageRouter) Route

func (c MessageRouter) Route(msg Message, sessionID SessionID) MessageRejectError

Route may be called from the fromApp/fromAdmin callbacks. Messages that cannot be routed will be rejected with UnsupportedMessageType.

type MessageStore

type MessageStore interface {
	NextSenderMsgSeqNum() int
	NextTargetMsgSeqNum() int

	IncrNextSenderMsgSeqNum()
	IncrNextTargetMsgSeqNum()

	SetNextSenderMsgSeqNum(next int)
	SetNextTargetMsgSeqNum(next int)

	CreationTime() time.Time

	SaveMessage(seqNum int, msg []byte)
	GetMessages(beginSeqNum, endSeqNum int) chan []byte

	Refresh()
	Reset()
}

The MessageStore interface provides methods to record and retrieve messages for resend purposes

type MessageStoreFactory

type MessageStoreFactory interface {
	Create(sessionID SessionID) (MessageStore, error)
}

The MessageStoreFactory interface is used by session to create a session specific message store

func NewMemoryStoreFactory

func NewMemoryStoreFactory() MessageStoreFactory

NewMemoryStoreFactory returns a MessageStoreFactory instance that created in-memory MessageStores

type RepeatingGroup

type RepeatingGroup struct {
	Tag
	GroupTemplate
	Groups []Group
}

RepeatingGroup is a FIX Repeating Group type

func (*RepeatingGroup) Add

func (f *RepeatingGroup) Add() Group

Add appends a new group to the RepeatingGroup and returns the new Group

type SessionID

type SessionID struct {
	BeginString, TargetCompID, SenderCompID, Qualifier string
}

SessionID is a unique identifer of a Session

func (SessionID) String

func (s SessionID) String() string

type SessionSettings

type SessionSettings struct {
	// contains filtered or unexported fields
}

SessionSettings maps session settings to values with typed accessors.

func NewSessionSettings

func NewSessionSettings() *SessionSettings

NewSessionSettings returns a newly initialized SessionSettings instance

func (SessionSettings) BoolSetting

func (s SessionSettings) BoolSetting(setting string) (bool, error)

BoolSetting returns the requested setting parsed as a boolean. Returns an errror if the setting is not set or cannot be parsed as a bool.

func (*SessionSettings) HasSetting

func (s *SessionSettings) HasSetting(setting string) bool

HasSetting returns true if a setting is set, false if not

func (*SessionSettings) Init

func (s *SessionSettings) Init()

Init initializes or resets SessionSettings

func (*SessionSettings) IntSetting

func (s *SessionSettings) IntSetting(setting string) (int, error)

IntSetting returns the requested setting parsed as an int. Returns an errror if the setting is not set or cannot be parsed as an int.

func (*SessionSettings) Set

func (s *SessionSettings) Set(setting string, val string)

Set assigns a value to a setting on SessionSettings.

func (*SessionSettings) Setting

func (s *SessionSettings) Setting(setting string) (string, error)

Setting is a settings string accessor. Returns an error if the setting is missing.

type Settings

type Settings struct {
	// contains filtered or unexported fields
}

The Settings type represents a collection of global and session settings.

func NewSettings

func NewSettings() *Settings

NewSettings creates a Settings instance

func ParseSettings

func ParseSettings(reader io.Reader) (*Settings, error)

ParseSettings creates and initializes a Settings instance with config parsed from a Reader. Returns error if the config is has parse errors

func (*Settings) AddSession

func (s *Settings) AddSession(sessionSettings *SessionSettings) (SessionID, error)

AddSession adds Session Settings to Settings instance. Returns an error if session settings with duplicate sessionID has already been added

func (*Settings) GlobalSettings

func (s *Settings) GlobalSettings() *SessionSettings

GlobalSettings are default setting inherited by all session settings.

func (*Settings) Init

func (s *Settings) Init()

Init initializes or resets a Settings instance

func (*Settings) SessionSettings

func (s *Settings) SessionSettings() map[SessionID]*SessionSettings

SessionSettings return all session settings overlaying globalsettings.

type Tag

type Tag int

Tag is a typed int representing a FIX tag

func (Tag) IsHeader

func (t Tag) IsHeader() bool

IsHeader returns true if tag belongs in the message header

func (Tag) IsTrailer

func (t Tag) IsTrailer() bool

IsTrailer returns true if tag belongs in the message trailer