diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b8f357c --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +*.swp +tmp +tradeclient +executor diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..50ef2d4 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,14 @@ +language: go +sudo: false + +go: + - 1.7 + - tip + +matrix: + allow_failures: + - go: tip + +install: + +script: go build ./cmd/... diff --git a/README.md b/README.md index b3141c8..0dbb70e 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,7 @@ -#Example QuickFIX/Go Applications +Example QuickFIX/Go Applications +================================ + +[![Build Status](https://travis-ci.org/quickfixgo/examples.svg?branch=master)](https://travis-ci.org/quickfixgo/examples) * TradeClient is a simple console based trading client * Executor is a server that fills every limit order it receives diff --git a/vendor/github.com/quickfixgo/quickfix/CHANGELOG.md b/vendor/github.com/quickfixgo/quickfix/CHANGELOG.md new file mode 100644 index 0000000..f4bb06b --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/CHANGELOG.md @@ -0,0 +1,106 @@ +## 0.4.0 (August 1, 2016) + +FEATURES + +* ReconnectInterval Initiator Configuration [GH 66, 161] + +ENHANCEMENTS + +* Generate Getters for messages [GH 118] +* Drop generate-* apps into cmd/ [GH 125, 150] +* Misc field type refactoring [GH 145] +* Cmd gen [GH 146, 147] +* refactoring enum generation [GH 148] +* pipelining generation [GH 149] +* Sending a message to an unlogged-in session, results an error [GH 173, 182] +* adds event logging related to session events [GH 175] +* Error handling around session code enhancement [GH 176] +* refactoring of session code [GH 183] +* Gen header beginstring [GH 184] + +BUG FIXES + +* Do not incr target seq num when seq num too high [GH 151] +* can't parse securitylist message [GH 153, 155] +* Concurrent map operations on Acceptor.Stop() [GH 156] +* Return requiredConfigurationMissing when "FileStorePath" not found [GH 157] +* Checks around HeartBtInt configuration [GH 158] +* Removed complexity around closing Initiator sessions [GH 159] +* Proper FIX logout sequence [GH 160] +* Session logic doesn't account for a failure when calling messageStore methods (e.g. persisting a message) [GH 162] +* Session event loop [GH 164] +* Session event loop follow up [GH 165] +* Handle OnLogon/Logout callbacks in user space [GH 167] +* Session deadlocks if both initiator and acceptor enter the resend state [GH 169, 179] +* Initiator.Stop() does not wait for Acceptor's logout response, causing a resend on next logon [GH 170, 172] +* Reset peer timer after logon [GH 171] +* Ensure OnLogon is called even if seq num too high [GH 174] +* increment target seq num on logout [GH 177] +* fixes bogus resend logic [GH 178] +* Session forgets it is in resend state [GH 180, 181] +* fixes donotsend logic [GH 185] + +## 0.3.0 (June 3, 2016) + +FEATURES + +* ValidateFieldsOutOfOrder Configuration Option [GH 107] + +ENHANCEMENTS + +* Datadictionary tests [GH 108] +* Proposal to add public method to convert raw fix message to quickfix.Message [GH 110] +* Make gen package public [GH 113] +* Make gen import path relative [GH 119] +* Validator interface [GH 120] +* Expose IncorrectDataFormat [GH 121] +* Spelling, fmtness [GH 123] +* More verbose error text on conditionally required field BMR [GH 131] +* better error handling in gen package [GH 134] +* Include timestamp in messages file log [GH 135] +* extracts repeating group interface [GH 137] +* Header, Body, Trailer FieldMap types [GH 138] +* Datadictionary/Gen refactor [GH 140] +* Gen value timestamp [GH 141] +* Slight gen revert [GH 142] +* replaced regex with faster impl for float parsing [GH 143] +* Expose sql.DB's SetConnMaxLifetime() in settings [GH 144, 139] + +BUG FIXES + +* Routing Incorrect for FIXT [GH 101] +* Validation Error for component tag [GH 102] +* Unmarshal error for repeating Group [GH 103] +* Marshaler/Reflector tries to convert time.Time struct into fix format [GH 109] +* nil pointer panic if no config.DataDictionary specified [GH 127] +* fixes required group validation error [GH 129] +* RefTagID is not known to BusinessMessageReject type [GH 130] + +## 0.2.0 (April 19, 2016) + +FEATURES + +* Persisted Store [GH 32] +* Initializer Constructors for Generated Messages [GH 69] +* Field Setters for generated messages [GH 70] +* Support for optional components, component setters [GH 79] +* Setters for repeating groups in components [GH 87] +* DB Store [GH 88] + +ENHANCEMENTS + +* Gen refactor [GH 78] +* Refactoring data dictionary pkg [GH 93] + +BUG FIXES + +* Initiator panic if connection closed [GH 59] +* New logs overrides old ones [GH 72] +* Session sending message timeout [GH 80] +* Potential FIX50 Market Data marshaling bug [GH 91] +* Allow settings values to contain equals signs [GH 97] +* Error when trying to unmarshal FIX message (FIX 5.0) [GH 99] + +## 0.1.0 (February 21, 2016) + +* Initial release diff --git a/vendor/github.com/quickfixgo/quickfix/CONTRIBUTING.md b/vendor/github.com/quickfixgo/quickfix/CONTRIBUTING.md new file mode 100644 index 0000000..d87ed08 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/CONTRIBUTING.md @@ -0,0 +1,16 @@ +# Contribution Guidelines + +We welcome pull requests, bug fixes and issue reports. + +Before proposing a large change, please discuss your change by raising an issue. + +## Submitting Changes + +* Push your changes to a topic branch in your fork of the repository +* Submit a pull request to the repository in the QuickFIXGo Organization + +## Notes + +* If you report a bug and do not include a fix, please include a failing test +* Generally, contributions without tests will not be accepted +* Contributions that fail the automated build will not be accepted diff --git a/vendor/github.com/quickfixgo/quickfix/LICENSE.txt b/vendor/github.com/quickfixgo/quickfix/LICENSE.txt new file mode 100644 index 0000000..d9eb364 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/LICENSE.txt @@ -0,0 +1,46 @@ +The QuickFIX Software License, Version 1.0 + +Copyright (c) 2001-2010 quickfixengine.org All rights +reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + +3. The end-user documentation included with the redistribution, + if any, must include the following acknowledgment: + "This product includes software developed by + quickfixengine.org (http://www.quickfixengine.org/)." + Alternately, this acknowledgment may appear in the software itself, + if and wherever such third-party acknowledgments normally appear. + +4. The names "QuickFIX" and "quickfixengine.org" must + not be used to endorse or promote products derived from this + software without prior written permission. For written + permission, please contact ask@quickfixengine.org + +5. Products derived from this software may not be called "QuickFIX", + nor may "QuickFIX" appear in their name, without prior written + permission of quickfixengine.org + +THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED +WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL QUICKFIXENGINE.ORG OR +ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF +USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT +OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +SUCH DAMAGE. + diff --git a/vendor/github.com/quickfixgo/quickfix/Makefile b/vendor/github.com/quickfixgo/quickfix/Makefile new file mode 100644 index 0000000..58b8cc9 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/Makefile @@ -0,0 +1,47 @@ +all: vet test + +generate: + go run cmd/generate-fix/generate-fix.go spec/*.xml + +fmt: + go fmt ./... + +vet: + go vet $(go list ./... | grep -v /vendor) + +lint: + go get github.com/golang/lint/golint + golint . + +test: + go test -v -cover . ./datadictionary ./internal + +_build_all: + go build -v ./... + +build_accept: + cd _test; go build -o echo_server + +build: _build_all build_accept + +fix40: + cd _test; ./runat.sh $@.cfg 5001 "definitions/server/$@/*.def" +fix41: + cd _test; ./runat.sh $@.cfg 5002 "definitions/server/$@/*.def" +fix42: + cd _test; ./runat.sh $@.cfg 5003 "definitions/server/$@/*.def" +fix43: + cd _test; ./runat.sh $@.cfg 5004 "definitions/server/$@/*.def" +fix44: + cd _test; ./runat.sh $@.cfg 5005 "definitions/server/$@/*.def" +fix50: + cd _test; ./runat.sh $@.cfg 5006 "definitions/server/$@/*.def" +fix50sp1: + cd _test; ./runat.sh $@.cfg 5007 "definitions/server/$@/*.def" +fix50sp2: + cd _test; ./runat.sh $@.cfg 5008 "definitions/server/$@/*.def" + +ACCEPT_SUITE=fix40 fix41 fix42 fix43 fix44 fix50 fix50sp1 fix50sp2 +accept: $(ACCEPT_SUITE) + +.PHONY: test $(ACCEPT_SUITE) diff --git a/vendor/github.com/quickfixgo/quickfix/README.md b/vendor/github.com/quickfixgo/quickfix/README.md new file mode 100644 index 0000000..c6daca6 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/README.md @@ -0,0 +1,99 @@ +QuickFIX/Go [![GoDoc](https://godoc.org/github.com/quickfixgo/quickfix?status.png)](https://godoc.org/github.com/quickfixgo/quickfix) [![Build Status](https://travis-ci.org/quickfixgo/quickfix.svg?branch=master)](https://travis-ci.org/quickfixgo/quickfix) [![Go Report Card](https://goreportcard.com/badge/github.com/quickfixgo/quickfix)](https://goreportcard.com/report/github.com/quickfixgo/quickfix) +=========== + +- Website: http://www.quickfixgo.org +- Mailing list: [Google Groups](https://groups.google.com/forum/#!forum/quickfixgo) + +Open Source [FIX Protocol](http://www.fixprotocol.org/) library implemented in Go + +FIX versions 4.0-5.0 + +Getting Started and Documentation +--------------------------------- + +All documentation is available on [GoDoc](https://godoc.org/github.com/quickfixgo/quickfix). + +### Installation + +To install QuickFIX/Go, use `go get`: + +``` +go get github.com/quickfixgo/quickfix +``` + +### Staying up to date + +To update QuickFIX/Go to the latest version, use `go get -u github.com/quickfixgo/quickfix`. + +### Example Apps + +See [examples](https://github.com/quickfixgo/examples) for some simple examples of using QuickFIX/Go. + +Developing QuickFIX/Go +---------------------- + +If you wish to work on QuickFIX/Go itself, you will first need [Go](http://www.golang.org) installed on your machine. + +### Build and Test + +The default make target runs [go vet](https://godoc.org/golang.org/x/tools/cmd/vet) and unit tests. + +### Dependencies + +QuickFIX/Go stores its dependencies under `vendor/`, which Go 1.6+ automatically recognize and load. We use [govendor](https://github.com/kardianos/govendor) to manage the vendored dependencies. + + +If you are developing QuickFIX/Go, there are a few tasks you might need to perform. + +#### Adding a dependency + +If you are adding a dependency, you will need to vendor it in the same Pull Request as the code that depends on it. You should do this in a separate commit from your code, as this makes PR review easier and Git history simpler to read in the future. + +To add a dependency: + +Assuming your work is on a branch called `my-feature-branch`, the steps look like this: + +1. Add the new package to your GOPATH: + + ```bash + go get github.com/quickfixgo/my-project + ``` + +2. Add the new package to your vendor/ directory: + + ```bash + govendor add github.com/quickfixgo/my-project + ``` + +3. Review the changes in git and commit them. + +#### Updating a dependency + +To update a dependency: + +1. Fetch the dependency: + + ```bash + govendor fetch github.com/quickfixgo/my-project + ``` + +2. Review the changes in git and commit them. + +### Acceptance Tests + +QuickFIX/Go has a comprehensive acceptance test suite covering the FIX protocol. These are the same tests used across all QuickFIX implementations. + +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 + +Licensing +--------- + +This software is available under the QuickFIX Software License. Please see the [LICENSE.txt](https://github.com/quickfixgo/quickfix/blob/master/LICENSE.txt) for the terms specified by the QuickFIX Software License. diff --git a/vendor/github.com/quickfixgo/quickfix/acceptor.go b/vendor/github.com/quickfixgo/quickfix/acceptor.go new file mode 100644 index 0000000..957ecc2 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/acceptor.go @@ -0,0 +1,203 @@ +package quickfix + +import ( + "bufio" + "crypto/tls" + "net" + "strconv" + "sync" + + "github.com/quickfixgo/quickfix/config" +) + +//Acceptor accepts connections from FIX clients and manages the associated sessions. +type Acceptor struct { + app Application + settings *Settings + logFactory LogFactory + storeFactory MessageStoreFactory + globalLog Log + sessions map[SessionID]*session + sessionGroup sync.WaitGroup + listener net.Listener + listenerShutdown sync.WaitGroup + sessionFactory +} + +//Start accepting connections. +func (a *Acceptor) Start() error { + socketAcceptHost := "" + if a.settings.GlobalSettings().HasSetting(config.SocketAcceptHost) { + var err error + if socketAcceptHost, err = a.settings.GlobalSettings().Setting(config.SocketAcceptHost); err != nil { + return err + } + } + + socketAcceptPort, err := a.settings.GlobalSettings().IntSetting(config.SocketAcceptPort) + if err != nil { + return err + } + + var tlsConfig *tls.Config + if tlsConfig, err = loadTLSConfig(a.settings.GlobalSettings()); err != nil { + return err + } + + address := net.JoinHostPort(socketAcceptHost, strconv.Itoa(socketAcceptPort)) + if tlsConfig != nil { + if a.listener, err = tls.Listen("tcp", address, tlsConfig); err != nil { + return err + } + } else { + if a.listener, err = net.Listen("tcp", address); err != nil { + return err + } + } + + for sessionID := range a.sessions { + session := a.sessions[sessionID] + a.sessionGroup.Add(1) + go func() { + session.run() + a.sessionGroup.Done() + }() + } + + a.listenerShutdown.Add(1) + go a.listenForConnections() + return nil +} + +//Stop logs out existing sessions, close their connections, and stop accepting new connections. +func (a *Acceptor) Stop() { + defer func() { + _ = recover() // suppress sending on closed channel error + }() + + a.listener.Close() + a.listenerShutdown.Wait() + for _, session := range a.sessions { + session.stop() + } + a.sessionGroup.Wait() +} + +//NewAcceptor creates and initializes a new Acceptor. +func NewAcceptor(app Application, storeFactory MessageStoreFactory, settings *Settings, logFactory LogFactory) (a *Acceptor, err error) { + a = &Acceptor{ + app: app, + storeFactory: storeFactory, + settings: settings, + logFactory: logFactory, + sessions: make(map[SessionID]*session), + } + + if a.globalLog, err = logFactory.Create(); err != nil { + return + } + + for sessionID, sessionSettings := range settings.SessionSettings() { + sessID := SessionID{ + BeginString: sessionID.BeginString, + TargetCompID: sessionID.TargetCompID, + SenderCompID: sessionID.SenderCompID, + } + + if _, dup := a.sessions[sessID]; dup { + return a, errDuplicateSessionID + } + + if a.sessions[sessID], err = a.createSession(sessionID, storeFactory, sessionSettings, logFactory, app); err != nil { + return + } + } + + return +} + +func (a *Acceptor) listenForConnections() { + defer a.listenerShutdown.Done() + + for { + netConn, err := a.listener.Accept() + if err != nil { + return + } + + go func() { + a.handleConnection(netConn) + }() + } +} + +func (a *Acceptor) invalidMessage(msg []byte, err error) { + a.globalLog.OnEventf("Invalid Message: %s, %v", msg, err.Error()) +} + +func (a *Acceptor) handleConnection(netConn net.Conn) { + defer func() { + if err := recover(); err != nil { + a.globalLog.OnEventf("Connection Terminated: %v", err) + } + + if err := netConn.Close(); err != nil { + a.globalLog.OnEvent(err.Error()) + } + }() + + reader := bufio.NewReader(netConn) + parser := newParser(reader) + + msgBytes, err := parser.ReadMessage() + if err != nil { + a.globalLog.OnEvent(err.Error()) + return + } + + msg, err := ParseMessage(msgBytes) + if err != nil { + a.invalidMessage(msgBytes, err) + return + } + + var beginString FIXString + if err := msg.Header.GetField(tagBeginString, &beginString); err != nil { + a.invalidMessage(msgBytes, err) + return + } + + var senderCompID FIXString + if err := msg.Header.GetField(tagSenderCompID, &senderCompID); err != nil { + a.invalidMessage(msgBytes, err) + return + } + + var targetCompID FIXString + if err := msg.Header.GetField(tagTargetCompID, &targetCompID); err != nil { + a.invalidMessage(msgBytes, err) + return + } + + sessID := SessionID{BeginString: string(beginString), SenderCompID: string(targetCompID), TargetCompID: string(senderCompID)} + session, ok := a.sessions[sessID] + if !ok { + a.globalLog.OnEventf("Session %v not found for incoming message: %s", sessID, msgBytes) + return + } + + msgIn := make(chan fixIn) + msgOut := make(chan []byte) + + if err := session.connect(msgIn, msgOut); err != nil { + a.globalLog.OnEventf("Unable to accept %v", err.Error()) + return + } + + go func() { + msgIn <- fixIn{msgBytes, parser.lastRead} + readLoop(parser, msgIn) + }() + + writeLoop(netConn, msgOut, a.globalLog) +} diff --git a/vendor/github.com/quickfixgo/quickfix/application.go b/vendor/github.com/quickfixgo/quickfix/application.go new file mode 100644 index 0000000..0bdb7dd --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/application.go @@ -0,0 +1,26 @@ +package quickfix + +//The Application interface should be implemented by FIX Applications. +//This is the primary interface for processing messages from a FIX Session. +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 +} diff --git a/vendor/github.com/quickfixgo/quickfix/config/configuration.go b/vendor/github.com/quickfixgo/quickfix/config/configuration.go new file mode 100644 index 0000000..49617c9 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/config/configuration.go @@ -0,0 +1,35 @@ +package config + +const ( + BeginString string = "BeginString" + SenderCompID string = "SenderCompID" + TargetCompID string = "TargetCompID" + SessionQualifier string = "SessionQualifier" + SocketAcceptHost string = "SocketAcceptHost" + SocketAcceptPort string = "SocketAcceptPort" + SocketConnectHost string = "SocketConnectHost" + SocketConnectPort string = "SocketConnectPort" + SocketPrivateKeyFile string = "SocketPrivateKeyFile" + SocketCertificateFile string = "SocketCertificateFile" + SocketCAFile string = "SocketCAFile" + DefaultApplVerID string = "DefaultApplVerID" + StartTime string = "StartTime" + EndTime string = "EndTime" + StartDay string = "StartDay" + EndDay string = "EndDay" + TimeZone string = "TimeZone" + DataDictionary string = "DataDictionary" + TransportDataDictionary string = "TransportDataDictionary" + AppDataDictionary string = "AppDataDictionary" + ResetOnLogon string = "ResetOnLogon" + RefreshOnLogon string = "RefreshOnLogon" + ResetOnLogout string = "ResetOnLogout" + ReconnectInterval string = "ReconnectInterval" + HeartBtInt string = "HeartBtInt" + FileLogPath string = "FileLogPath" + FileStorePath string = "FileStorePath" + SQLDriver string = "SQLDriver" + SQLDataSourceName string = "SQLDataSourceName" + SQLConnMaxLifetime string = "SQLConnMaxLifetime" + ValidateFieldsOutOfOrder string = "ValidateFieldsOutOfOrder" +) diff --git a/vendor/github.com/quickfixgo/quickfix/config/doc.go b/vendor/github.com/quickfixgo/quickfix/config/doc.go new file mode 100644 index 0000000..fa45647 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/config/doc.go @@ -0,0 +1,232 @@ +/* +Package config declares application and session settings for QuickFIX/Go + +BeginString + +Version of FIX this session should use. Valid values: + + FIXT.1.1 + FIX.4.4 + FIX.4.3 + FIX.4.2 + FIX.4.1 + FIX.4.0 + +SenderCompID + +Your ID as associated with this FIX session. Value is case-sensitive alpha-numeric string. + +TargetCompID + +Counter parties ID as associated with this FIX session. Value is case-sensitive alpha-numeric string. + +SessionQualifier + +Additional qualifier to disambiguate otherwise identical sessions. Value is case-sensitive alpha-numeric string. + +DefaultApplVerID + +Required only for FIXT 1.1 (and newer). Ignored for earlier transport versions. Specifies the default application version ID for the session. This can either be the ApplVerID enum (see the ApplVerID field) or the BeginString for the default version. Valid Values: + + FIX.5.0SP2 + FIX.5.0SP1 + FIX.5.0 + FIX.4.4 + FIX.4.3 + FIX.4.2 + FIX.4.1 + FIX.4.0 + 9 + 8 + 7 + 6 + 5 + 4 + 3 + 2 + +TimeZone + +Time zone for this session; if specified, the session start and end will be converted from this zone to UTC. Valid Values: + + IANA Time zone ID (America/New_York, Asia/Tokyo, Europe/London, etc.) + Local (The Zone on host) + +Defaults to UTC. + +StartTime + +Time of day that this FIX session becomes activated. Valid Values: + + time in the format of HH:MM:SS, time is represented in time zone configured by TimeZone + +EndTime + +Time of day that this FIX session becomes deactivated. Valid Values: + + time in the format of HH:MM:SS, time is represented in time zone configured by TimeZone + +StartDay + +For week long sessions, the starting day of week for the session. Use in combination with StartTime. Valid Values: + + Full day of week in English, or 3 letter abbreviation (i.e. Monday and Mon are valid) + +EndDay + +For week long sessions, the ending day of week for the session. Use in combination with EndTime. Valid Values: + + Full day of week in English, or 3 letter abbreviation (i.e. Monday and Mon are valid) + +ResetOnLogon + +Determines if sequence numbers should be reset when receiving a logon request. Acceptors only. Valid Values: + Y + N + +Defaults to N. + +ResetOnLogout + +Determines if sequence numbers should be reset to 1 after a normal logout termination. Valid Values: + Y + N + +Defaults to N. + +RefreshOnLogon + +Determines if session state should be restored from persistence layer when logging on. Useful for creating hot failover sessions. Valid Values: + Y + N + +Defaults to N. + + +Validation + +The following settings are specific to message validation. + +DataDictionary + +XML definition file for validating incoming FIX messages. If no DataDictionary is supplied, only basic message validation will be done. + +This setting should only be used with FIX transport versions older than FIXT.1.1. See TransportDataDictionary and AppDataDictionary for FIXT.1.1 settings. Value must be a valid XML data dictionary file. QuickFIX/Go comes with the following defaults in the spec directory + + FIX44.xml + FIX43.xml + FIX42.xml + FIX41.xml + FIX40.xml + +TransportDataDictionary + +XML definition file for validating admin (transport) messages. This setting is only valid for FIXT.1.1 (or newer) sessions. See DataDictionary for older transport versions (FIX.4.0 - FIX.4.4) for additional information. Value must be a valid XML data dictionary file, QuickFIX/Go comes with the following defaults in the spec directory + + FIXT1.1.xml + +AppDataDictionary + +XML definition file for validating application messages. This setting is only valid for FIXT.1.1 (or newer) sessions. See DataDictionary for older transport versions (FIX.4.0 - FIX.4.4) for additional information. + +This setting supports the possibility of a custom application data dictionary for each session. This setting would only be used with FIXT 1.1 and new transport protocols. This setting can be used as a prefix to specify multiple application dictionaries for the FIXT transport. For example: + + DefaultApplVerID=FIX.4.2 + # For default application version ID + AppDataDictionary=FIX42.xml + # For nondefault application version ID + # Use BeginString suffix for app version + AppDataDictionary.FIX.4.4=FIX44.xml + +Value must be a valid XML data dictionary file. QuickFIX/Go comes with the following defaults in the spec directory + + FIX50SP2.xml + FIX50SP1.xml + FIX50.xml + FIX44.xml + FIX43.xml + FIX42.xml + FIX41.xml + FIX40.xml + +ValidateFieldsOutOfOrder + +If set to N, fields that are out of order (i.e. body fields in the header, or header fields in the body) will not be rejected. Useful for connecting to systems which do not properly order fields. Valid Values: + Y + N + +Defaults to Y. + +ReconnectInterval + +Time between reconnection attempts in seconds. Only used for initiators. Value must be positive integer. + +Defaults to 30 + +HeartBtInt + +Heartbeat interval in seconds. Only used for initiators. Value must be positive integer. + +SocketConnectPort + +Socket port for connecting to a session. Only used for initiators. Must be positive integer + +SocketConnectHost + +Host to connect to. Only used for initiators. Value must be a valid IPv4 or IPv6 address or a domain name + +SocketConnectPort + +Alternate socket ports for connecting to a session for failover, where n is a positive integer. (i.e.) SocketConnectPort1, SocketConnectPort2... must be consecutive and have a matching SocketConnectHost[n]. Value must be a positive integer. + +SocketConnectHost + +Alternate socket hosts for connecting to a session for failover, where n is a positive integer. (i.e.) SocketConnectHost1, SocketConnectHost2... must be consecutive and have a matching SocketConnectPort[n]. Value must be a valid IPv4 or IPv6 address or a domain name + +SocketAcceptHost + +Socket host address for listening on incoming connections, only used for acceptors. By default acceptors listen on all available interfaces. + +SocketAcceptPort + +Socket port for listening to incoming connections, only used for acceptors. Value must be a positive integer, valid open socket port. + +SocketPrivateKeyFile + +Private key to use for secure TLS connections. Must be used with SocketCertificateFile. + +SocketCertificateFile + +Certificate to use for secure TLS connections. Must be used with SocketPrivateKeyFile. + +SocketCAFile + +Optional root CA to use for secure TLS connections. For acceptors, client certificates will be verified against this CA. For initiators, clients will use the CA to verify the server certificate. If not configurated, initiators will verify the server certificate using the host's root CA set. + +FileLogPath + +Directory to store logs. Value must be valid directory for storing files, application must have write access. + +FileStorePath + +Directory to store sequence number and message files. Only used with FileStoreFactory. + +SQLDriver + +The name of the database driver to use (see https://github.com/golang/go/wiki/SQLDrivers for the list of available drivers). Only used with SqlStoreFactory. + +SQLDataSourceName + +The driver-specific data source name of the database to use. Only used with SqlStoreFactory. + +SQLConnMaxLifetime + +SetConnMaxLifetime sets the maximum duration of time that a database connection may be reused (see https://golang.org/pkg/database/sql/#DB.SetConnMaxLifetime). Defaults to zero, which causes connections to be reused forever. Only used with SqlStoreFactory. + +If your database server has a config option to close inactive connections after some duration (e.g. MySQL "wait_timeout"), set SQLConnMaxLifetime to a value less than that duration. + +Example Values: + SQLConnMaxLifetime=14400s # 14400 seconds + SQLConnMaxLifetime=2h45m # 2 hours and 45 minutes +*/ +package config diff --git a/vendor/github.com/quickfixgo/quickfix/connection.go b/vendor/github.com/quickfixgo/quickfix/connection.go new file mode 100644 index 0000000..4e5768a --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/connection.go @@ -0,0 +1,28 @@ +package quickfix + +import "io" + +func writeLoop(connection io.Writer, messageOut chan []byte, log Log) { + for { + msg, ok := <-messageOut + if !ok { + return + } + + if _, err := connection.Write(msg); err != nil { + log.OnEvent(err.Error()) + } + } +} + +func readLoop(parser *parser, msgIn chan fixIn) { + defer close(msgIn) + + for { + msg, err := parser.ReadMessage() + if err != nil { + return + } + msgIn <- fixIn{msg, parser.lastRead} + } +} diff --git a/vendor/github.com/quickfixgo/quickfix/datadictionary/build.go b/vendor/github.com/quickfixgo/quickfix/datadictionary/build.go new file mode 100644 index 0000000..9956580 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/datadictionary/build.go @@ -0,0 +1,228 @@ +package datadictionary + +import ( + "fmt" +) + +type builder struct { + doc *XMLDoc + dict *DataDictionary + componentByName map[string]*XMLComponent +} + +func (b *builder) build(doc *XMLDoc) (*DataDictionary, error) { + b.doc = doc + + b.componentByName = make(map[string]*XMLComponent) + for _, c := range doc.Components { + b.componentByName[c.Name] = c + } + + b.dict = &DataDictionary{FIXType: doc.Type, Major: doc.Major, Minor: doc.Minor, ServicePack: doc.ServicePack} + b.buildFieldTypes() + + if err := b.buildComponents(); err != nil { + return nil, err + } + + if err := b.buildMessageDefs(); err != nil { + return nil, err + } + + var err error + if b.dict.Header, err = b.buildMessageDef(b.doc.Header); err != nil { + return nil, err + } + if b.dict.Trailer, err = b.buildMessageDef(b.doc.Trailer); err != nil { + return nil, err + } + + return b.dict, nil +} + +func (b builder) findOrBuildComponentType(xmlMember *XMLComponentMember) (*ComponentType, error) { + if comp, preBuilt := b.dict.ComponentTypes[xmlMember.Name]; preBuilt { + return comp, nil + } + + var xmlComp *XMLComponent + var ok bool + + if xmlComp, ok = b.componentByName[xmlMember.Name]; !ok { + return nil, newUnknownComponent(xmlMember.Name) + } + + var comp *ComponentType + var err error + + if comp, err = b.buildComponentType(xmlComp); err != nil { + return nil, err + } + + b.dict.ComponentTypes[xmlMember.Name] = comp + + return comp, nil +} + +func (b builder) buildComponentType(xmlComponent *XMLComponent) (*ComponentType, error) { + var parts []MessagePart + + for _, member := range xmlComponent.Members { + if member.isComponent() { + var childComponentType *ComponentType + var err error + if childComponentType, err = b.findOrBuildComponentType(member); err != nil { + return nil, err + } + + childComponent := Component{ + ComponentType: childComponentType, + required: member.isRequired(), + } + + parts = append(parts, childComponent) + } else { + var field *FieldDef + var err error + if field, err = b.buildFieldDef(member); err != nil { + return nil, err + } + + parts = append(parts, field) + } + } + + return NewComponentType(xmlComponent.Name, parts), nil +} + +func (b builder) buildComponents() error { + b.dict.ComponentTypes = make(map[string]*ComponentType) + + for _, c := range b.doc.Components { + if _, allReadyBuilt := b.dict.ComponentTypes[c.Name]; !allReadyBuilt { + var builtComponent *ComponentType + var err error + if builtComponent, err = b.buildComponentType(c); err != nil { + return err + } + b.dict.ComponentTypes[c.Name] = builtComponent + } + } + + return nil +} + +func (b builder) buildMessageDefs() error { + b.dict.Messages = make(map[string]*MessageDef) + + var err error + for _, m := range b.doc.Messages { + if b.dict.Messages[m.MsgType], err = b.buildMessageDef(m); err != nil { + break + } + } + + return err +} + +func (b builder) buildMessageDef(xmlMessage *XMLComponent) (*MessageDef, error) { + var parts []MessagePart + for _, member := range xmlMessage.Members { + if member.isComponent() { + var ok bool + var comp *ComponentType + if comp, ok = b.dict.ComponentTypes[member.Name]; !ok { + return nil, newUnknownComponent(member.Name) + } + + parts = append(parts, Component{ComponentType: comp, required: member.isRequired()}) + } else { + var field *FieldDef + var err error + if field, err = b.buildFieldDef(member); err != nil { + return nil, err + } + parts = append(parts, field) + } + } + + return NewMessageDef(xmlMessage.Name, xmlMessage.MsgType, parts), nil +} + +func (b builder) buildGroupFieldDef(xmlField *XMLComponentMember, groupFieldType *FieldType) (*FieldDef, error) { + var parts []MessagePart + + for _, member := range xmlField.Members { + if member.isComponent() { + var err error + var compType *ComponentType + if compType, err = b.findOrBuildComponentType(member); err != nil { + return nil, err + } + + comp := Component{ + ComponentType: compType, + required: member.isRequired(), + } + + parts = append(parts, comp) + } else { + var f *FieldDef + var err error + if f, err = b.buildFieldDef(member); err != nil { + return nil, err + } + parts = append(parts, f) + } + } + + return NewGroupFieldDef(groupFieldType, xmlField.isRequired(), parts), nil +} + +func (b builder) buildFieldDef(xmlField *XMLComponentMember) (*FieldDef, error) { + var fieldType *FieldType + var ok bool + + if fieldType, ok = b.dict.FieldTypeByName[xmlField.Name]; !ok { + return nil, newUnknownField(xmlField.Name) + } + + if xmlField.isGroup() { + f, err := b.buildGroupFieldDef(xmlField, fieldType) + return f, err + } + + return NewFieldDef(fieldType, xmlField.isRequired()), nil +} + +func (b builder) buildFieldTypes() { + b.dict.FieldTypeByTag = make(map[int]*FieldType) + b.dict.FieldTypeByName = make(map[string]*FieldType) + for _, f := range b.doc.Fields { + field := buildFieldType(f) + b.dict.FieldTypeByTag[field.Tag()] = field + b.dict.FieldTypeByName[field.Name()] = field + } +} + +func buildFieldType(xmlField *XMLField) *FieldType { + field := NewFieldType(xmlField.Name, xmlField.Number, xmlField.Type) + + if len(xmlField.Values) > 0 { + field.Enums = make(map[string]Enum) + + for _, enum := range xmlField.Values { + field.Enums[enum.Enum] = Enum{Value: enum.Enum, Description: enum.Description} + } + } + + return field +} + +func newUnknownComponent(name string) error { + return fmt.Errorf("unknown component %v", name) +} + +func newUnknownField(name string) error { + return fmt.Errorf("unknown field %v", name) +} diff --git a/vendor/github.com/quickfixgo/quickfix/datadictionary/datadictionary.go b/vendor/github.com/quickfixgo/quickfix/datadictionary/datadictionary.go new file mode 100644 index 0000000..410ca8e --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/datadictionary/datadictionary.go @@ -0,0 +1,340 @@ +//Package datadictionary provides support for parsing and organizing FIX Data Dictionaries +package datadictionary + +import ( + "encoding/xml" + "os" +) + +//DataDictionary models FIX messages, components, and fields. +type DataDictionary struct { + FIXType string + Major int + Minor int + ServicePack int + FieldTypeByTag map[int]*FieldType + FieldTypeByName map[string]*FieldType + Messages map[string]*MessageDef + ComponentTypes map[string]*ComponentType + Header *MessageDef + Trailer *MessageDef +} + +//MessagePart can represent a Field, Repeating Group, or Component +type MessagePart interface { + Name() string + Required() bool +} + +//messagePartWithFields is a MessagePart with multiple Fields +type messagePartWithFields interface { + MessagePart + Fields() []*FieldDef + RequiredFields() []*FieldDef +} + +//ComponentType is a grouping of fields. +type ComponentType struct { + name string + parts []MessagePart + fields []*FieldDef + requiredFields []*FieldDef + requiredParts []MessagePart +} + +//NewComponentType returns an initialized component type +func NewComponentType(name string, parts []MessagePart) *ComponentType { + comp := ComponentType{ + name: name, + parts: parts, + } + + for _, part := range parts { + + if part.Required() { + comp.requiredParts = append(comp.requiredParts, part) + } + + switch f := part.(type) { + case messagePartWithFields: + comp.fields = append(comp.fields, f.Fields()...) + + if f.Required() { + comp.requiredFields = append(comp.requiredFields, f.RequiredFields()...) + } + case *FieldDef: + comp.fields = append(comp.fields, f) + + if f.Required() { + comp.requiredFields = append(comp.requiredFields, f) + } + } + } + + return &comp +} + +//Name returns the name of this component type +func (c ComponentType) Name() string { return c.name } + +//Fields returns all fields contained in this component. Includes fields +//encapsulated in components of this component +func (c ComponentType) Fields() []*FieldDef { return c.fields } + +//RequiredFields returns those fields that are required for this component +func (c ComponentType) RequiredFields() []*FieldDef { return c.requiredFields } + +//RequiredParts returns those parts that are required for this component +func (c ComponentType) RequiredParts() []MessagePart { return c.requiredParts } + +// Parts returns all parts in declaration order contained in this component +func (c ComponentType) Parts() []MessagePart { return c.parts } + +//TagSet is set for tags. +type TagSet map[int]struct{} + +//Add adds a tag to the tagset. +func (t TagSet) Add(tag int) { + t[tag] = struct{}{} +} + +//Component is a Component as it appears in a given MessageDef +type Component struct { + *ComponentType + required bool +} + +//NewComponent returns an initialized Component instance +func NewComponent(ct *ComponentType, required bool) *Component { + return &Component{ + ComponentType: ct, + required: required, + } +} + +//Required returns true if this component is required for the containing +//MessageDef +func (c Component) Required() bool { return c.required } + +//Field models a field or repeating group in a message +type Field interface { + Tag() int +} + +//FieldDef models a field belonging to a message. +type FieldDef struct { + *FieldType + required bool + + Parts []MessagePart + Fields []*FieldDef + requiredParts []MessagePart + requiredFields []*FieldDef +} + +//NewFieldDef returns an initialized FieldDef +func NewFieldDef(fieldType *FieldType, required bool) *FieldDef { + return &FieldDef{ + FieldType: fieldType, + required: required, + } +} + +//NewGroupFieldDef returns an initialized FieldDef for a repeating group +func NewGroupFieldDef(fieldType *FieldType, required bool, parts []MessagePart) *FieldDef { + field := FieldDef{ + FieldType: fieldType, + required: required, + Parts: parts, + } + + for _, part := range parts { + if part.Required() { + field.requiredParts = append(field.requiredParts, part) + } + + if comp, ok := part.(Component); ok { + field.Fields = append(field.Fields, comp.Fields()...) + + if comp.required { + field.requiredFields = append(field.requiredFields, comp.requiredFields...) + } + } else { + if child, ok := part.(*FieldDef); ok { + field.Fields = append(field.Fields, child) + + if child.required { + field.requiredFields = append(field.requiredFields, child) + } + } else { + panic("unknown part") + } + } + } + + return &field +} + +//Required returns true if this FieldDef is required for the containing +//MessageDef +func (f FieldDef) Required() bool { return f.required } + +//IsGroup is true if the field is a repeating group. +func (f FieldDef) IsGroup() bool { + return len(f.Fields) > 0 +} + +//RequiredParts returns those parts that are required for this FieldDef. IsGroup +//must return true +func (f FieldDef) RequiredParts() []MessagePart { return f.requiredParts } + +//RequiredFields returns those fields that are required for this FieldDef. IsGroup +//must return true +func (f FieldDef) RequiredFields() []*FieldDef { return f.requiredFields } + +func (f FieldDef) childTags() []int { + tags := make([]int, 0, len(f.Fields)) + + for _, f := range f.Fields { + tags = append(tags, f.Tag()) + for _, t := range f.childTags() { + tags = append(tags, t) + } + } + + return tags +} + +func (f FieldDef) requiredChildTags() []int { + var tags []int + + for _, f := range f.Fields { + if !f.Required() { + continue + } + + tags = append(tags, f.Tag()) + for _, t := range f.requiredChildTags() { + tags = append(tags, t) + } + } + + return tags +} + +//FieldType holds information relating to a field. Includes Tag, type, and enums, if defined. +type FieldType struct { + name string + tag int + Type string + Enums map[string]Enum +} + +//NewFieldType returns a pointer to an initialized FieldType +func NewFieldType(name string, tag int, fixType string) *FieldType { + return &FieldType{ + name: name, + tag: tag, + Type: fixType, + } +} + +//Name returns the name for this FieldType +func (f FieldType) Name() string { return f.name } + +//Tag returns the tag for this fieldType +func (f FieldType) Tag() int { return f.tag } + +//Enum is a container for value and description. +type Enum struct { + Value string + Description string +} + +//MessageDef can apply to header, trailer, or body of a FIX Message. +type MessageDef struct { + Name string + MsgType string + Fields map[int]*FieldDef + //Parts are the MessageParts of contained in this MessageDef in declaration + //order + Parts []MessagePart + requiredParts []MessagePart + + RequiredTags TagSet + Tags TagSet +} + +//RequiredParts returns those parts that are required for this Message +func (m MessageDef) RequiredParts() []MessagePart { return m.requiredParts } + +//NewMessageDef returns a pointer to an initialized MessageDef +func NewMessageDef(name, msgType string, parts []MessagePart) *MessageDef { + msg := MessageDef{ + Name: name, + MsgType: msgType, + Fields: make(map[int]*FieldDef), + RequiredTags: make(TagSet), + Tags: make(TagSet), + Parts: parts, + } + + processField := func(field *FieldDef, allowRequired bool) { + msg.Fields[field.Tag()] = field + msg.Tags.Add(field.Tag()) + for _, t := range field.childTags() { + msg.Tags.Add(t) + } + + if allowRequired && field.Required() { + msg.RequiredTags.Add(field.Tag()) + } + } + + for _, part := range parts { + if part.Required() { + msg.requiredParts = append(msg.requiredParts, part) + } + + switch pType := part.(type) { + case messagePartWithFields: + for _, f := range pType.Fields() { + //field if required in component is required in message only if + //component is required + processField(f, pType.Required()) + } + + case *FieldDef: + processField(pType, true) + + default: + panic("Unknown Part") + } + } + + return &msg +} + +//Parse loads and and build a datadictionary instance from an xml file. +func Parse(path string) (*DataDictionary, error) { + var xmlFile *os.File + xmlFile, err := os.Open(path) + if err != nil { + return nil, err + } + defer xmlFile.Close() + + doc := new(XMLDoc) + decoder := xml.NewDecoder(xmlFile) + if err := decoder.Decode(doc); err != nil { + return nil, err + } + + b := new(builder) + var dict *DataDictionary + if dict, err = b.build(doc); err != nil { + return nil, err + } + + return dict, nil +} diff --git a/vendor/github.com/quickfixgo/quickfix/datadictionary/xml.go b/vendor/github.com/quickfixgo/quickfix/datadictionary/xml.go new file mode 100644 index 0000000..814d20f --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/datadictionary/xml.go @@ -0,0 +1,63 @@ +package datadictionary + +import ( + "encoding/xml" +) + +//XMLDoc is the unmarshalled root of a FIX Dictionary. +type XMLDoc struct { + Type string `xml:"type,attr"` + Major int `xml:"major,attr"` + Minor int `xml:"minor,attr"` + ServicePack int `xml:"servicepack,attr"` + + Header *XMLComponent `xml:"header"` + Trailer *XMLComponent `xml:"trailer"` + Messages []*XMLComponent `xml:"messages>message"` + Components []*XMLComponent `xml:"components>component"` + Fields []*XMLField `xml:"fields>field"` +} + +// XMLComponent can represent header, trailer, messages/message, or components/component xml elements. +type XMLComponent struct { + Name string `xml:"name,attr"` + MsgCat string `xml:"msgcat,attr"` + MsgType string `xml:"msgtype,attr"` + + Members []*XMLComponentMember `xml:",any"` +} + +//XMLField represents the fields/field xml element. +type XMLField struct { + Number int `xml:"number,attr"` + Name string `xml:"name,attr"` + Type string `xml:"type,attr"` + Values []*XMLValue `xml:"value"` +} + +//XMLValue represents the fields/field/value xml element. +type XMLValue struct { + Enum string `xml:"enum,attr"` + Description string `xml:"description,attr"` +} + +//XMLComponentMember represents child elements of header, trailer, messages/message, and components/component elements +type XMLComponentMember struct { + XMLName xml.Name + Name string `xml:"name,attr"` + Required string `xml:"required,attr"` + + Members []*XMLComponentMember `xml:",any"` +} + +func (member XMLComponentMember) isComponent() bool { + return member.XMLName.Local == "component" +} + +func (member XMLComponentMember) isGroup() bool { + return member.XMLName.Local == "group" +} + +func (member XMLComponentMember) isRequired() bool { + return member.Required == "Y" +} diff --git a/vendor/github.com/quickfixgo/quickfix/doc.go b/vendor/github.com/quickfixgo/quickfix/doc.go new file mode 100644 index 0000000..7874799 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/doc.go @@ -0,0 +1,196 @@ +/* +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 callback functions provide for you. + + OnCreate(sessionID SessionID) + +OnCreate 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) + +OnLogon 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) + +OnLogout 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) + +ToAdmin 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 administrative message is sent out. + + ToApp(message Message, sessionID SessionID) error + +ToApp notifies you of 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 + +FromAdmin 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 + +FromApp 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 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. Any messages you do not establish routes for will by default return an UnsupportedMessageType reject. + + import ( + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fix41/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.NewOrderSingle, sessionID quickfix.SessionID) (err quickfix.MessageRejectError) { + var clOrdID field.ClOrdIDField + if clOrdID, err = msg.GetClOrdID(); err!=nil { + return + } + + //compile time error!! field not defined in FIX41 + var clearingAccount field.ClearingAccountField + clearingAccount, err = msg.GetClearingAccount() + + ... + 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. + + func (m *MyApplication) FromApp(msg quickfix.Message, sessionID quickfix.SessionID) (err quickfix.MessageRejectError) { + var price field.PriceField + if err = msg.Body.Get(&field); err!=nil { + return + } + + ... + return + } + + +Or you can go the least type safe route. + + func (m *MyApplication) FromApp(msg quickfix.Message, sessionID quickfix.SessionID) (err quickfix.MessageRejectError) { + var field quickfix.FIXString + if err = msg.Body.GetField(quickfix.Tag(44), &field); err!=nil { + return + } + + ... + return + } + +Sending Messages + +Messages can be sent to the counter party with the Send and SendToTarget functions. + + //Send determines the session to send Messagable using header fields BeginString, TargetCompID, SenderCompID + func Send(m Messagable) error + + //SendToTarget sends Messagable based on the sessionID. Convenient for use in FromApp since it provides a session ID for incoming messages + func SendToTarget(m Messagable, sessionID SessionID) error + +*/ +package quickfix diff --git a/vendor/github.com/quickfixgo/quickfix/enum/begin_string.go b/vendor/github.com/quickfixgo/quickfix/enum/begin_string.go new file mode 100644 index 0000000..d8a2820 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/enum/begin_string.go @@ -0,0 +1,11 @@ +package enum + +//FIX BeginString string values +const ( + BeginStringFIX40 = "FIX.4.0" + BeginStringFIX41 = "FIX.4.1" + BeginStringFIX42 = "FIX.4.2" + BeginStringFIX43 = "FIX.4.3" + BeginStringFIX44 = "FIX.4.4" + BeginStringFIXT11 = "FIXT.1.1" +) diff --git a/vendor/github.com/quickfixgo/quickfix/enum/enum.go b/vendor/github.com/quickfixgo/quickfix/enum/enum.go new file mode 100644 index 0000000..6e62a50 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/enum/enum.go @@ -0,0 +1,2 @@ +//Package enum declares standard FIX enum values. +package enum diff --git a/vendor/github.com/quickfixgo/quickfix/enum/enums.generated.go b/vendor/github.com/quickfixgo/quickfix/enum/enums.generated.go new file mode 100644 index 0000000..4ed0bc4 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/enum/enums.generated.go @@ -0,0 +1,4598 @@ +package enum + +//Enum values for AccountType +const ( + AccountType_ACCOUNT_IS_CARRIED_ON_CUSTOMER_SIDE_OF_THE_BOOKS = "1" + AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS = "2" + AccountType_HOUSE_TRADER = "3" + AccountType_FLOOR_TRADER = "4" + AccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED = "6" + AccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED = "7" + AccountType_JOINT_BACK_OFFICE_ACCOUNT = "8" +) + +//Enum values for AcctIDSource +const ( + AcctIDSource_BIC = "1" + AcctIDSource_SID_CODE = "2" + AcctIDSource_TFM = "3" + AcctIDSource_OMGEO = "4" + AcctIDSource_DTCC_CODE = "5" + AcctIDSource_OTHER = "99" +) + +//Enum values for Adjustment +const ( + Adjustment_CANCEL = "1" + Adjustment_ERROR = "2" + Adjustment_CORRECTION = "3" +) + +//Enum values for AdjustmentType +const ( + AdjustmentType_PROCESS_REQUEST_AS_MARGIN_DISPOSITION = "0" + AdjustmentType_DELTA_PLUS = "1" + AdjustmentType_DELTA_MINUS = "2" + AdjustmentType_FINAL = "3" +) + +//Enum values for AdvSide +const ( + AdvSide_BUY = "B" + AdvSide_SELL = "S" + AdvSide_TRADE = "T" + AdvSide_CROSS = "X" +) + +//Enum values for AdvTransType +const ( + AdvTransType_CANCEL = "C" + AdvTransType_NEW = "N" + AdvTransType_REPLACE = "R" +) + +//Enum values for AffirmStatus +const ( + AffirmStatus_RECEIVED = "1" + AffirmStatus_CONFIRM_REJECTED_IE_NOT_AFFIRMED = "2" + AffirmStatus_AFFIRMED = "3" +) + +//Enum values for AggregatedBook +const ( + AggregatedBook_NO = "N" + AggregatedBook_YES = "Y" +) + +//Enum values for AggressorIndicator +const ( + AggressorIndicator_NO = "N" + AggressorIndicator_YES = "Y" +) + +//Enum values for AllocAccountType +const ( + AllocAccountType_ACCOUNT_IS_CARRIED_PN_CUSTOMER_SIDE_OF_BOOKS = "1" + AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS = "2" + AllocAccountType_HOUSE_TRADER = "3" + AllocAccountType_FLOOR_TRADER = "4" + AllocAccountType_ACCOUNT_IS_CARRIED_ON_NON_CUSTOMER_SIDE_OF_BOOKS_AND_IS_CROSS_MARGINED = "6" + AllocAccountType_ACCOUNT_IS_HOUSE_TRADER_AND_IS_CROSS_MARGINED = "7" + AllocAccountType_JOINT_BACK_OFFICE_ACCOUNT = "8" +) + +//Enum values for AllocCancReplaceReason +const ( + AllocCancReplaceReason_ORIGINAL_DETAILS_INCOMPLETE_INCORRECT = "1" + AllocCancReplaceReason_CHANGE_IN_UNDERLYING_ORDER_DETAILS = "2" + AllocCancReplaceReason_OTHER = "99" +) + +//Enum values for AllocHandlInst +const ( + AllocHandlInst_MATCH = "1" + AllocHandlInst_FORWARD = "2" + AllocHandlInst_FORWARD_AND_MATCH = "3" +) + +//Enum values for AllocIntermedReqType +const ( + AllocIntermedReqType_PENDING_ACCEPT = "1" + AllocIntermedReqType_PENDING_RELEASE = "2" + AllocIntermedReqType_PENDING_REVERSAL = "3" + AllocIntermedReqType_ACCEPT = "4" + AllocIntermedReqType_BLOCK_LEVEL_REJECT = "5" + AllocIntermedReqType_ACCOUNT_LEVEL_REJECT = "6" +) + +//Enum values for AllocLinkType +const ( + AllocLinkType_FX_NETTING = "0" + AllocLinkType_FX_SWAP = "1" +) + +//Enum values for AllocMethod +const ( + AllocMethod_AUTOMATIC = "1" + AllocMethod_GUARANTOR = "2" + AllocMethod_MANUAL = "3" +) + +//Enum values for AllocNoOrdersType +const ( + AllocNoOrdersType_NOT_SPECIFIED = "0" + AllocNoOrdersType_EXPLICIT_LIST_PROVIDED = "1" +) + +//Enum values for AllocPositionEffect +const ( + AllocPositionEffect_CLOSE = "C" + AllocPositionEffect_FIFO = "F" + AllocPositionEffect_OPEN = "O" + AllocPositionEffect_ROLLED = "R" +) + +//Enum values for AllocRejCode +const ( + AllocRejCode_UNKNOWN_ACCOUNT = "0" + AllocRejCode_INCORRECT_QUANTITY = "1" + AllocRejCode_UNKNOWN_OR_STALE_EXECID = "10" + AllocRejCode_MISMATCHED_DATA = "11" + AllocRejCode_UNKNOWN_CLORDID = "12" + AllocRejCode_WAREHOUSE_REQUEST_REJECTED = "13" + AllocRejCode_INCORRECT_AVERAGEG_PRICE = "2" + AllocRejCode_UNKNOWN_EXECUTING_BROKER_MNEMONIC = "3" + AllocRejCode_COMMISSION_DIFFERENCE = "4" + AllocRejCode_UNKNOWN_ORDERID = "5" + AllocRejCode_UNKNOWN_LISTID = "6" + AllocRejCode_OTHER_7 = "7" + AllocRejCode_INCORRECT_ALLOCATED_QUANTITY = "8" + AllocRejCode_CALCULATION_DIFFERENCE = "9" + AllocRejCode_OTHER_99 = "99" +) + +//Enum values for AllocReportType +const ( + AllocReportType_REJECT = "10" + AllocReportType_ACCEPT_PENDING = "11" + AllocReportType_COMPLETE = "12" + AllocReportType_REVERSE_PENDING = "14" + AllocReportType_PRELIMINARY_REQUEST_TO_INTERMEDIARY = "2" + AllocReportType_SELLSIDE_CALCULATED_USING_PRELIMINARY = "3" + AllocReportType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY = "4" + AllocReportType_WAREHOUSE_RECAP = "5" + AllocReportType_REQUEST_TO_INTERMEDIARY = "8" + AllocReportType_ACCEPT = "9" +) + +//Enum values for AllocSettlInstType +const ( + AllocSettlInstType_USE_DEFAULT_INSTRUCTIONS = "0" + AllocSettlInstType_DERIVE_FROM_PARAMETERS_PROVIDED = "1" + AllocSettlInstType_FULL_DETAILS_PROVIDED = "2" + AllocSettlInstType_SSI_DB_IDS_PROVIDED = "3" + AllocSettlInstType_PHONE_FOR_INSTRUCTIONS = "4" +) + +//Enum values for AllocStatus +const ( + AllocStatus_ACCEPTED = "0" + AllocStatus_BLOCK_LEVEL_REJECT = "1" + AllocStatus_ACCOUNT_LEVEL_REJECT = "2" + AllocStatus_RECEIVED = "3" + AllocStatus_INCOMPLETE = "4" + AllocStatus_REJECTED_BY_INTERMEDIARY = "5" + AllocStatus_ALLOCATION_PENDING = "6" + AllocStatus_REVERSED = "7" +) + +//Enum values for AllocTransType +const ( + AllocTransType_NEW = "0" + AllocTransType_REPLACE = "1" + AllocTransType_CANCEL = "2" + AllocTransType_PRELIMINARY = "3" + AllocTransType_CALCULATED = "4" + AllocTransType_CALCULATED_WITHOUT_PRELIMINARY = "5" + AllocTransType_REVERSAL = "6" +) + +//Enum values for AllocType +const ( + AllocType_CALCULATED = "1" + AllocType_REJECT = "10" + AllocType_ACCEPT_PENDING = "11" + AllocType_INCOMPLETE_GROUP = "12" + AllocType_COMPLETE_GROUP = "13" + AllocType_REVERSAL_PENDING = "14" + AllocType_PRELIMINARY = "2" + AllocType_SELLSIDE_CALCULATED_USING_PRELIMINARY = "3" + AllocType_SELLSIDE_CALCULATED_WITHOUT_PRELIMINARY = "4" + AllocType_READY_TO_BOOK = "5" + AllocType_BUYSIDE_READY_TO_BOOK = "6" + AllocType_WAREHOUSE_INSTRUCTION = "7" + AllocType_REQUEST_TO_INTERMEDIARY = "8" + AllocType_ACCEPT = "9" +) + +//Enum values for ApplQueueAction +const ( + ApplQueueAction_NO_ACTION_TAKEN = "0" + ApplQueueAction_QUEUE_FLUSHED = "1" + ApplQueueAction_OVERLAY_LAST = "2" + ApplQueueAction_END_SESSION = "3" +) + +//Enum values for ApplQueueResolution +const ( + ApplQueueResolution_NO_ACTION_TAKEN = "0" + ApplQueueResolution_QUEUE_FLUSHED = "1" + ApplQueueResolution_OVERLAY_LAST = "2" + ApplQueueResolution_END_SESSION = "3" +) + +//Enum values for ApplReportType +const ( + ApplReportType_RESET_APPLSEQNUM_TO_NEW_VALUE_SPECIFIED_IN_APPLNEWSEQNUM = "0" + ApplReportType_REPORTS_THAT_THE_LAST_MESSAGE_HAS_BEEN_SENT_FOR_THE_APPLIDS_REFER_TO_REFAPPLLASTSEQNUM = "1" + ApplReportType_HEARTBEAT_MESSAGE_INDICATING_THAT_APPLICATION_IDENTIFIED_BY_REFAPPLID = "2" + ApplReportType_APPLICATION_MESSAGE_RE_SEND_COMPLETED = "3" +) + +//Enum values for ApplReqType +const ( + ApplReqType_RETRANSMISSION_OF_APPLICATION_MESSAGES_FOR_THE_SPECIFIED_APPLICATIONS = "0" + ApplReqType_SUBSCRIPTION_TO_THE_SPECIFIED_APPLICATIONS = "1" + ApplReqType_REQUEST_FOR_THE_LAST_APPLLASTSEQNUM_PUBLISHED_FOR_THE_SPECIFIED_APPLICATIONS = "2" + ApplReqType_REQUEST_VALID_SET_OF_APPLICATIONS = "3" + ApplReqType_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS = "4" + ApplReqType_CANCEL_RETRANSMISSION = "5" + ApplReqType_CANCEL_RETRANSMISSION_AND_UNSUBSCRIBE_TO_THE_SPECIFIED_APPLICATIONS = "6" +) + +//Enum values for ApplResponseError +const ( + ApplResponseError_APPLICATION_DOES_NOT_EXIST = "0" + ApplResponseError_MESSAGES_REQUESTED_ARE_NOT_AVAILABLE = "1" + ApplResponseError_USER_NOT_AUTHORIZED_FOR_APPLICATION = "2" +) + +//Enum values for ApplResponseType +const ( + ApplResponseType_REQUEST_SUCCESSFULLY_PROCESSED = "0" + ApplResponseType_APPLICATION_DOES_NOT_EXIST = "1" + ApplResponseType_MESSAGES_NOT_AVAILABLE = "2" +) + +//Enum values for ApplVerID +const ( + ApplVerID_FIX27 = "0" + ApplVerID_FIX30 = "1" + ApplVerID_FIX40 = "2" + ApplVerID_FIX41 = "3" + ApplVerID_FIX42 = "4" + ApplVerID_FIX43 = "5" + ApplVerID_FIX44 = "6" + ApplVerID_FIX50 = "7" + ApplVerID_FIX50SP1 = "8" + ApplVerID_FIX50SP2 = "9" +) + +//Enum values for AsOfIndicator +const ( + AsOfIndicator_FALSE = "0" + AsOfIndicator_TRUE = "1" +) + +//Enum values for AssignmentMethod +const ( + AssignmentMethod_PRO_RATA = "P" + AssignmentMethod_RANDOM = "R" +) + +//Enum values for AvgPxIndicator +const ( + AvgPxIndicator_NO_AVERAGE_PRICING = "0" + AvgPxIndicator_TRADE_IS_PART_OF_AN_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID = "1" + AvgPxIndicator_LAST_TRADE_IS_THE_AVERAGE_PRICE_GROUP_IDENTIFIED_BY_THE_TRADELINKID = "2" +) + +//Enum values for BasisPxType +const ( + BasisPxType_CLOSING_PRICE_AT_MORNINGN_SESSION = "2" + BasisPxType_CLOSING_PRICE = "3" + BasisPxType_CURRENT_PRICE = "4" + BasisPxType_SQ = "5" + BasisPxType_VWAP_THROUGH_A_DAY = "6" + BasisPxType_VWAP_THROUGH_A_MORNING_SESSION = "7" + BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION = "8" + BasisPxType_VWAP_THROUGH_A_DAY_EXCEPT_YORI = "9" + BasisPxType_VWAP_THROUGH_A_MORNING_SESSION_EXCEPT_YORI = "A" + BasisPxType_VWAP_THROUGH_AN_AFTERNOON_SESSION_EXCEPT_YORI = "B" + BasisPxType_STRIKE = "C" + BasisPxType_OPEN = "D" + BasisPxType_OTHERS = "Z" +) + +//Enum values for Benchmark +const ( + Benchmark_CURVE = "1" + Benchmark_5YR = "2" + Benchmark_OLD5 = "3" + Benchmark_10YR = "4" + Benchmark_OLD10 = "5" + Benchmark_30YR = "6" + Benchmark_OLD30 = "7" + Benchmark_3MOLIBOR = "8" + Benchmark_6MOLIBOR = "9" +) + +//Enum values for BenchmarkCurveName +const ( + BenchmarkCurveName_EONIA = "EONIA" + BenchmarkCurveName_EUREPO = "EUREPO" + BenchmarkCurveName_EURIBOR = "Euribor" + BenchmarkCurveName_FUTURESWAP = "FutureSWAP" + BenchmarkCurveName_LIBID = "LIBID" + BenchmarkCurveName_LIBOR = "LIBOR" + BenchmarkCurveName_MUNIAAA = "MuniAAA" + BenchmarkCurveName_OTHER = "OTHER" + BenchmarkCurveName_PFANDBRIEFE = "Pfandbriefe" + BenchmarkCurveName_SONIA = "SONIA" + BenchmarkCurveName_SWAP = "SWAP" + BenchmarkCurveName_TREASURY = "Treasury" +) + +//Enum values for BidDescriptorType +const ( + BidDescriptorType_SECTOR = "1" + BidDescriptorType_COUNTRY = "2" + BidDescriptorType_INDEX = "3" +) + +//Enum values for BidRequestTransType +const ( + BidRequestTransType_CANCEL = "C" + BidRequestTransType_NO = "N" +) + +//Enum values for BidTradeType +const ( + BidTradeType_AGENCY = "A" + BidTradeType_VWAP_GUARANTEE = "G" + BidTradeType_GUARANTEED_CLOSE = "J" + BidTradeType_RISK_TRADE = "R" +) + +//Enum values for BidType +const ( + BidType_NON_DISCLOSED_STYLE = "1" + BidType_DISCLOSED_SYTLE = "2" + BidType_NO_BIDDING_PROCESS = "3" +) + +//Enum values for BookingType +const ( + BookingType_REGULAR_BOOKING = "0" + BookingType_CFD = "1" + BookingType_TOTAL_RETURN_SWAP = "2" +) + +//Enum values for BookingUnit +const ( + BookingUnit_EACH_PARTIAL_EXECUTION_IS_A_BOOKABLE_UNIT = "0" + BookingUnit_AGGREGATE_PARTIAL_EXECUTIONS_ON_THIS_ORDER_AND_BOOK_ONE_TRADE_PER_ORDER = "1" + BookingUnit_AGGREGATE_EXECUTIONS_FOR_THIS_SYMBOL_SIDE_AND_SETTLEMENT_DATE = "2" +) + +//Enum values for BusinessRejectReason +const ( + BusinessRejectReason_OTHER = "0" + BusinessRejectReason_UNKNOWN_ID = "1" + BusinessRejectReason_INVALID_PRICE_INCREMENT = "18" + BusinessRejectReason_UNKNOWN_SECURITY = "2" + BusinessRejectReason_UNSUPPORTED_MESSAGE_TYPE = "3" + BusinessRejectReason_APPLICATION_NOT_AVAILABLE = "4" + BusinessRejectReason_CONDITIONALLY_REQUIRED_FIELD_MISSING = "5" + BusinessRejectReason_NOT_AUTHORIZED = "6" + BusinessRejectReason_DELIVERTO_FIRM_NOT_AVAILABLE_AT_THIS_TIME = "7" +) + +//Enum values for CPProgram +const ( + CPProgram_3 = "1" + CPProgram_4 = "2" + CPProgram_OTHER = "99" +) + +//Enum values for CancellationRights +const ( + CancellationRights_NO_M = "M" + CancellationRights_NO_N = "N" + CancellationRights_NO_O = "O" + CancellationRights_YES = "Y" +) + +//Enum values for CashMargin +const ( + CashMargin_CASH = "1" + CashMargin_MARGIN_OPEN = "2" + CashMargin_MARGIN_CLOSE = "3" +) + +//Enum values for ClearingFeeIndicator +const ( + ClearingFeeIndicator_1ST_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT = "1" + ClearingFeeIndicator_2ND_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT = "2" + ClearingFeeIndicator_3RD_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT = "3" + ClearingFeeIndicator_4TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT = "4" + ClearingFeeIndicator_5TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT = "5" + ClearingFeeIndicator_6TH_YEAR_DELEGATE_TRADING_FOR_OWN_ACCOUNT = "9" + ClearingFeeIndicator_CBOE_MEMBER = "B" + ClearingFeeIndicator_NON_MEMBER_AND_CUSTOMER = "C" + ClearingFeeIndicator_EQUITY_MEMBER_AND_CLEARING_MEMBER = "E" + ClearingFeeIndicator_FULL_AND_ASSOCIATE_MEMBER_TRADING_FOR_OWN_ACCOUNT_AND_AS_FLOOR_BROKERS = "F" + ClearingFeeIndicator_106H_AND_106J_FIRMS = "H" + ClearingFeeIndicator_GIM_IDEM_AND_COM_MEMBERSHIP_INTEREST_HOLDERS = "I" + ClearingFeeIndicator_LESSEE_106F_EMPLOYEES = "L" + ClearingFeeIndicator_ALL_OTHER_OWNERSHIP_TYPES = "M" +) + +//Enum values for ClearingInstruction +const ( + ClearingInstruction_PROCESS_NORMALLY = "0" + ClearingInstruction_EXCLUDE_FROM_ALL_NETTING = "1" + ClearingInstruction_AUTOMATIC_GIVE_UP_MODE = "10" + ClearingInstruction_QUALIFIED_SERVICE_REPRESENTATIVE_QSR = "11" + ClearingInstruction_CUSTOMER_TRADE = "12" + ClearingInstruction_SELF_CLEARING = "13" + ClearingInstruction_BILATERAL_NETTING_ONLY = "2" + ClearingInstruction_EX_CLEARING = "3" + ClearingInstruction_SPECIAL_TRADE = "4" + ClearingInstruction_MULTILATERAL_NETTING = "5" + ClearingInstruction_CLEAR_AGAINST_CENTRAL_COUNTERPARTY = "6" + ClearingInstruction_EXCLUDE_FROM_CENTRAL_COUNTERPARTY = "7" + ClearingInstruction_MANUAL_MODE = "8" + ClearingInstruction_AUTOMATIC_POSTING_MODE = "9" +) + +//Enum values for CollAction +const ( + CollAction_RETAIN = "0" + CollAction_ADD = "1" + CollAction_REMOVE = "2" +) + +//Enum values for CollApplType +const ( + CollApplType_SPECIFIC_DEPOSIT = "0" + CollApplType_GENERAL = "1" +) + +//Enum values for CollAsgnReason +const ( + CollAsgnReason_INITIAL = "0" + CollAsgnReason_SCHEDULED = "1" + CollAsgnReason_TIME_WARNING = "2" + CollAsgnReason_MARGIN_DEFICIENCY = "3" + CollAsgnReason_MARGIN_EXCESS = "4" + CollAsgnReason_FORWARD_COLLATERAL_DEMAND = "5" + CollAsgnReason_EVENT_OF_DEFAULT = "6" + CollAsgnReason_ADVERSE_TAX_EVENT = "7" +) + +//Enum values for CollAsgnRejectReason +const ( + CollAsgnRejectReason_UNKNOWN_DEAL = "0" + CollAsgnRejectReason_UNKNOWN_OR_INVALID_INSTRUMENT = "1" + CollAsgnRejectReason_UNAUTHORIZED_TRANSACTION = "2" + CollAsgnRejectReason_INSUFFICIENT_COLLATERAL = "3" + CollAsgnRejectReason_INVALID_TYPE_OF_COLLATERAL = "4" + CollAsgnRejectReason_EXCESSIVE_SUBSTITUTION = "5" + CollAsgnRejectReason_OTHER = "99" +) + +//Enum values for CollAsgnRespType +const ( + CollAsgnRespType_RECEIVED = "0" + CollAsgnRespType_ACCEPTED = "1" + CollAsgnRespType_DECLINED = "2" + CollAsgnRespType_REJECTED = "3" +) + +//Enum values for CollAsgnTransType +const ( + CollAsgnTransType_NEW = "0" + CollAsgnTransType_REPLACE = "1" + CollAsgnTransType_CANCEL = "2" + CollAsgnTransType_RELEASE = "3" + CollAsgnTransType_REVERSE = "4" +) + +//Enum values for CollInquiryQualifier +const ( + CollInquiryQualifier_TRADE_DATE = "0" + CollInquiryQualifier_GC_INSTRUMENT = "1" + CollInquiryQualifier_COLLATERAL_INSTRUMENT = "2" + CollInquiryQualifier_SUBSTITUTION_ELIGIBLE = "3" + CollInquiryQualifier_NOT_ASSIGNED = "4" + CollInquiryQualifier_PARTIALLY_ASSIGNED = "5" + CollInquiryQualifier_FULLY_ASSIGNED = "6" + CollInquiryQualifier_OUTSTANDING_TRADES = "7" +) + +//Enum values for CollInquiryResult +const ( + CollInquiryResult_SUCCESSFUL = "0" + CollInquiryResult_INVALID_OR_UNKNOWN_INSTRUMENT = "1" + CollInquiryResult_INVALID_OR_UNKNOWN_COLLATERAL_TYPE = "2" + CollInquiryResult_INVALID_PARTIES = "3" + CollInquiryResult_INVALID_TRANSPORT_TYPE_REQUESTED = "4" + CollInquiryResult_INVALID_DESTINATION_REQUESTED = "5" + CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_TRADE_SPECIFIED = "6" + CollInquiryResult_NO_COLLATERAL_FOUND_FOR_THE_ORDER_SPECIFIED = "7" + CollInquiryResult_COLLATERAL_INQUIRY_TYPE_NOT_SUPPORTED = "8" + CollInquiryResult_UNAUTHORIZED_FOR_COLLATERAL_INQUIRY = "9" + CollInquiryResult_OTHER = "99" +) + +//Enum values for CollInquiryStatus +const ( + CollInquiryStatus_ACCEPTED = "0" + CollInquiryStatus_ACCEPTED_WITH_WARNINGS = "1" + CollInquiryStatus_COMPLETED = "2" + CollInquiryStatus_COMPLETED_WITH_WARNINGS = "3" + CollInquiryStatus_REJECTED = "4" +) + +//Enum values for CollStatus +const ( + CollStatus_UNASSIGNED = "0" + CollStatus_PARTIALLY_ASSIGNED = "1" + CollStatus_ASSIGNMENT_PROPOSED = "2" + CollStatus_ASSIGNED = "3" + CollStatus_CHALLENGED = "4" +) + +//Enum values for CommType +const ( + CommType_PER_UNIT = "1" + CommType_PERCENT = "2" + CommType_ABSOLUTE = "3" + CommType_PERCENTAGE_WAIVED_4 = "4" + CommType_PERCENTAGE_WAIVED_5 = "5" + CommType_POINTS_PER_BOND_OR_CONTRACT = "6" +) + +//Enum values for ComplexEventCondition +const ( + ComplexEventCondition_AND = "1" + ComplexEventCondition_OR = "2" +) + +//Enum values for ComplexEventPriceBoundaryMethod +const ( + ComplexEventPriceBoundaryMethod_LESS_THAN_COMPLEXEVENTPRICE = "1" + ComplexEventPriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE = "2" + ComplexEventPriceBoundaryMethod_EQUAL_TO_COMPLEXEVENTPRICE = "3" + ComplexEventPriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_COMPLEXEVENTPRICE = "4" + ComplexEventPriceBoundaryMethod_GREATER_THAN_COMPLEXEVENTPRICE = "5" +) + +//Enum values for ComplexEventPriceTimeType +const ( + ComplexEventPriceTimeType_EXPIRATION = "1" + ComplexEventPriceTimeType_IMMEDIATE = "2" + ComplexEventPriceTimeType_SPECIFIED_DATE_TIME = "3" +) + +//Enum values for ComplexEventType +const ( + ComplexEventType_CAPPED = "1" + ComplexEventType_TRIGGER = "2" + ComplexEventType_KNOCK_IN_UP = "3" + ComplexEventType_KOCK_IN_DOWN = "4" + ComplexEventType_KNOCK_OUT_UP = "5" + ComplexEventType_KNOCK_OUT_DOWN = "6" + ComplexEventType_UNDERLYING = "7" + ComplexEventType_RESET_BARRIER = "8" + ComplexEventType_ROLLING_BARRIER = "9" +) + +//Enum values for ConfirmRejReason +const ( + ConfirmRejReason_MISMATCHED_ACCOUNT = "1" + ConfirmRejReason_MISSING_SETTLEMENT_INSTRUCTIONS = "2" + ConfirmRejReason_OTHER = "99" +) + +//Enum values for ConfirmStatus +const ( + ConfirmStatus_RECEIVED = "1" + ConfirmStatus_MISMATCHED_ACCOUNT = "2" + ConfirmStatus_MISSING_SETTLEMENT_INSTRUCTIONS = "3" + ConfirmStatus_CONFIRMED = "4" + ConfirmStatus_REQUEST_REJECTED = "5" +) + +//Enum values for ConfirmTransType +const ( + ConfirmTransType_NEW = "0" + ConfirmTransType_REPLACE = "1" + ConfirmTransType_CANCEL = "2" +) + +//Enum values for ConfirmType +const ( + ConfirmType_STATUS = "1" + ConfirmType_CONFIRMATION = "2" + ConfirmType_CONFIRMATION_REQUEST_REJECTED = "3" +) + +//Enum values for ContAmtType +const ( + ContAmtType_COMMISSION_AMOUNT = "1" + ContAmtType_EXIT_CHARGE_PERCENT = "10" + ContAmtType_FUND_BASED_RENEWAL_COMMISSION_PERCENT = "11" + ContAmtType_PROJECTED_FUND_VALUE = "12" + ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_13 = "13" + ContAmtType_FUND_BASED_RENEWAL_COMMISSION_AMOUNT_14 = "14" + ContAmtType_NET_SETTLEMENT_AMOUNT = "15" + ContAmtType_COMMISSION_PERCENT = "2" + ContAmtType_INITIAL_CHARGE_AMOUNT = "3" + ContAmtType_INITIAL_CHARGE_PERCENT = "4" + ContAmtType_DISCOUNT_AMOUNT = "5" + ContAmtType_DISCOUNT_PERCENT = "6" + ContAmtType_DILUTION_LEVY_AMOUNT = "7" + ContAmtType_DILUTION_LEVY_PERCENT = "8" + ContAmtType_EXIT_CHARGE_AMOUNT = "9" +) + +//Enum values for ContingencyType +const ( + ContingencyType_ONE_CANCELS_THE_OTHER = "1" + ContingencyType_ONE_TRIGGERS_THE_OTHER = "2" + ContingencyType_ONE_UPDATES_THE_OTHER_3 = "3" + ContingencyType_ONE_UPDATES_THE_OTHER_4 = "4" +) + +//Enum values for ContractMultiplierUnit +const ( + ContractMultiplierUnit_SHARES = "0" + ContractMultiplierUnit_HOURS = "1" + ContractMultiplierUnit_DAYS = "2" +) + +//Enum values for CorporateAction +const ( + CorporateAction_EX_DIVIDEND = "A" + CorporateAction_EX_DISTRIBUTION = "B" + CorporateAction_EX_RIGHTS = "C" + CorporateAction_NEW = "D" + CorporateAction_EX_INTEREST = "E" + CorporateAction_CASH_DIVIDEND = "F" + CorporateAction_STOCK_DIVIDEND = "G" + CorporateAction_NON_INTEGER_STOCK_SPLIT = "H" + CorporateAction_REVERSE_STOCK_SPLIT = "I" + CorporateAction_STANDARD_INTEGER_STOCK_SPLIT = "J" + CorporateAction_POSITION_CONSOLIDATION = "K" + CorporateAction_LIQUIDATION_REORGANIZATION = "L" + CorporateAction_MERGER_REORGANIZATION = "M" + CorporateAction_RIGHTS_OFFERING = "N" + CorporateAction_SHAREHOLDER_MEETING = "O" + CorporateAction_SPINOFF = "P" + CorporateAction_TENDER_OFFER = "Q" + CorporateAction_WARRANT = "R" + CorporateAction_SPECIAL_ACTION = "S" + CorporateAction_SYMBOL_CONVERSION = "T" + CorporateAction_CUSIP = "U" + CorporateAction_LEAP_ROLLOVER = "V" + CorporateAction_SUCCESSION_EVENT = "W" +) + +//Enum values for CoveredOrUncovered +const ( + CoveredOrUncovered_COVERED = "0" + CoveredOrUncovered_UNCOVERED = "1" +) + +//Enum values for CrossPrioritization +const ( + CrossPrioritization_NONE = "0" + CrossPrioritization_BUY_SIDE_IS_PRIORITIZED = "1" + CrossPrioritization_SELL_SIDE_IS_PRIORITIZED = "2" +) + +//Enum values for CrossType +const ( + CrossType_CROSS_AON = "1" + CrossType_CROSS_IOC = "2" + CrossType_CROSS_ONE_SIDE = "3" + CrossType_CROSS_SAME_PRICE = "4" +) + +//Enum values for CustOrderCapacity +const ( + CustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT = "1" + CustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT = "2" + CustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER = "3" + CustOrderCapacity_ALL_OTHER = "4" +) + +//Enum values for CustOrderHandlingInst +const ( + CustOrderHandlingInst_ADD_ON_ORDER = "ADD" + CustOrderHandlingInst_ALL_OR_NONE = "AON" + CustOrderHandlingInst_CASH_NOT_HELD = "CNH" + CustOrderHandlingInst_DIRECTED_ORDER = "DIR" + CustOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION = "E.W" + CustOrderHandlingInst_FILL_OR_KILL = "FOK" + CustOrderHandlingInst_IMBALANCE_ONLY = "IO" + CustOrderHandlingInst_IMMEDIATE_OR_CANCEL = "IOC" + CustOrderHandlingInst_LIMIT_ON_CLOSE = "LOC" + CustOrderHandlingInst_LIMIT_ON_OPEN = "LOO" + CustOrderHandlingInst_MARKET_AT_CLOSE = "MAC" + CustOrderHandlingInst_MARKET_AT_OPEN = "MAO" + CustOrderHandlingInst_MARKET_ON_CLOSE = "MOC" + CustOrderHandlingInst_MARKET_ON_OPEN = "MOO" + CustOrderHandlingInst_MINIMUM_QUANTITY = "MQT" + CustOrderHandlingInst_NOT_HELD = "NH" + CustOrderHandlingInst_OVER_THE_DAY = "OVD" + CustOrderHandlingInst_PEGGED = "PEG" + CustOrderHandlingInst_RESERVE_SIZE_ORDER = "RSV" + CustOrderHandlingInst_STOP_STOCK_TRANSACTION = "S.W" + CustOrderHandlingInst_SCALE = "SCL" + CustOrderHandlingInst_TIME_ORDER = "TMO" + CustOrderHandlingInst_TRAILING_STOP = "TS" + CustOrderHandlingInst_WORK = "WRK" +) + +//Enum values for CustomerOrFirm +const ( + CustomerOrFirm_CUSTOMER = "0" + CustomerOrFirm_FIRM = "1" +) + +//Enum values for CxlRejReason +const ( + CxlRejReason_TOO_LATE_TO_CANCEL = "0" + CxlRejReason_UNKNOWN_ORDER = "1" + CxlRejReason_INVALID_PRICE_INCREMENT = "18" + CxlRejReason_BROKER = "2" + CxlRejReason_ORDER_ALREADY_IN_PENDING_CANCEL_OR_PENDING_REPLACE_STATUS = "3" + CxlRejReason_UNABLE_TO_PROCESS_ORDER_MASS_CANCEL_REQUEST = "4" + CxlRejReason_ORIGORDMODTIME = "5" + CxlRejReason_DUPLICATE_CLORDID = "6" + CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE = "7" + CxlRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND = "8" + CxlRejReason_OTHER = "99" +) + +//Enum values for CxlRejResponseTo +const ( + CxlRejResponseTo_ORDER_CANCEL_REQUEST = "1" + CxlRejResponseTo_ORDER_CANCEL_REPLACE_REQUEST = "2" +) + +//Enum values for CxlType +const ( + CxlType_FULL_REMAINING_QUANTITY = "F" + CxlType_PARTIAL_CANCEL = "P" +) + +//Enum values for DKReason +const ( + DKReason_UNKNOWN_SYMBOL = "A" + DKReason_WRONG_SIDE = "B" + DKReason_QUANTITY_EXCEEDS_ORDER = "C" + DKReason_NO_MATCHING_ORDER = "D" + DKReason_PRICE_EXCEEDS_LIMIT = "E" + DKReason_CALCULATION_DIFFERENCE = "F" + DKReason_OTHER = "Z" +) + +//Enum values for DayBookingInst +const ( + DayBookingInst_CAN_TRIGGER_BOOKING_WITHOUT_REFERENCE_TO_THE_ORDER_INITIATOR = "0" + DayBookingInst_SPEAK_WITH_ORDER_INITIATOR_BEFORE_BOOKING = "1" + DayBookingInst_ACCUMULATE = "2" +) + +//Enum values for DealingCapacity +const ( + DealingCapacity_AGENT = "A" + DealingCapacity_PRINCIPAL = "P" + DealingCapacity_RISKLESS_PRINCIPAL = "R" +) + +//Enum values for DeleteReason +const ( + DeleteReason_CANCELLATION = "0" + DeleteReason_ERROR = "1" +) + +//Enum values for DeliveryForm +const ( + DeliveryForm_BOOK_ENTRY = "1" + DeliveryForm_BEARER = "2" +) + +//Enum values for DeliveryType +const ( + DeliveryType_VERSUS_PAYMENT_DELIVER = "0" + DeliveryType_FREE_DELIVER = "1" + DeliveryType_TRI_PARTY = "2" + DeliveryType_HOLD_IN_CUSTODY = "3" +) + +//Enum values for DerivativeSecurityListRequestType +const ( + DerivativeSecurityListRequestType_SYMBOL = "0" + DerivativeSecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE = "1" + DerivativeSecurityListRequestType_PRODUCT = "2" + DerivativeSecurityListRequestType_TRADINGSESSIONID = "3" + DerivativeSecurityListRequestType_ALL_SECURITIES = "4" + DerivativeSecurityListRequestType_UNDELYINGSYMBOL = "5" + DerivativeSecurityListRequestType_UNDERLYING_SECURITYTYPE_AND_OR_CFICODE = "6" + DerivativeSecurityListRequestType_UNDERLYING_PRODUCT = "7" + DerivativeSecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID = "8" +) + +//Enum values for DeskOrderHandlingInst +const ( + DeskOrderHandlingInst_ADD_ON_ORDER = "ADD" + DeskOrderHandlingInst_ALL_OR_NONE = "AON" + DeskOrderHandlingInst_CASH_NOT_HELD = "CNH" + DeskOrderHandlingInst_DIRECTED_ORDER = "DIR" + DeskOrderHandlingInst_EXCHANGE_FOR_PHYSICAL_TRANSACTION = "E.W" + DeskOrderHandlingInst_FILL_OR_KILL = "FOK" + DeskOrderHandlingInst_IMBALANCE_ONLY = "IO" + DeskOrderHandlingInst_IMMEDIATE_OR_CANCEL = "IOC" + DeskOrderHandlingInst_LIMIT_ON_CLOSE = "LOC" + DeskOrderHandlingInst_LIMIT_ON_OPEN = "LOO" + DeskOrderHandlingInst_MARKET_AT_CLOSE = "MAC" + DeskOrderHandlingInst_MARKET_AT_OPEN = "MAO" + DeskOrderHandlingInst_MARKET_ON_CLOSE = "MOC" + DeskOrderHandlingInst_MARKET_ON_OPEN = "MOO" + DeskOrderHandlingInst_MINIMUM_QUANTITY = "MQT" + DeskOrderHandlingInst_NOT_HELD = "NH" + DeskOrderHandlingInst_OVER_THE_DAY = "OVD" + DeskOrderHandlingInst_PEGGED = "PEG" + DeskOrderHandlingInst_RESERVE_SIZE_ORDER = "RSV" + DeskOrderHandlingInst_STOP_STOCK_TRANSACTION = "S.W" + DeskOrderHandlingInst_SCALE = "SCL" + DeskOrderHandlingInst_TIME_ORDER = "TMO" + DeskOrderHandlingInst_TRAILING_STOP = "TS" + DeskOrderHandlingInst_WORK = "WRK" +) + +//Enum values for DeskType +const ( + DeskType_AGENCY = "A" + DeskType_ARBITRAGE = "AR" + DeskType_DERIVATIVES = "D" + DeskType_INTERNATIONAL = "IN" + DeskType_INSTITUTIONAL = "IS" + DeskType_OTHER = "O" + DeskType_PREFERRED_TRADING = "PF" + DeskType_PROPRIETARY = "PR" + DeskType_PROGRAM_TRADING = "PT" + DeskType_SALES = "S" + DeskType_TRADING = "T" +) + +//Enum values for DeskTypeSource +const ( + DeskTypeSource_NASD_OATS = "1" +) + +//Enum values for DiscretionInst +const ( + DiscretionInst_RELATED_TO_DISPLAYED_PRICE = "0" + DiscretionInst_RELATED_TO_MARKET_PRICE = "1" + DiscretionInst_RELATED_TO_PRIMARY_PRICE = "2" + DiscretionInst_RELATED_TO_LOCAL_PRIMARY_PRICE = "3" + DiscretionInst_RELATED_TO_MIDPOINT_PRICE = "4" + DiscretionInst_RELATED_TO_LAST_TRADE_PRICE = "5" + DiscretionInst_RELATED_TO_VWAP = "6" + DiscretionInst_AVERAGE_PRICE_GUARANTEE = "7" +) + +//Enum values for DiscretionLimitType +const ( + DiscretionLimitType_OR_BETTER = "0" + DiscretionLimitType_STRICT = "1" + DiscretionLimitType_OR_WORSE = "2" +) + +//Enum values for DiscretionMoveType +const ( + DiscretionMoveType_FLOATING = "0" + DiscretionMoveType_FIXED = "1" +) + +//Enum values for DiscretionOffsetType +const ( + DiscretionOffsetType_PRICE = "0" + DiscretionOffsetType_BASIS_POINTS = "1" + DiscretionOffsetType_TICKS = "2" + DiscretionOffsetType_PRICE_TIER = "3" +) + +//Enum values for DiscretionRoundDirection +const ( + DiscretionRoundDirection_MORE_AGGRESSIVE = "1" + DiscretionRoundDirection_MORE_PASSIVE = "2" +) + +//Enum values for DiscretionScope +const ( + DiscretionScope_LOCAL = "1" + DiscretionScope_NATIONAL = "2" + DiscretionScope_GLOBAL = "3" + DiscretionScope_NATIONAL_EXCLUDING_LOCAL = "4" +) + +//Enum values for DisplayMethod +const ( + DisplayMethod_INITIAL = "1" + DisplayMethod_NEW = "2" + DisplayMethod_RANDOM = "3" + DisplayMethod_UNDISCLOSED = "4" +) + +//Enum values for DisplayWhen +const ( + DisplayWhen_IMMEDIATE = "1" + DisplayWhen_EXHAUST = "2" +) + +//Enum values for DistribPaymentMethod +const ( + DistribPaymentMethod_CREST = "1" + DistribPaymentMethod_BPAY = "10" + DistribPaymentMethod_HIGH_VALUE_CLEARING_SYSTEM_HVACS = "11" + DistribPaymentMethod_REINVEST_IN_FUND = "12" + DistribPaymentMethod_NSCC = "2" + DistribPaymentMethod_EUROCLEAR = "3" + DistribPaymentMethod_CLEARSTREAM = "4" + DistribPaymentMethod_CHEQUE = "5" + DistribPaymentMethod_TELEGRAPHIC_TRANSFER = "6" + DistribPaymentMethod_FED_WIRE = "7" + DistribPaymentMethod_DIRECT_CREDIT = "8" + DistribPaymentMethod_ACH_CREDIT = "9" +) + +//Enum values for DlvyInstType +const ( + DlvyInstType_CASH = "C" + DlvyInstType_SECURITIES = "S" +) + +//Enum values for DueToRelated +const ( + DueToRelated_NO = "N" + DueToRelated_YES = "Y" +) + +//Enum values for EmailType +const ( + EmailType_NEW = "0" + EmailType_REPLY = "1" + EmailType_ADMIN_REPLY = "2" +) + +//Enum values for EncryptMethod +const ( + EncryptMethod_NONE_OTHER = "0" + EncryptMethod_PKCS = "1" + EncryptMethod_DES = "2" + EncryptMethod_PKCS_DES = "3" + EncryptMethod_PGP_DES = "4" + EncryptMethod_PGP_DES_MD5 = "5" + EncryptMethod_PEM_DES_MD5 = "6" +) + +//Enum values for EventType +const ( + EventType_PUT = "1" + EventType_SWAP_ROLL_DATE = "10" + EventType_SWAP_NEXT_START_DATE = "11" + EventType_SWAP_NEXT_ROLL_DATE = "12" + EventType_FIRST_DELIVERY_DATE = "13" + EventType_LAST_DELIVERY_DATE = "14" + EventType_INITIAL_INVENTORY_DUE_DATE = "15" + EventType_FINAL_INVENTORY_DUE_DATE = "16" + EventType_FIRST_INTENT_DATE = "17" + EventType_LAST_INTENT_DATE = "18" + EventType_POSITION_REMOVAL_DATE = "19" + EventType_CALL = "2" + EventType_TENDER = "3" + EventType_SINKING_FUND_CALL = "4" + EventType_ACTIVATION = "5" + EventType_INACTIVIATION = "6" + EventType_LAST_ELIGIBLE_TRADE_DATE = "7" + EventType_SWAP_START_DATE = "8" + EventType_SWAP_END_DATE = "9" + EventType_OTHER = "99" +) + +//Enum values for ExDestination +const ( + ExDestination_NONE = "0" + ExDestination_POSIT = "4" +) + +//Enum values for ExDestinationIDSource +const ( + ExDestinationIDSource_BIC = "B" + ExDestinationIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER = "C" + ExDestinationIDSource_PROPRIETARY = "D" + ExDestinationIDSource_ISO_COUNTRY_CODE = "E" + ExDestinationIDSource_MIC = "G" +) + +//Enum values for ExchangeForPhysical +const ( + ExchangeForPhysical_NO = "N" + ExchangeForPhysical_YES = "Y" +) + +//Enum values for ExecAckStatus +const ( + ExecAckStatus_RECEIVED_NOT_YET_PROCESSED = "0" + ExecAckStatus_ACCEPTED = "1" + ExecAckStatus_DONT_KNOW = "2" +) + +//Enum values for ExecInst +const ( + ExecInst_STAY_ON_OFFER_SIDE = "0" + ExecInst_NOT_HELD = "1" + ExecInst_WORK = "2" + ExecInst_GO_ALONG = "3" + ExecInst_OVER_THE_DAY = "4" + ExecInst_HELD = "5" + ExecInst_PARTICIPANT_DONT_INITIATE = "6" + ExecInst_STRICT_SCALE = "7" + ExecInst_TRY_TO_SCALE = "8" + ExecInst_STAY_ON_BID_SIDE = "9" + ExecInst_NO_CROSS = "A" + ExecInst_OK_TO_CROSS = "B" + ExecInst_CALL_FIRST = "C" + ExecInst_PERCENT_OF_VOLUME = "D" + ExecInst_DO_NOT_INCREASE = "E" + ExecInst_DO_NOT_REDUCE = "F" + ExecInst_ALL_OR_NONE = "G" + ExecInst_REINSTATE_ON_SYSTEM_FAILURE = "H" + ExecInst_INSTITUTIONS_ONLY = "I" + ExecInst_REINSTATE_ON_TRADING_HALT = "J" + ExecInst_CANCEL_ON_TRADING_HALT = "K" + ExecInst_LAST_PEG = "L" + ExecInst_MID_PRICE_PEG = "M" + ExecInst_NON_NEGOTIABLE = "N" + ExecInst_OPENING_PEG = "O" + ExecInst_MARKET_PEG = "P" + ExecInst_CANCEL_ON_SYSTEM_FAILURE = "Q" + ExecInst_PRIMARY_PEG = "R" + ExecInst_SUSPEND = "S" + ExecInst_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER = "T" + ExecInst_CUSTOMER_DISPLAY_INSTRUCTION = "U" + ExecInst_NETTING = "V" + ExecInst_PEG_TO_VWAP = "W" + ExecInst_TRADE_ALONG = "X" + ExecInst_TRY_TO_STOP = "Y" + ExecInst_CANCEL_IF_NOT_BEST = "Z" + ExecInst_TRAILING_STOP_PEG = "a" + ExecInst_STRICT_LIMIT = "b" + ExecInst_IGNORE_PRICE_VALIDITY_CHECKS = "c" + ExecInst_PEG_TO_LIMIT_PRICE = "d" + ExecInst_WORK_TO_TARGET_STRATEGY = "e" + ExecInst_INTERMARKET_SWEEP = "f" + ExecInst_EXTERNAL_ROUTING_ALLOWED = "g" + ExecInst_EXTERNAL_ROUTING_NOT_ALLOWED = "h" + ExecInst_IMBALANCE_ONLY = "i" + ExecInst_SINGLE_EXECUTION_REQUESTED_FOR_BLOCK_TRADE = "j" + ExecInst_BEST_EXECUTION = "k" + ExecInst_SUSPEND_ON_SYSTEM_FAILURE = "l" + ExecInst_SUSPEND_ON_TRADING_HALT = "m" + ExecInst_REINSTATE_ON_CONNECTION_LOSS = "n" + ExecInst_CANCEL_ON_CONNECTION_LOSS = "o" + ExecInst_SUSPEND_ON_CONNECTION_LOSS = "p" + ExecInst_RELEASE_FROM_SUSPENSION = "q" + ExecInst_EXECUTE_AS_DELTA_NEUTRAL_USING_VOLATILITY_PROVIDED = "r" + ExecInst_EXECUTE_AS_DURATION_NEUTRAL = "s" + ExecInst_EXECUTE_AS_FX_NEUTRAL = "t" +) + +//Enum values for ExecPriceType +const ( + ExecPriceType_BID_PRICE = "B" + ExecPriceType_CREATION_PRICE = "C" + ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_PERCENT = "D" + ExecPriceType_CREATION_PRICE_PLUS_ADJUSTMENT_AMOUNT = "E" + ExecPriceType_OFFER_PRICE = "O" + ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_PERCENT = "P" + ExecPriceType_OFFER_PRICE_MINUS_ADJUSTMENT_AMOUNT = "Q" + ExecPriceType_SINGLE_PRICE = "S" +) + +//Enum values for ExecRestatementReason +const ( + ExecRestatementReason_GT_CORPORATE_ACTION = "0" + ExecRestatementReason_GT_RENEWAL = "1" + ExecRestatementReason_WAREHOUSE_RECAP = "10" + ExecRestatementReason_PEG_REFRESH = "11" + ExecRestatementReason_VERBAL_CHANGE = "2" + ExecRestatementReason_REPRICING_OF_ORDER = "3" + ExecRestatementReason_BROKER_OPTION = "4" + ExecRestatementReason_PARTIAL_DECLINE_OF_ORDERQTY = "5" + ExecRestatementReason_CANCEL_ON_TRADING_HALT = "6" + ExecRestatementReason_CANCEL_ON_SYSTEM_FAILURE = "7" + ExecRestatementReason_MARKET = "8" + ExecRestatementReason_CANCELED_NOT_BEST = "9" + ExecRestatementReason_OTHER = "99" +) + +//Enum values for ExecTransType +const ( + ExecTransType_NEW = "0" + ExecTransType_CANCEL = "1" + ExecTransType_CORRECT = "2" + ExecTransType_STATUS = "3" +) + +//Enum values for ExecType +const ( + ExecType_NEW = "0" + ExecType_PARTIAL_FILL = "1" + ExecType_FILL = "2" + ExecType_DONE_FOR_DAY = "3" + ExecType_CANCELED = "4" + ExecType_REPLACED = "5" + ExecType_PENDING_CANCEL = "6" + ExecType_STOPPED = "7" + ExecType_REJECTED = "8" + ExecType_SUSPENDED = "9" + ExecType_PENDING_NEW = "A" + ExecType_CALCULATED = "B" + ExecType_EXPIRED = "C" + ExecType_RESTATED = "D" + ExecType_PENDING_REPLACE = "E" + ExecType_TRADE = "F" + ExecType_TRADE_CORRECT = "G" + ExecType_TRADE_CANCEL = "H" + ExecType_ORDER_STATUS = "I" + ExecType_TRADE_IN_A_CLEARING_HOLD = "J" + ExecType_TRADE_HAS_BEEN_RELEASED_TO_CLEARING = "K" + ExecType_TRIGGERED_OR_ACTIVATED_BY_SYSTEM = "L" +) + +//Enum values for ExerciseMethod +const ( + ExerciseMethod_AUTOMATIC = "A" + ExerciseMethod_MANUAL = "M" +) + +//Enum values for ExerciseStyle +const ( + ExerciseStyle_EUROPEAN = "0" + ExerciseStyle_AMERICAN = "1" + ExerciseStyle_BERMUDA = "2" +) + +//Enum values for ExpType +const ( + ExpType_AUTO_EXERCISE = "1" + ExpType_NON_AUTO_EXERCISE = "2" + ExpType_FINAL_WILL_BE_EXERCISED = "3" + ExpType_CONTRARY_INTENTION = "4" + ExpType_DIFFERENCE = "5" +) + +//Enum values for ExpirationCycle +const ( + ExpirationCycle_EXPIRE_ON_TRADING_SESSION_CLOSE = "0" + ExpirationCycle_EXPIRE_ON_TRADING_SESSION_OPEN = "1" + ExpirationCycle_TRADING_ELIGIBILITY_EXPIRATION_SPECIFIED_IN_THE_DATE_AND_TIME_FIELDS_EVENTDATE = "2" +) + +//Enum values for ExpirationQtyType +const ( + ExpirationQtyType_AUTO_EXERCISE = "1" + ExpirationQtyType_NON_AUTO_EXERCISE = "2" + ExpirationQtyType_FINAL_WILL_BE_EXERCISED = "3" + ExpirationQtyType_CONTRARY_INTENTION = "4" + ExpirationQtyType_DIFFERENCE = "5" +) + +//Enum values for FinancialStatus +const ( + FinancialStatus_BANKRUPT = "1" + FinancialStatus_PENDING_DELISTING = "2" + FinancialStatus_RESTRICTED = "3" +) + +//Enum values for FlowScheduleType +const ( + FlowScheduleType_NERC_EASTERN_OFF_PEAK = "0" + FlowScheduleType_NERC_WESTERN_OFF_PEAK = "1" + FlowScheduleType_NERC_CALENDAR_ALL_DAYS_IN_MONTH = "2" + FlowScheduleType_NERC_EASTERN_PEAK = "3" + FlowScheduleType_NERC_WESTERN_PEAK = "4" +) + +//Enum values for ForexReq +const ( + ForexReq_NO = "N" + ForexReq_YES = "Y" +) + +//Enum values for FundRenewWaiv +const ( + FundRenewWaiv_NO = "N" + FundRenewWaiv_YES = "Y" +) + +//Enum values for FuturesValuationMethod +const ( + FuturesValuationMethod_PREMIUM_STYLE = "EQTY" + FuturesValuationMethod_FUTURES_STYLE_MARK_TO_MARKET = "FUT" + FuturesValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT = "FUTDA" +) + +//Enum values for GTBookingInst +const ( + GTBookingInst_BOOK_OUT_ALL_TRADES_ON_DAY_OF_EXECUTION = "0" + GTBookingInst_ACCUMULATE_EXECTUIONS_UNTIL_FORDER_IS_FILLED_OR_EXPIRES = "1" + GTBookingInst_ACCUMULATE_UNTIL_VERBALLLY_NOTIFIED_OTHERWISE = "2" +) + +//Enum values for GapFillFlag +const ( + GapFillFlag_NO = "N" + GapFillFlag_YES = "Y" +) + +//Enum values for HaltReasonChar +const ( + HaltReasonChar_NEWS_DISSEMINATION = "D" + HaltReasonChar_ORDER_INFLUX = "E" + HaltReasonChar_ORDER_IMBALANCE = "I" + HaltReasonChar_ADDITIONAL_INFORMATION = "M" + HaltReasonChar_NEW_PENDING = "P" + HaltReasonChar_EQUIPMENT_CHANGEOVER = "X" +) + +//Enum values for HaltReasonInt +const ( + HaltReasonInt_NEWS_DISSEMINATION = "0" + HaltReasonInt_ORDER_INFLUX = "1" + HaltReasonInt_ORDER_IMBALANCE = "2" + HaltReasonInt_ADDITIONAL_INFORMATION = "3" + HaltReasonInt_NEWS_PENDING = "4" + HaltReasonInt_EQUIPMENT_CHANGEOVER = "5" +) + +//Enum values for HandlInst +const ( + HandlInst_AUTOMATED_EXECUTION_ORDER_PRIVATE_NO_BROKER_INTERVENTION = "1" + HandlInst_AUTOMATED_EXECUTION_ORDER_PUBLIC_BROKER_INTERVENTION_OK = "2" + HandlInst_MANUAL_ORDER_BEST_EXECUTION = "3" +) + +//Enum values for IDSource +const ( + IDSource_CUSIP = "1" + IDSource_SEDOL = "2" + IDSource_QUIK = "3" + IDSource_ISIN_NUMBER = "4" + IDSource_RIC_CODE = "5" + IDSource_ISO_CURRENCY_CODE = "6" + IDSource_ISO_COUNTRY_CODE = "7" + IDSource_EXCHANGE_SYMBOL = "8" + IDSource_CONSOLIDATED_TAPE_ASSOCIATION = "9" +) + +//Enum values for IOINaturalFlag +const ( + IOINaturalFlag_NO = "N" + IOINaturalFlag_YES = "Y" +) + +//Enum values for IOIOthSvc +const ( + IOIOthSvc_AUTEX = "A" + IOIOthSvc_BRIDGE = "B" +) + +//Enum values for IOIQltyInd +const ( + IOIQltyInd_HIGH = "H" + IOIQltyInd_LOW = "L" + IOIQltyInd_MEDIUM = "M" +) + +//Enum values for IOIQty +const ( + IOIQty_1000000000 = "0" + IOIQty_LARGE = "L" + IOIQty_MEDIUM = "M" + IOIQty_SMALL = "S" + IOIQty_UNDISCLOSED_QUANTITY = "U" +) + +//Enum values for IOIQualifier +const ( + IOIQualifier_ALL_OR_NONE = "A" + IOIQualifier_MARKET_ON_CLOSE = "B" + IOIQualifier_AT_THE_CLOSE = "C" + IOIQualifier_VWAP = "D" + IOIQualifier_IN_TOUCH_WITH = "I" + IOIQualifier_LIMIT = "L" + IOIQualifier_MORE_BEHIND = "M" + IOIQualifier_AT_THE_OPEN = "O" + IOIQualifier_TAKING_A_POSITION = "P" + IOIQualifier_AT_THE_MARKET = "Q" + IOIQualifier_READY_TO_TRADE = "R" + IOIQualifier_PORTFOLIO_SHOWN = "S" + IOIQualifier_THROUGH_THE_DAY = "T" + IOIQualifier_VERSUS = "V" + IOIQualifier_INDICATION = "W" + IOIQualifier_CROSSING_OPPORTUNITY = "X" + IOIQualifier_AT_THE_MIDPOINT = "Y" + IOIQualifier_PRE_OPEN = "Z" +) + +//Enum values for IOIShares +const ( + IOIShares_LARGE = "L" + IOIShares_MEDIUM = "M" + IOIShares_SMALL = "S" +) + +//Enum values for IOITransType +const ( + IOITransType_CANCEL = "C" + IOITransType_NEW = "N" + IOITransType_REPLACE = "R" +) + +//Enum values for ImpliedMarketIndicator +const ( + ImpliedMarketIndicator_NOT_IMPLIED = "0" + ImpliedMarketIndicator_IMPLIED_IN = "1" + ImpliedMarketIndicator_IMPLIED_OUT = "2" + ImpliedMarketIndicator_BOTH_IMPLIED_IN_AND_IMPLIED_OUT = "3" +) + +//Enum values for InViewOfCommon +const ( + InViewOfCommon_NO = "N" + InViewOfCommon_YES = "Y" +) + +//Enum values for IncTaxInd +const ( + IncTaxInd_NET = "1" + IncTaxInd_GROSS = "2" +) + +//Enum values for IndividualAllocType +const ( + IndividualAllocType_SUB_ALLOCATE = "1" + IndividualAllocType_THIRD_PARTY_ALLOCATION = "2" +) + +//Enum values for InstrAttribType +const ( + InstrAttribType_FLAT = "1" + InstrAttribType_ORIGINAL_ISSUE_DISCOUNT = "10" + InstrAttribType_CALLABLE_PUTTABLE = "11" + InstrAttribType_ESCROWED_TO_MATURITY = "12" + InstrAttribType_ESCROWED_TO_REDEMPTION_DATE = "13" + InstrAttribType_PRE_REFUNDED = "14" + InstrAttribType_IN_DEFAULT = "15" + InstrAttribType_UNRATED = "16" + InstrAttribType_TAXABLE = "17" + InstrAttribType_INDEXED = "18" + InstrAttribType_SUBJECT_TO_ALTERNATIVE_MINIMUM_TAX = "19" + InstrAttribType_ZERO_COUPON = "2" + InstrAttribType_ORIGINAL_ISSUE_DISCOUNT_PRICE_SUPPLY_PRICE_IN_THE_INSTRATTRIBVALUE = "20" + InstrAttribType_CALLABLE_BELOW_MATURITY_VALUE = "21" + InstrAttribType_CALLABLE_WITHOUT_NOTICE_BY_MAIL_TO_HOLDER_UNLESS_REGISTERED = "22" + InstrAttribType_PRICE_TICK_RULES_FOR_SECURITY = "23" + InstrAttribType_TRADE_TYPE_ELIGIBILITY_DETAILS_FOR_SECURITY = "24" + InstrAttribType_INSTRUMENT_DENOMINATOR = "25" + InstrAttribType_INSTRUMENT_NUMERATOR = "26" + InstrAttribType_INSTRUMENT_PRICE_PRECISION = "27" + InstrAttribType_INSTRUMENT_STRIKE_PRICE = "28" + InstrAttribType_TRADEABLE_INDICATOR = "29" + InstrAttribType_INTEREST_BEARING = "3" + InstrAttribType_NO_PERIODIC_PAYMENTS = "4" + InstrAttribType_VARIABLE_RATE = "5" + InstrAttribType_LESS_FEE_FOR_PUT = "6" + InstrAttribType_STEPPED_COUPON = "7" + InstrAttribType_COUPON_PERIOD = "8" + InstrAttribType_WHEN_AND_IF_ISSUED = "9" + InstrAttribType_TEXT_SUPPLY_THE_TEXT_OF_THE_ATTRIBUTE_OR_DISCLAIMER_IN_THE_INSTRATTRIBVALUE = "99" +) + +//Enum values for InstrRegistry +const ( + InstrRegistry_CUSTODIAN = "BIC" + InstrRegistry_COUNTRY = "ISO" + InstrRegistry_PHYSICAL = "ZZ" +) + +//Enum values for LastCapacity +const ( + LastCapacity_AGENT = "1" + LastCapacity_CROSS_AS_AGENT = "2" + LastCapacity_CROSS_AS_PRINCIPAL = "3" + LastCapacity_PRINCIPAL = "4" +) + +//Enum values for LastFragment +const ( + LastFragment_NO = "N" + LastFragment_YES = "Y" +) + +//Enum values for LastLiquidityInd +const ( + LastLiquidityInd_ADDED_LIQUIDITY = "1" + LastLiquidityInd_REMOVED_LIQUIDITY = "2" + LastLiquidityInd_LIQUIDITY_ROUTED_OUT = "3" + LastLiquidityInd_AUCTION = "4" +) + +//Enum values for LastRptRequested +const ( + LastRptRequested_NO = "N" + LastRptRequested_YES = "Y" +) + +//Enum values for LegSwapType +const ( + LegSwapType_PAR_FOR_PAR = "1" + LegSwapType_MODIFIED_DURATION = "2" + LegSwapType_RISK = "4" + LegSwapType_PROCEEDS = "5" +) + +//Enum values for LegalConfirm +const ( + LegalConfirm_NO = "N" + LegalConfirm_YES = "Y" +) + +//Enum values for LiquidityIndType +const ( + LiquidityIndType_5_DAY_MOVING_AVERAGE = "1" + LiquidityIndType_20_DAY_MOVING_AVERAGE = "2" + LiquidityIndType_NORMAL_MARKET_SIZE = "3" + LiquidityIndType_OTHER = "4" +) + +//Enum values for ListExecInstType +const ( + ListExecInstType_IMMEDIATE = "1" + ListExecInstType_WAIT_FOR_EXECUT_INSTRUCTION = "2" + ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_3 = "3" + ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_4 = "4" + ListExecInstType_EXCHANGE_SWITCH_CIV_ORDER_5 = "5" +) + +//Enum values for ListMethod +const ( + ListMethod_PRE_LISTED_ONLY = "0" + ListMethod_USER_REQUESTED = "1" +) + +//Enum values for ListOrderStatus +const ( + ListOrderStatus_IN_BIDDING_PROCESS = "1" + ListOrderStatus_RECEIVED_FOR_EXECUTION = "2" + ListOrderStatus_EXECUTING = "3" + ListOrderStatus_CANCELLING = "4" + ListOrderStatus_ALERT = "5" + ListOrderStatus_ALL_DONE = "6" + ListOrderStatus_REJECT = "7" +) + +//Enum values for ListRejectReason +const ( + ListRejectReason_BROKER = "0" + ListRejectReason_UNSUPPORTED_ORDER_CHARACTERISTIC = "11" + ListRejectReason_EXCHANGE_CLOSED = "2" + ListRejectReason_TOO_LATE_TO_ENTER = "4" + ListRejectReason_UNKNOWN_ORDER = "5" + ListRejectReason_DUPLICATE_ORDER = "6" + ListRejectReason_OTHER = "99" +) + +//Enum values for ListStatusType +const ( + ListStatusType_ACK = "1" + ListStatusType_RESPONSE = "2" + ListStatusType_TIMED = "3" + ListStatusType_EXEC_STARTED = "4" + ListStatusType_ALL_DONE = "5" + ListStatusType_ALERT = "6" +) + +//Enum values for LocateReqd +const ( + LocateReqd_NO = "N" + LocateReqd_YES = "Y" +) + +//Enum values for LotType +const ( + LotType_ODD_LOT = "1" + LotType_ROUND_LOT = "2" + LotType_BLOCK_LOT = "3" + LotType_ROUND_LOT_BASED_UPON_UNITOFMEASURE = "4" +) + +//Enum values for MDBookType +const ( + MDBookType_TOP_OF_BOOK = "1" + MDBookType_PRICE_DEPTH = "2" + MDBookType_ORDER_DEPTH = "3" +) + +//Enum values for MDEntryType +const ( + MDEntryType_BID = "0" + MDEntryType_OFFER = "1" + MDEntryType_TRADE = "2" + MDEntryType_INDEX_VALUE = "3" + MDEntryType_OPENING_PRICE = "4" + MDEntryType_CLOSING_PRICE = "5" + MDEntryType_SETTLEMENT_PRICE = "6" + MDEntryType_TRADING_SESSION_HIGH_PRICE = "7" + MDEntryType_TRADING_SESSION_LOW_PRICE = "8" + MDEntryType_TRADING_SESSION_VWAP_PRICE = "9" + MDEntryType_IMBALANCE = "A" + MDEntryType_TRADE_VOLUME = "B" + MDEntryType_OPEN_INTEREST = "C" + MDEntryType_COMPOSITE_UNDERLYING_PRICE = "D" + MDEntryType_SIMULATED_SELL_PRICE = "E" + MDEntryType_SIMULATED_BUY_PRICE = "F" + MDEntryType_MARGIN_RATE = "G" + MDEntryType_MID_PRICE = "H" + MDEntryType_EMPTY_BOOK = "J" + MDEntryType_SETTLE_HIGH_PRICE = "K" + MDEntryType_SETTLE_LOW_PRICE = "L" + MDEntryType_PRIOR_SETTLE_PRICE = "M" + MDEntryType_SESSION_HIGH_BID = "N" + MDEntryType_SESSION_LOW_OFFER = "O" + MDEntryType_EARLY_PRICES = "P" + MDEntryType_AUCTION_CLEARING_PRICE = "Q" + MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS = "R" + MDEntryType_SWAP_VALUE_FACTOR = "S" + MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_LONG_POSITIONS = "T" + MDEntryType_DAILY_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS = "U" + MDEntryType_CUMULATIVE_VALUE_ADJUSTMENT_FOR_SHORT_POSITIONS = "V" + MDEntryType_FIXING_PRICE = "W" + MDEntryType_CASH_RATE = "X" + MDEntryType_RECOVERY_RATE = "Y" + MDEntryType_RECOVERY_RATE_FOR_LONG = "Z" + MDEntryType_RECOVERY_RATE_FOR_SHORT = "a" +) + +//Enum values for MDImplicitDelete +const ( + MDImplicitDelete_NO = "N" + MDImplicitDelete_YES = "Y" +) + +//Enum values for MDOriginType +const ( + MDOriginType_BOOK = "0" + MDOriginType_OFF_BOOK = "1" + MDOriginType_CROSS = "2" +) + +//Enum values for MDQuoteType +const ( + MDQuoteType_INDICATIVE = "0" + MDQuoteType_TRADEABLE = "1" + MDQuoteType_RESTRICTED_TRADEABLE = "2" + MDQuoteType_COUNTER = "3" + MDQuoteType_INDICATIVE_AND_TRADEABLE = "4" +) + +//Enum values for MDReqRejReason +const ( + MDReqRejReason_UNKNOWN_SYMBOL = "0" + MDReqRejReason_DUPLICATE_MDREQID = "1" + MDReqRejReason_INSUFFICIENT_BANDWIDTH = "2" + MDReqRejReason_INSUFFICIENT_PERMISSIONS = "3" + MDReqRejReason_UNSUPPORTED_SUBSCRIPTIONREQUESTTYPE = "4" + MDReqRejReason_UNSUPPORTED_MARKETDEPTH = "5" + MDReqRejReason_UNSUPPORTED_MDUPDATETYPE = "6" + MDReqRejReason_UNSUPPORTED_AGGREGATEDBOOK = "7" + MDReqRejReason_UNSUPPORTED_MDENTRYTYPE = "8" + MDReqRejReason_UNSUPPORTED_TRADINGSESSIONID = "9" + MDReqRejReason_UNSUPPORTED_SCOPE = "A" + MDReqRejReason_UNSUPPORTED_OPENCLOSESETTLEFLAG = "B" + MDReqRejReason_UNSUPPORTED_MDIMPLICITDELETE = "C" + MDReqRejReason_INSUFFICIENT_CREDIT = "D" +) + +//Enum values for MDSecSizeType +const ( + MDSecSizeType_CUSTOMER = "1" +) + +//Enum values for MDUpdateAction +const ( + MDUpdateAction_NEW = "0" + MDUpdateAction_CHANGE = "1" + MDUpdateAction_DELETE = "2" + MDUpdateAction_DELETE_THRU = "3" + MDUpdateAction_DELETE_FROM = "4" + MDUpdateAction_OVERLAY = "5" +) + +//Enum values for MDUpdateType +const ( + MDUpdateType_FULL_REFRESH = "0" + MDUpdateType_INCREMENTAL_REFRESH = "1" +) + +//Enum values for MarketUpdateAction +const ( + MarketUpdateAction_ADD = "A" + MarketUpdateAction_DELETE = "D" + MarketUpdateAction_MODIFY = "M" +) + +//Enum values for MassActionRejectReason +const ( + MassActionRejectReason_MASS_ACTION_NOT_SUPPORTED = "0" + MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY = "1" + MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER = "10" + MassActionRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY = "11" + MassActionRejectReason_INVALID_OR_UNKNOWN_UNDERLYING_SECURITY = "2" + MassActionRejectReason_INVALID_OR_UNKNOWN_PRODUCT = "3" + MassActionRejectReason_INVALID_OR_UNKNOWN_CFICODE = "4" + MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE = "5" + MassActionRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION = "6" + MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET = "7" + MassActionRejectReason_INVALID_OR_UNKNOWN_MARKET_SEGMENT = "8" + MassActionRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP = "9" + MassActionRejectReason_OTHER = "99" +) + +//Enum values for MassActionResponse +const ( + MassActionResponse_REJECTED = "0" + MassActionResponse_ACCEPTED = "1" +) + +//Enum values for MassActionScope +const ( + MassActionScope_ALL_ORDERS_FOR_A_SECURITY = "1" + MassActionScope_ALL_ORDERS_FOR_A_SECURITY_GROUP = "10" + MassActionScope_CANCEL_FOR_SECURITY_ISSUER = "11" + MassActionScope_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY = "12" + MassActionScope_ALL_ORDERS_FOR_AN_UNDERLYING_SECURITY = "2" + MassActionScope_ALL_ORDERS_FOR_A_PRODUCT = "3" + MassActionScope_ALL_ORDERS_FOR_A_CFICODE = "4" + MassActionScope_ALL_ORDERS_FOR_A_SECURITYTYPE = "5" + MassActionScope_ALL_ORDERS_FOR_A_TRADING_SESSION = "6" + MassActionScope_ALL_ORDERS = "7" + MassActionScope_ALL_ORDERS_FOR_A_MARKET = "8" + MassActionScope_ALL_ORDERS_FOR_A_MARKET_SEGMENT = "9" +) + +//Enum values for MassActionType +const ( + MassActionType_SUSPEND_ORDERS = "1" + MassActionType_RELEASE_ORDERS_FROM_SUSPENSION = "2" + MassActionType_CANCEL_ORDERS = "3" +) + +//Enum values for MassCancelRejectReason +const ( + MassCancelRejectReason_MASS_CANCEL_NOT_SUPPORTED = "0" + MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY = "1" + MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER = "10" + MassCancelRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY = "11" + MassCancelRejectReason_INVALID_OR_UNKOWN_UNDERLYING_SECURITY = "2" + MassCancelRejectReason_INVALID_OR_UNKNOWN_PRODUCT = "3" + MassCancelRejectReason_INVALID_OR_UNKNOWN_CFICODE = "4" + MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITYTYPE = "5" + MassCancelRejectReason_INVALID_OR_UNKNOWN_TRADING_SESSION = "6" + MassCancelRejectReason_INVALID_OR_UNKNOWN_MARKET = "7" + MassCancelRejectReason_INVALID_OR_UNKOWN_MARKET_SEGMENT = "8" + MassCancelRejectReason_INVALID_OR_UNKNOWN_SECURITY_GROUP = "9" + MassCancelRejectReason_OTHER = "99" +) + +//Enum values for MassCancelRequestType +const ( + MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY = "1" + MassCancelRequestType_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY = "2" + MassCancelRequestType_CANCEL_ORDERS_FOR_A_PRODUCT = "3" + MassCancelRequestType_CANCEL_ORDERS_FOR_A_CFICODE = "4" + MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITYTYPE = "5" + MassCancelRequestType_CANCEL_ORDERS_FOR_A_TRADING_SESSION = "6" + MassCancelRequestType_CANCEL_ALL_ORDERS = "7" + MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET = "8" + MassCancelRequestType_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT = "9" + MassCancelRequestType_CANCEL_ORDERS_FOR_A_SECURITY_GROUP = "A" + MassCancelRequestType_CANCEL_FOR_SECURITY_ISSUER = "B" + MassCancelRequestType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY = "C" +) + +//Enum values for MassCancelResponse +const ( + MassCancelResponse_CANCEL_REQUEST_REJECTED = "0" + MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY = "1" + MassCancelResponse_CANCEL_ORDERS_FOR_AN_UNDERLYING_SECURITY = "2" + MassCancelResponse_CANCEL_ORDERS_FOR_A_PRODUCT = "3" + MassCancelResponse_CANCEL_ORDERS_FOR_A_CFICODE = "4" + MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITYTYPE = "5" + MassCancelResponse_CANCEL_ORDERS_FOR_A_TRADING_SESSION = "6" + MassCancelResponse_CANCEL_ALL_ORDERS = "7" + MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET = "8" + MassCancelResponse_CANCEL_ORDERS_FOR_A_MARKET_SEGMENT = "9" + MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITY_GROUP = "A" + MassCancelResponse_CANCEL_ORDERS_FOR_A_SECURITIES_ISSUER = "B" + MassCancelResponse_CANCEL_ORDERS_FOR_ISSUER_OF_UNDERLYING_SECURITY = "C" +) + +//Enum values for MassStatusReqType +const ( + MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITY = "1" + MassStatusReqType_STATUS_FOR_ISSUER_OF_UNDERLYING_SECURITY = "10" + MassStatusReqType_STATUS_FOR_ORDERS_FOR_AN_UNDERLYING_SECURITY = "2" + MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PRODUCT = "3" + MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_CFICODE = "4" + MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_SECURITYTYPE = "5" + MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_TRADING_SESSION = "6" + MassStatusReqType_STATUS_FOR_ALL_ORDERS = "7" + MassStatusReqType_STATUS_FOR_ORDERS_FOR_A_PARTYID = "8" + MassStatusReqType_STATUS_FOR_SECURITY_ISSUER = "9" +) + +//Enum values for MatchStatus +const ( + MatchStatus_COMPARED_MATCHED_OR_AFFIRMED = "0" + MatchStatus_UNCOMPARED_UNMATCHED_OR_UNAFFIRMED = "1" + MatchStatus_ADVISORY_OR_ALERT = "2" +) + +//Enum values for MatchType +const ( + MatchType_ONE_PARTY_TRADE_REPORT = "1" + MatchType_TWO_PARTY_TRADE_REPORT = "2" + MatchType_CONFIRMED_TRADE_REPORT = "3" + MatchType_AUTO_MATCH = "4" + MatchType_CROSS_AUCTION = "5" + MatchType_COUNTER_ORDER_SELECTION = "6" + MatchType_ONE_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT = "60" + MatchType_TWO_PARTY_PRIVATELY_NEGOTIATED_TRADE_REPORT = "61" + MatchType_CONTINUOUS_AUTO_MATCH = "62" + MatchType_CROSS_AUCTION_63 = "63" + MatchType_COUNTER_ORDER_SELECTION_64 = "64" + MatchType_CALL_AUCTION_65 = "65" + MatchType_CALL_AUCTION = "7" + MatchType_ISSUING_BUY_BACK_AUCTION = "8" + MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES_AND_EXECUTION_TIME = "A1" + MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_FOUR_BADGES = "A2" + MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES_AND_EXECUTION_TIME = "A3" + MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_TWO_BADGES = "A4" + MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADETYPE_AND_SPECIAL_TRADE_INDICATOR_PLUS_EXECUTION_TIME = "A5" + MatchType_NASDAQACTM1MATCH = "ACTM1" + MatchType_NASDAQACTM2MATCH = "ACTM2" + MatchType_NASDAQACTACCEPTEDTRADE = "ACTM3" + MatchType_NASDAQACTDEFAULTTRADE = "ACTM4" + MatchType_NASDAQACTDEFAULTAFTERM2 = "ACTM5" + MatchType_NASDAQACTM6MATCH = "ACTM6" + MatchType_NASDAQNONACT = "ACTMT" + MatchType_COMPARED_RECORDS_RESULTING_FROM_STAMPED_ADVISORIES_OR_SPECIALIST_ACCEPTS_PAIR_OFFS = "AQ" + MatchType_EXACT_MATCH_ON_TRADE_DATE_STOCK_SYMBOL_QUANTITY_PRICE_TRADE_TYPE_AND_SPECIAL_TRADE_INDICATOR_MINUS_BADGES_AND_TIMES_ACT_M1_MATCH = "M1" + MatchType_SUMMARIZED_MATCH_MINUS_BADGES_AND_TIMES_ACT_M2_MATCH = "M2" + MatchType_ACT_ACCEPTED_TRADE = "M3" + MatchType_ACT_DEFAULT_TRADE = "M4" + MatchType_ACT_DEFAULT_AFTER_M2 = "M5" + MatchType_ACT_M6_MATCH = "M6" + MatchType_OCS_LOCKED_IN_NON_ACT = "MT" + MatchType_SUMMARIZED_MATCH_USING_A1_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIED = "S1" + MatchType_SUMMARIZED_MATCH_USING_A2_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED = "S2" + MatchType_SUMMARIZED_MATCH_USING_A3_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED = "S3" + MatchType_SUMMARIZED_MATCH_USING_A4_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED = "S4" + MatchType_SUMMARIZED_MATCH_USING_A5_EXACT_MATCH_CRITERIA_EXCEPT_QUANTITY_IS_SUMMARIZED = "S5" +) + +//Enum values for MaturityMonthYearFormat +const ( + MaturityMonthYearFormat_YEARMONTH_ONLY = "0" + MaturityMonthYearFormat_YEARMONTHDAY = "1" + MaturityMonthYearFormat_YEARMONTHWEEK = "2" +) + +//Enum values for MaturityMonthYearIncrementUnits +const ( + MaturityMonthYearIncrementUnits_MONTHS = "0" + MaturityMonthYearIncrementUnits_DAYS = "1" + MaturityMonthYearIncrementUnits_WEEKS = "2" + MaturityMonthYearIncrementUnits_YEARS = "3" +) + +//Enum values for MessageEncoding +const ( + MessageEncoding_EUC_JP = "EUC-JP" + MessageEncoding_ISO_2022_JP = "ISO-2022-JP" + MessageEncoding_SHIFT_JIS = "SHIFT_JIS" + MessageEncoding_UTF_8 = "UTF-8" +) + +//Enum values for MiscFeeBasis +const ( + MiscFeeBasis_ABSOLUTE = "0" + MiscFeeBasis_PER_UNIT = "1" + MiscFeeBasis_PERCENTAGE = "2" +) + +//Enum values for MiscFeeType +const ( + MiscFeeType_REGULATORY = "1" + MiscFeeType_PER_TRANSACTION = "10" + MiscFeeType_CONVERSION = "11" + MiscFeeType_AGENT = "12" + MiscFeeType_TRANSFER_FEE = "13" + MiscFeeType_SECURITY_LENDING = "14" + MiscFeeType_TAX = "2" + MiscFeeType_LOCAL_COMMISSION = "3" + MiscFeeType_EXCHANGE_FEES = "4" + MiscFeeType_STAMP = "5" + MiscFeeType_LEVY = "6" + MiscFeeType_OTHER = "7" + MiscFeeType_MARKUP = "8" + MiscFeeType_CONSUMPTION_TAX = "9" +) + +//Enum values for ModelType +const ( + ModelType_UTILITY_PROVIDED_STANDARD_MODEL = "0" + ModelType_PROPRIETARY = "1" +) + +//Enum values for MoneyLaunderingStatus +const ( + MoneyLaunderingStatus_EXEMPT_1 = "1" + MoneyLaunderingStatus_EXEMPT_2 = "2" + MoneyLaunderingStatus_EXEMPT_3 = "3" + MoneyLaunderingStatus_NOT_CHECKED = "N" + MoneyLaunderingStatus_PASSED = "Y" +) + +//Enum values for MsgDirection +const ( + MsgDirection_RECEIVE = "R" + MsgDirection_SEND = "S" +) + +//Enum values for MsgType +const ( + MsgType_HEARTBEAT = "0" + MsgType_TEST_REQUEST = "1" + MsgType_RESEND_REQUEST = "2" + MsgType_REJECT = "3" + MsgType_SEQUENCE_RESET = "4" + MsgType_LOGOUT = "5" + MsgType_INDICATION_OF_INTEREST = "6" + MsgType_ADVERTISEMENT = "7" + MsgType_EXECUTION_REPORT = "8" + MsgType_ORDER_CANCEL_REJECT = "9" + MsgType_LOGON = "A" + MsgType_DERIVATIVE_SECURITY_LIST = "AA" + MsgType_NEW_ORDER_MULTILEG = "AB" + MsgType_MULTILEG_ORDER_CANCEL_REPLACE = "AC" + MsgType_TRADE_CAPTURE_REPORT_REQUEST = "AD" + MsgType_TRADE_CAPTURE_REPORT = "AE" + MsgType_ORDER_MASS_STATUS_REQUEST = "AF" + MsgType_QUOTE_REQUEST_REJECT = "AG" + MsgType_RFQ_REQUEST = "AH" + MsgType_QUOTE_STATUS_REPORT = "AI" + MsgType_QUOTE_RESPONSE = "AJ" + MsgType_CONFIRMATION = "AK" + MsgType_POSITION_MAINTENANCE_REQUEST = "AL" + MsgType_POSITION_MAINTENANCE_REPORT = "AM" + MsgType_REQUEST_FOR_POSITIONS = "AN" + MsgType_REQUEST_FOR_POSITIONS_ACK = "AO" + MsgType_POSITION_REPORT = "AP" + MsgType_TRADE_CAPTURE_REPORT_REQUEST_ACK = "AQ" + MsgType_TRADE_CAPTURE_REPORT_ACK = "AR" + MsgType_ALLOCATION_REPORT = "AS" + MsgType_ALLOCATION_REPORT_ACK = "AT" + MsgType_CONFIRMATION_ACK = "AU" + MsgType_SETTLEMENT_INSTRUCTION_REQUEST = "AV" + MsgType_ASSIGNMENT_REPORT = "AW" + MsgType_COLLATERAL_REQUEST = "AX" + MsgType_COLLATERAL_ASSIGNMENT = "AY" + MsgType_COLLATERAL_RESPONSE = "AZ" + MsgType_NEWS = "B" + MsgType_COLLATERAL_REPORT = "BA" + MsgType_COLLATERAL_INQUIRY = "BB" + MsgType_NETWORK_STATUS_REQUEST = "BC" + MsgType_NETWORK_STATUS_RESPONSE = "BD" + MsgType_USER_REQUEST = "BE" + MsgType_USER_RESPONSE = "BF" + MsgType_COLLATERAL_INQUIRY_ACK = "BG" + MsgType_CONFIRMATION_REQUEST = "BH" + MsgType_TRADING_SESSION_LIST_REQUEST = "BI" + MsgType_TRADING_SESSION_LIST = "BJ" + MsgType_SECURITY_LIST_UPDATE_REPORT = "BK" + MsgType_ADJUSTED_POSITION_REPORT = "BL" + MsgType_ALLOCATION_INSTRUCTION_ALERT = "BM" + MsgType_EXECUTION_ACKNOWLEDGEMENT = "BN" + MsgType_CONTRARY_INTENTION_REPORT = "BO" + MsgType_SECURITY_DEFINITION_UPDATE_REPORT = "BP" + MsgType_SETTLEMENTOBLIGATIONREPORT = "BQ" + MsgType_DERIVATIVESECURITYLISTUPDATEREPORT = "BR" + MsgType_TRADINGSESSIONLISTUPDATEREPORT = "BS" + MsgType_MARKETDEFINITIONREQUEST = "BT" + MsgType_MARKETDEFINITION = "BU" + MsgType_MARKETDEFINITIONUPDATEREPORT = "BV" + MsgType_APPLICATIONMESSAGEREQUEST = "BW" + MsgType_APPLICATIONMESSAGEREQUESTACK = "BX" + MsgType_APPLICATIONMESSAGEREPORT = "BY" + MsgType_ORDERMASSACTIONREPORT = "BZ" + MsgType_EMAIL = "C" + MsgType_ORDERMASSACTIONREQUEST = "CA" + MsgType_USERNOTIFICATION = "CB" + MsgType_STREAMASSIGNMENTREQUEST = "CC" + MsgType_STREAMASSIGNMENTREPORT = "CD" + MsgType_STREAMASSIGNMENTREPORTACK = "CE" + MsgType_PARTYDETAILSLISTREQUEST = "CF" + MsgType_PARTYDETAILSLISTREPORT = "CG" + MsgType_ORDER_SINGLE = "D" + MsgType_ORDER_LIST = "E" + MsgType_ORDER_CANCEL_REQUEST = "F" + MsgType_ORDER_CANCEL_REPLACE_REQUEST = "G" + MsgType_ORDER_STATUS_REQUEST = "H" + MsgType_ALLOCATION_INSTRUCTION = "J" + MsgType_LIST_CANCEL_REQUEST = "K" + MsgType_LIST_EXECUTE = "L" + MsgType_LIST_STATUS_REQUEST = "M" + MsgType_LIST_STATUS = "N" + MsgType_ALLOCATION_INSTRUCTION_ACK = "P" + MsgType_DONT_KNOW_TRADE = "Q" + MsgType_QUOTE_REQUEST = "R" + MsgType_QUOTE = "S" + MsgType_SETTLEMENT_INSTRUCTIONS = "T" + MsgType_MARKET_DATA_REQUEST = "V" + MsgType_MARKET_DATA_SNAPSHOT_FULL_REFRESH = "W" + MsgType_MARKET_DATA_INCREMENTAL_REFRESH = "X" + MsgType_MARKET_DATA_REQUEST_REJECT = "Y" + MsgType_QUOTE_CANCEL = "Z" + MsgType_QUOTE_STATUS_REQUEST = "a" + MsgType_MASS_QUOTE_ACKNOWLEDGEMENT = "b" + MsgType_SECURITY_DEFINITION_REQUEST = "c" + MsgType_SECURITY_DEFINITION = "d" + MsgType_SECURITY_STATUS_REQUEST = "e" + MsgType_SECURITY_STATUS = "f" + MsgType_TRADING_SESSION_STATUS_REQUEST = "g" + MsgType_TRADING_SESSION_STATUS = "h" + MsgType_MASS_QUOTE = "i" + MsgType_BUSINESS_MESSAGE_REJECT = "j" + MsgType_BID_REQUEST = "k" + MsgType_BID_RESPONSE = "l" + MsgType_LIST_STRIKE_PRICE = "m" + MsgType_XML_MESSAGE = "n" + MsgType_REGISTRATION_INSTRUCTIONS = "o" + MsgType_REGISTRATION_INSTRUCTIONS_RESPONSE = "p" + MsgType_ORDER_MASS_CANCEL_REQUEST = "q" + MsgType_ORDER_MASS_CANCEL_REPORT = "r" + MsgType_NEW_ORDER_CROSS = "s" + MsgType_CROSS_ORDER_CANCEL_REPLACE_REQUEST = "t" + MsgType_CROSS_ORDER_CANCEL_REQUEST = "u" + MsgType_SECURITY_TYPE_REQUEST = "v" + MsgType_SECURITY_TYPES = "w" + MsgType_SECURITY_LIST_REQUEST = "x" + MsgType_SECURITY_LIST = "y" + MsgType_DERIVATIVE_SECURITY_LIST_REQUEST = "z" +) + +//Enum values for MultiLegReportingType +const ( + MultiLegReportingType_SINGLE_SECURITY = "1" + MultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTI_LEG_SECURITY = "2" + MultiLegReportingType_MULTI_LEG_SECURITY = "3" +) + +//Enum values for MultiLegRptTypeReq +const ( + MultiLegRptTypeReq_REPORT_BY_MULITLEG_SECURITY_ONLY = "0" + MultiLegRptTypeReq_REPORT_BY_MULTILEG_SECURITY_AND_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY = "1" + MultiLegRptTypeReq_REPORT_BY_INSTRUMENT_LEGS_BELONGING_TO_THE_MULTILEG_SECURITY_ONLY = "2" +) + +//Enum values for MultilegModel +const ( + MultilegModel_PREDEFINED_MULTILEG_SECURITY = "0" + MultilegModel_USER_DEFINED_MULTLEG_SECURITY = "1" + MultilegModel_USER_DEFINED_NON_SECURITIZED_MULTILEG = "2" +) + +//Enum values for MultilegPriceMethod +const ( + MultilegPriceMethod_NET_PRICE = "0" + MultilegPriceMethod_REVERSED_NET_PRICE = "1" + MultilegPriceMethod_YIELD_DIFFERENCE = "2" + MultilegPriceMethod_INDIVIDUAL = "3" + MultilegPriceMethod_CONTRACT_WEIGHTED_AVERAGE_PRICE = "4" + MultilegPriceMethod_MULTIPLIED_PRICE = "5" +) + +//Enum values for NetGrossInd +const ( + NetGrossInd_NET = "1" + NetGrossInd_GROSS = "2" +) + +//Enum values for NetworkRequestType +const ( + NetworkRequestType_SNAPSHOT = "1" + NetworkRequestType_SUBSCRIBE = "2" + NetworkRequestType_STOP_SUBSCRIBING = "4" + NetworkRequestType_LEVEL_OF_DETAIL_THEN_NOCOMPIDS_BECOMES_REQUIRED = "8" +) + +//Enum values for NetworkStatusResponseType +const ( + NetworkStatusResponseType_FULL = "1" + NetworkStatusResponseType_INCREMENTAL_UPDATE = "2" +) + +//Enum values for NewsCategory +const ( + NewsCategory_COMPANY_NEWS = "0" + NewsCategory_MARKETPLACE_NEWS = "1" + NewsCategory_FINANCIAL_MARKET_NEWS = "2" + NewsCategory_TECHNICAL_NEWS = "3" + NewsCategory_OTHER_NEWS = "99" +) + +//Enum values for NewsRefType +const ( + NewsRefType_REPLACEMENT = "0" + NewsRefType_OTHER_LANGUAGE = "1" + NewsRefType_COMPLIMENTARY = "2" +) + +//Enum values for NoSides +const ( + NoSides_ONE_SIDE = "1" + NoSides_BOTH_SIDES = "2" +) + +//Enum values for NotifyBrokerOfCredit +const ( + NotifyBrokerOfCredit_NO = "N" + NotifyBrokerOfCredit_YES = "Y" +) + +//Enum values for OddLot +const ( + OddLot_NO = "N" + OddLot_YES = "Y" +) + +//Enum values for OpenClose +const ( + OpenClose_CLOSE = "C" + OpenClose_OPEN = "O" +) + +//Enum values for OpenCloseSettlFlag +const ( + OpenCloseSettlFlag_DAILY_OPEN = "0" + OpenCloseSettlFlag_SESSION_OPEN = "1" + OpenCloseSettlFlag_DELIVERY_SETTLEMENT_ENTRY = "2" + OpenCloseSettlFlag_EXPECTED_ENTRY = "3" + OpenCloseSettlFlag_ENTRY_FROM_PREVIOUS_BUSINESS_DAY = "4" + OpenCloseSettlFlag_THEORETICAL_PRICE_VALUE = "5" +) + +//Enum values for OpenCloseSettleFlag +const ( + OpenCloseSettleFlag_DAILY_OPEN = "0" + OpenCloseSettleFlag_SESSION_OPEN = "1" + OpenCloseSettleFlag_DELIVERY_SETTLEMENT_PRICE = "2" + OpenCloseSettleFlag_EXPECTED_PRICE = "3" + OpenCloseSettleFlag_PRICE_FROM_PREVIOUS_BUSINESS_DAY = "4" +) + +//Enum values for OptPayoutType +const ( + OptPayoutType_VANILLA = "1" + OptPayoutType_CAPPED = "2" + OptPayoutType_BINARY = "3" +) + +//Enum values for OrdRejReason +const ( + OrdRejReason_BROKER = "0" + OrdRejReason_UNKNOWN_SYMBOL = "1" + OrdRejReason_INVALID_INVESTOR_ID = "10" + OrdRejReason_UNSUPPORTED_ORDER_CHARACTERISTIC = "11" + OrdRejReason_SURVEILLENCE_OPTION = "12" + OrdRejReason_INCORRECT_QUANTITY = "13" + OrdRejReason_INCORRECT_ALLOCATED_QUANTITY = "14" + OrdRejReason_UNKNOWN_ACCOUNT = "15" + OrdRejReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND = "16" + OrdRejReason_INVALID_PRICE_INCREMENT = "18" + OrdRejReason_EXCHANGE_CLOSED = "2" + OrdRejReason_ORDER_EXCEEDS_LIMIT = "3" + OrdRejReason_TOO_LATE_TO_ENTER = "4" + OrdRejReason_UNKNOWN_ORDER = "5" + OrdRejReason_DUPLICATE_ORDER = "6" + OrdRejReason_DUPLICATE_OF_A_VERBALLY_COMMUNICATED_ORDER = "7" + OrdRejReason_STALE_ORDER = "8" + OrdRejReason_TRADE_ALONG_REQUIRED = "9" + OrdRejReason_OTHER = "99" +) + +//Enum values for OrdStatus +const ( + OrdStatus_NEW = "0" + OrdStatus_PARTIALLY_FILLED = "1" + OrdStatus_FILLED = "2" + OrdStatus_DONE_FOR_DAY = "3" + OrdStatus_CANCELED = "4" + OrdStatus_REPLACED = "5" + OrdStatus_PENDING_CANCEL = "6" + OrdStatus_STOPPED = "7" + OrdStatus_REJECTED = "8" + OrdStatus_SUSPENDED = "9" + OrdStatus_PENDING_NEW = "A" + OrdStatus_CALCULATED = "B" + OrdStatus_EXPIRED = "C" + OrdStatus_ACCEPTED_FOR_BIDDING = "D" + OrdStatus_PENDING_REPLACE = "E" +) + +//Enum values for OrdType +const ( + OrdType_MARKET = "1" + OrdType_LIMIT = "2" + OrdType_STOP = "3" + OrdType_STOP_LIMIT = "4" + OrdType_MARKET_ON_CLOSE = "5" + OrdType_WITH_OR_WITHOUT = "6" + OrdType_LIMIT_OR_BETTER = "7" + OrdType_LIMIT_WITH_OR_WITHOUT = "8" + OrdType_ON_BASIS = "9" + OrdType_ON_CLOSE = "A" + OrdType_LIMIT_ON_CLOSE = "B" + OrdType_FOREX_MARKET = "C" + OrdType_PREVIOUSLY_QUOTED = "D" + OrdType_PREVIOUSLY_INDICATED = "E" + OrdType_FOREX_LIMIT = "F" + OrdType_FOREX_SWAP = "G" + OrdType_FOREX_PREVIOUSLY_QUOTED = "H" + OrdType_FUNARI = "I" + OrdType_MARKET_IF_TOUCHED = "J" + OrdType_MARKET_WITH_LEFT_OVER_AS_LIMIT = "K" + OrdType_PREVIOUS_FUND_VALUATION_POINT = "L" + OrdType_NEXT_FUND_VALUATION_POINT = "M" + OrdType_PEGGED = "P" + OrdType_COUNTER_ORDER_SELECTION = "Q" +) + +//Enum values for OrderCapacity +const ( + OrderCapacity_AGENCY = "A" + OrderCapacity_PROPRIETARY = "G" + OrderCapacity_INDIVIDUAL = "I" + OrderCapacity_PRINCIPAL = "P" + OrderCapacity_RISKLESS_PRINCIPAL = "R" + OrderCapacity_AGENT_FOR_OTHER_MEMBER = "W" +) + +//Enum values for OrderCategory +const ( + OrderCategory_ORDER = "1" + OrderCategory_QUOTE = "2" + OrderCategory_PRIVATELY_NEGOTIATED_TRADE = "3" + OrderCategory_MULTILEG_ORDER = "4" + OrderCategory_LINKED_ORDER = "5" + OrderCategory_QUOTE_REQUEST = "6" + OrderCategory_IMPLIED_ORDER = "7" + OrderCategory_CROSS_ORDER = "8" + OrderCategory_STREAMING_PRICE = "9" +) + +//Enum values for OrderDelayUnit +const ( + OrderDelayUnit_SECONDS = "0" + OrderDelayUnit_TENTHS_OF_A_SECOND = "1" + OrderDelayUnit_MINUTES = "10" + OrderDelayUnit_HOURS = "11" + OrderDelayUnit_DAYS = "12" + OrderDelayUnit_WEEKS = "13" + OrderDelayUnit_MONTHS = "14" + OrderDelayUnit_YEARS = "15" + OrderDelayUnit_HUNDREDTHS_OF_A_SECOND = "2" + OrderDelayUnit_MILLISECONDS = "3" + OrderDelayUnit_MICROSECONDS = "4" + OrderDelayUnit_NANOSECONDS = "5" +) + +//Enum values for OrderHandlingInstSource +const ( + OrderHandlingInstSource_NASD_OATS = "1" +) + +//Enum values for OrderRestrictions +const ( + OrderRestrictions_PROGRAM_TRADE = "1" + OrderRestrictions_INDEX_ARBITRAGE = "2" + OrderRestrictions_NON_INDEX_ARBITRAGE = "3" + OrderRestrictions_COMPETING_MARKET_MAKER = "4" + OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_SECURITY = "5" + OrderRestrictions_ACTING_AS_MARKET_MAKER_OR_SPECIALIST_IN_THE_UNDERLYING_SECURITY_OF_A_DERIVATIVE_SECURITY = "6" + OrderRestrictions_FOREIGN_ENTITY = "7" + OrderRestrictions_EXTERNAL_MARKET_PARTICIPANT = "8" + OrderRestrictions_EXTERNAL_INTER_CONNECTED_MARKET_LINKAGE = "9" + OrderRestrictions_RISKLESS_ARBITRAGE = "A" + OrderRestrictions_ISSUER_HOLDING = "B" + OrderRestrictions_ISSUE_PRICE_STABILIZATION = "C" + OrderRestrictions_NON_ALGORITHMIC = "D" + OrderRestrictions_ALGORITHMIC = "E" + OrderRestrictions_CROSS = "F" +) + +//Enum values for OrigCustOrderCapacity +const ( + OrigCustOrderCapacity_MEMBER_TRADING_FOR_THEIR_OWN_ACCOUNT = "1" + OrigCustOrderCapacity_CLEARING_FIRM_TRADING_FOR_ITS_PROPRIETARY_ACCOUNT = "2" + OrigCustOrderCapacity_MEMBER_TRADING_FOR_ANOTHER_MEMBER = "3" + OrigCustOrderCapacity_ALL_OTHER = "4" +) + +//Enum values for OwnerType +const ( + OwnerType_INDIVIDUAL_INVESTOR = "1" + OwnerType_NETWORKING_SUB_ACCOUNT = "10" + OwnerType_NON_PROFIT_ORGANIZATION = "11" + OwnerType_CORPORATE_BODY = "12" + OwnerType_NOMINEE = "13" + OwnerType_PUBLIC_COMPANY = "2" + OwnerType_PRIVATE_COMPANY = "3" + OwnerType_INDIVIDUAL_TRUSTEE = "4" + OwnerType_COMPANY_TRUSTEE = "5" + OwnerType_PENSION_PLAN = "6" + OwnerType_CUSTODIAN_UNDER_GIFTS_TO_MINORS_ACT = "7" + OwnerType_TRUSTS = "8" + OwnerType_FIDUCIARIES = "9" +) + +//Enum values for OwnershipType +const ( + OwnershipType_JOINT_TRUSTEES = "2" + OwnershipType_JOINT_INVESTORS = "J" + OwnershipType_TENANTS_IN_COMMON = "T" +) + +//Enum values for PartyDetailsRequestResult +const ( + PartyDetailsRequestResult_VALID_REQUEST = "0" + PartyDetailsRequestResult_INVALID_OR_UNSUPPORTED_REQUEST = "1" + PartyDetailsRequestResult_NO_PARTIES_OR_PARTY_DETAILS_FOUND_THAT_MATCH_SELECTION_CRITERIA = "2" + PartyDetailsRequestResult_UNSUPPORTED_PARTYLISTRESPONSETYPE = "3" + PartyDetailsRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_PARTIES_OR_PARTY_DETAILS_DATA = "4" + PartyDetailsRequestResult_PARTIES_OR_PARTY_DETAILS_DATA_TEMPORARILY_UNAVAILABLE = "5" + PartyDetailsRequestResult_REQUEST_FOR_PARTIES_DATA_NOT_SUPPORTED = "6" + PartyDetailsRequestResult_OTHER = "99" +) + +//Enum values for PartyIDSource +const ( + PartyIDSource_KOREAN_INVESTOR_ID = "1" + PartyIDSource_TAIWANESE_QUALIFIED_FOREIGN_INVESTOR_ID_QFII_FID = "2" + PartyIDSource_TAIWANESE_TRADING_ACCT = "3" + PartyIDSource_MALAYSIAN_CENTRAL_DEPOSITORY = "4" + PartyIDSource_CHINESE_INVESTOR_ID = "5" + PartyIDSource_UK_NATIONAL_INSURANCE_OR_PENSION_NUMBER = "6" + PartyIDSource_US_SOCIAL_SECURITY_NUMBER = "7" + PartyIDSource_US_EMPLOYER_OR_TAX_ID_NUMBER = "8" + PartyIDSource_AUSTRALIAN_BUSINESS_NUMBER = "9" + PartyIDSource_AUSTRALIAN_TAX_FILE_NUMBER = "A" + PartyIDSource_BIC = "B" + PartyIDSource_GENERALLY_ACCEPTED_MARKET_PARTICIPANT_IDENTIFIER = "C" + PartyIDSource_PROPRIETARY = "D" + PartyIDSource_ISO_COUNTRY_CODE = "E" + PartyIDSource_SETTLEMENT_ENTITY_LOCATION = "F" + PartyIDSource_MIC = "G" + PartyIDSource_CSD_PARTICIPANT_MEMBER_CODE = "H" + PartyIDSource_DIRECTED_BROKER_THREE_CHARACTER_ACRONYM_AS_DEFINED_IN_ISITC_ETC_BEST_PRACTICE_GUIDELINES_DOCUMENT = "I" +) + +//Enum values for PartyListResponseType +const ( + PartyListResponseType_RETURN_ALL_AVAILABLE_INFORMATION_ON_PARTIES_AND_RELATED_PARTIES = "0" + PartyListResponseType_RETURN_ONLY_PARTY_INFORMATION = "1" + PartyListResponseType_INCLUDE_INFORMATION_ON_RELATED_PARTIES = "2" + PartyListResponseType_INCLUDE_RISK_LIMIT_INFORMATION = "3" +) + +//Enum values for PartyRelationship +const ( + PartyRelationship_IS_ALSO = "0" + PartyRelationship_CLEARS_FOR = "1" + PartyRelationship_HAS_MEMBERS = "10" + PartyRelationship_PROVIDES_MARKETPLACE_FOR = "11" + PartyRelationship_PARTICIPANT_OF_MARKETPLACE = "12" + PartyRelationship_CARRIES_POSITIONS_FOR = "13" + PartyRelationship_POSTS_TRADES_TO = "14" + PartyRelationship_ENTERS_TRADES_FOR = "15" + PartyRelationship_ENTERS_TRADES_THROUGH = "16" + PartyRelationship_PROVIDES_QUOTES_TO = "17" + PartyRelationship_REQUESTS_QUOTES_FROM = "18" + PartyRelationship_INVESTS_FOR = "19" + PartyRelationship_CLEARS_THROUGH = "2" + PartyRelationship_INVESTS_THROUGH = "20" + PartyRelationship_BROKERS_TRADES_FOR = "21" + PartyRelationship_BROKERS_TRADES_THROUGH = "22" + PartyRelationship_PROVIDES_TRADING_SERVICES_FOR = "23" + PartyRelationship_USES_TRADING_SERVICES_OF = "24" + PartyRelationship_APPROVES_OF = "25" + PartyRelationship_APPROVED_BY = "26" + PartyRelationship_PARENT_FIRM_FOR = "27" + PartyRelationship_SUBSIDIARY_OF = "28" + PartyRelationship_REGULATORY_OWNER_OF = "29" + PartyRelationship_TRADES_FOR = "3" + PartyRelationship_OWNED_BY_30 = "30" + PartyRelationship_CONTROLS = "31" + PartyRelationship_IS_CONTROLLED_BY = "32" + PartyRelationship_LEGAL = "33" + PartyRelationship_OWNED_BY_34 = "34" + PartyRelationship_BENEFICIAL_OWNER_OF = "35" + PartyRelationship_OWNED_BY_36 = "36" + PartyRelationship_TRADES_THROUGH = "4" + PartyRelationship_SPONSORS = "5" + PartyRelationship_SPONSORED_THROUGH = "6" + PartyRelationship_PROVIDES_GUARANTEE_FOR = "7" + PartyRelationship_IS_GUARANTEED_BY = "8" + PartyRelationship_MEMBER_OF = "9" +) + +//Enum values for PartyRole +const ( + PartyRole_EXECUTING_FIRM = "1" + PartyRole_SETTLEMENT_LOCATION = "10" + PartyRole_ORDER_ORIGINATION_TRADER = "11" + PartyRole_EXECUTING_TRADER = "12" + PartyRole_ORDER_ORIGINATION_FIRM = "13" + PartyRole_GIVEUP_CLEARING_FIRM = "14" + PartyRole_CORRESPONDANT_CLEARING_FIRM = "15" + PartyRole_EXECUTING_SYSTEM = "16" + PartyRole_CONTRA_FIRM = "17" + PartyRole_CONTRA_CLEARING_FIRM = "18" + PartyRole_SPONSORING_FIRM = "19" + PartyRole_BROKER_OF_CREDIT = "2" + PartyRole_UNDERLYING_CONTRA_FIRM = "20" + PartyRole_CLEARING_ORGANIZATION = "21" + PartyRole_EXCHANGE = "22" + PartyRole_CUSTOMER_ACCOUNT = "24" + PartyRole_CORRESPONDENT_CLEARING_ORGANIZATION = "25" + PartyRole_CORRESPONDENT_BROKER = "26" + PartyRole_BUYER_SELLER = "27" + PartyRole_CUSTODIAN = "28" + PartyRole_INTERMEDIARY = "29" + PartyRole_CLIENT_ID = "3" + PartyRole_AGENT = "30" + PartyRole_SUB_CUSTODIAN = "31" + PartyRole_BENEFICIARY = "32" + PartyRole_INTERESTED_PARTY = "33" + PartyRole_REGULATORY_BODY = "34" + PartyRole_LIQUIDITY_PROVIDER = "35" + PartyRole_ENTERING_TRADER = "36" + PartyRole_CONTRA_TRADER = "37" + PartyRole_POSITION_ACCOUNT = "38" + PartyRole_CONTRA_INVESTOR_ID = "39" + PartyRole_CLEARING_FIRM = "4" + PartyRole_TRANSFER_TO_FIRM = "40" + PartyRole_CONTRA_POSITION_ACCOUNT = "41" + PartyRole_CONTRA_EXCHANGE = "42" + PartyRole_INTERNAL_CARRY_ACCOUNT = "43" + PartyRole_ORDER_ENTRY_OPERATOR_ID = "44" + PartyRole_SECONDARY_ACCOUNT_NUMBER = "45" + PartyRole_FOREIGN_FIRM = "46" + PartyRole_THIRD_PARTY_ALLOCATION_FIRM = "47" + PartyRole_CLAIMING_ACCOUNT = "48" + PartyRole_ASSET_MANAGER = "49" + PartyRole_INVESTOR_ID = "5" + PartyRole_PLEDGOR_ACCOUNT = "50" + PartyRole_PLEDGEE_ACCOUNT = "51" + PartyRole_LARGE_TRADER_REPORTABLE_ACCOUNT = "52" + PartyRole_TRADER_MNEMONIC = "53" + PartyRole_SENDER_LOCATION = "54" + PartyRole_SESSION_ID = "55" + PartyRole_ACCEPTABLE_COUNTERPARTY = "56" + PartyRole_UNACCEPTABLE_COUNTERPARTY = "57" + PartyRole_ENTERING_UNIT = "58" + PartyRole_EXECUTING_UNIT = "59" + PartyRole_INTRODUCING_FIRM = "6" + PartyRole_INTRODUCING_BROKER = "60" + PartyRole_QUOTE_ORIGINATOR = "61" + PartyRole_REPORT_ORIGINATOR = "62" + PartyRole_SYSTEMATIC_INTERNALISER = "63" + PartyRole_MULTILATERAL_TRADING_FACILITY = "64" + PartyRole_REGULATED_MARKET = "65" + PartyRole_MARKET_MAKER = "66" + PartyRole_INVESTMENT_FIRM = "67" + PartyRole_HOST_COMPETENT_AUTHORITY = "68" + PartyRole_HOME_COMPETENT_AUTHORITY = "69" + PartyRole_ENTERING_FIRM = "7" + PartyRole_COMPETENT_AUTHORITY_OF_THE_MOST_RELEVANT_MARKET_IN_TERMS_OF_LIQUIDITY = "70" + PartyRole_COMPETENT_AUTHORITY_OF_THE_TRANSACTION = "71" + PartyRole_REPORTING_INTERMEDIARY = "72" + PartyRole_EXECUTION_VENUE = "73" + PartyRole_MARKET_DATA_ENTRY_ORIGINATOR = "74" + PartyRole_LOCATION_ID = "75" + PartyRole_DESK_ID = "76" + PartyRole_MARKET_DATA_MARKET = "77" + PartyRole_ALLOCATION_ENTITY = "78" + PartyRole_PRIME_BROKER_PROVIDING_GENERAL_TRADE_SERVICES = "79" + PartyRole_LOCATE = "8" + PartyRole_STEP_OUT_FIRM = "80" + PartyRole_BROKERCLEARINGID = "81" + PartyRole_CENTRAL_REGISTRATION_DEPOSITORY = "82" + PartyRole_CLEARING_ACCOUNT = "83" + PartyRole_ACCEPTABLE_SETTLING_COUNTERPARTY = "84" + PartyRole_UNACCEPTABLE_SETTLING_COUNTERPARTY = "85" + PartyRole_FUND_MANAGER_CLIENT_ID = "9" +) + +//Enum values for PartySubIDType +const ( + PartySubIDType_FIRM = "1" + PartySubIDType_SECURITIES_ACCOUNT_NUMBER = "10" + PartySubIDType_REGISTRATION_NUMBER = "11" + PartySubIDType_REGISTERED_ADDRESS_12 = "12" + PartySubIDType_REGULATORY_STATUS = "13" + PartySubIDType_REGISTRATION_NAME = "14" + PartySubIDType_CASH_ACCOUNT_NUMBER = "15" + PartySubIDType_BIC = "16" + PartySubIDType_CSD_PARTICIPANT_MEMBER_CODE = "17" + PartySubIDType_REGISTERED_ADDRESS_18 = "18" + PartySubIDType_FUND_ACCOUNT_NAME = "19" + PartySubIDType_PERSON = "2" + PartySubIDType_TELEX_NUMBER = "20" + PartySubIDType_FAX_NUMBER = "21" + PartySubIDType_SECURITIES_ACCOUNT_NAME = "22" + PartySubIDType_CASH_ACCOUNT_NAME = "23" + PartySubIDType_DEPARTMENT = "24" + PartySubIDType_LOCATION_DESK = "25" + PartySubIDType_POSITION_ACCOUNT_TYPE = "26" + PartySubIDType_SECURITY_LOCATE_ID = "27" + PartySubIDType_MARKET_MAKER = "28" + PartySubIDType_ELIGIBLE_COUNTERPARTY = "29" + PartySubIDType_SYSTEM = "3" + PartySubIDType_PROFESSIONAL_CLIENT = "30" + PartySubIDType_LOCATION = "31" + PartySubIDType_EXECUTION_VENUE = "32" + PartySubIDType_CURRENCY_DELIVERY_IDENTIFIER = "33" + PartySubIDType_APPLICATION = "4" + PartySubIDType_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES = "4000" + PartySubIDType_FULL_LEGAL_NAME_OF_FIRM = "5" + PartySubIDType_POSTAL_ADDRESS = "6" + PartySubIDType_PHONE_NUMBER = "7" + PartySubIDType_EMAIL_ADDRESS = "8" + PartySubIDType_CONTACT_NAME = "9" +) + +//Enum values for PaymentMethod +const ( + PaymentMethod_CREST = "1" + PaymentMethod_DIRECT_CREDIT = "10" + PaymentMethod_CREDIT_CARD = "11" + PaymentMethod_ACH_DEBIT = "12" + PaymentMethod_ACH_CREDIT = "13" + PaymentMethod_BPAY = "14" + PaymentMethod_HIGH_VALUE_CLEARING_SYSTEM = "15" + PaymentMethod_NSCC = "2" + PaymentMethod_EUROCLEAR = "3" + PaymentMethod_CLEARSTREAM = "4" + PaymentMethod_CHEQUE = "5" + PaymentMethod_TELEGRAPHIC_TRANSFER = "6" + PaymentMethod_FED_WIRE = "7" + PaymentMethod_DEBIT_CARD = "8" + PaymentMethod_DIRECT_DEBIT = "9" +) + +//Enum values for PegLimitType +const ( + PegLimitType_OR_BETTER = "0" + PegLimitType_STRICT = "1" + PegLimitType_OR_WORSE = "2" +) + +//Enum values for PegMoveType +const ( + PegMoveType_FLOATING = "0" + PegMoveType_FIXED = "1" +) + +//Enum values for PegOffsetType +const ( + PegOffsetType_PRICE = "0" + PegOffsetType_BASIS_POINTS = "1" + PegOffsetType_TICKS = "2" + PegOffsetType_PRICE_TIER = "3" +) + +//Enum values for PegPriceType +const ( + PegPriceType_LAST_PEG = "1" + PegPriceType_MID_PRICE_PEG = "2" + PegPriceType_OPENING_PEG = "3" + PegPriceType_MARKET_PEG = "4" + PegPriceType_PRIMARY_PEG = "5" + PegPriceType_FIXED_PEG_TO_LOCAL_BEST_BID_OR_OFFER_AT_TIME_OF_ORDER = "6" + PegPriceType_PEG_TO_VWAP = "7" + PegPriceType_TRAILING_STOP_PEG = "8" + PegPriceType_PEG_TO_LIMIT_PRICE = "9" +) + +//Enum values for PegRoundDirection +const ( + PegRoundDirection_MORE_AGGRESSIVE = "1" + PegRoundDirection_MORE_PASSIVE = "2" +) + +//Enum values for PegScope +const ( + PegScope_LOCAL = "1" + PegScope_NATIONAL = "2" + PegScope_GLOBAL = "3" + PegScope_NATIONAL_EXCLUDING_LOCAL = "4" +) + +//Enum values for PosAmtType +const ( + PosAmtType_ACCRUED_COUPON_AMOUNT = "ACPN" + PosAmtType_TOTAL_BANKED_AMOUNT = "BANK" + PosAmtType_CASH_AMOUNT = "CASH" + PosAmtType_COLLATERALIZED_MARK_TO_MARKET = "CMTM" + PosAmtType_TOTAL_COLLATERALIZED_AMOUNT = "COLAT" + PosAmtType_COUPON_AMOUNT = "CPN" + PosAmtType_CASH_RESIDUAL_AMOUNT = "CRES" + PosAmtType_COMPENSATION_AMOUNT = "DLV" + PosAmtType_FINAL_MARK_TO_MARKET_AMOUNT = "FMTM" + PosAmtType_INCREMENTAL_ACCRUED_COUPON = "IACPN" + PosAmtType_INCREMENTAL_COLLATERALIZED_MARK_TO_MARKET = "ICMTM" + PosAmtType_INITIAL_TRADE_COUPON_AMOUNT = "ICPN" + PosAmtType_INCREMENTAL_MARK_TO_MARKET_AMOUNT = "IMTM" + PosAmtType_PREMIUM_AMOUNT = "PREM" + PosAmtType_SETTLEMENT_VALUE = "SETL" + PosAmtType_START_OF_DAY_MARK_TO_MARKET_AMOUNT = "SMTM" + PosAmtType_TRADE_VARIATION_AMOUNT = "TVAR" + PosAmtType_VALUE_ADJUSTED_AMOUNT = "VADJ" +) + +//Enum values for PosMaintAction +const ( + PosMaintAction_NEW = "1" + PosMaintAction_REPLACE = "2" + PosMaintAction_CANCEL = "3" + PosMaintAction_REVERSE = "4" +) + +//Enum values for PosMaintResult +const ( + PosMaintResult_SUCCESSFUL_COMPLETION = "0" + PosMaintResult_REJECTED = "1" + PosMaintResult_OTHER = "99" +) + +//Enum values for PosMaintStatus +const ( + PosMaintStatus_ACCEPTED = "0" + PosMaintStatus_ACCEPTED_WITH_WARNINGS = "1" + PosMaintStatus_REJECTED = "2" + PosMaintStatus_COMPLETED = "3" + PosMaintStatus_COMPLETED_WITH_WARNINGS = "4" +) + +//Enum values for PosQtyStatus +const ( + PosQtyStatus_SUBMITTED = "0" + PosQtyStatus_ACCEPTED = "1" + PosQtyStatus_REJECTED = "2" +) + +//Enum values for PosReqResult +const ( + PosReqResult_VALID_REQUEST = "0" + PosReqResult_INVALID_OR_UNSUPPORTED_REQUEST = "1" + PosReqResult_NO_POSITIONS_FOUND_THAT_MATCH_CRITERIA = "2" + PosReqResult_NOT_AUTHORIZED_TO_REQUEST_POSITIONS = "3" + PosReqResult_REQUEST_FOR_POSITION_NOT_SUPPORTED = "4" + PosReqResult_OTHER = "99" +) + +//Enum values for PosReqStatus +const ( + PosReqStatus_COMPLETED = "0" + PosReqStatus_COMPLETED_WITH_WARNINGS = "1" + PosReqStatus_REJECTED = "2" +) + +//Enum values for PosReqType +const ( + PosReqType_POSITIONS = "0" + PosReqType_TRADES = "1" + PosReqType_EXERCISES = "2" + PosReqType_ASSIGNMENTS = "3" + PosReqType_SETTLEMENT_ACTIVITY = "4" + PosReqType_BACKOUT_MESSAGE = "5" + PosReqType_DELTA_POSITIONS = "6" +) + +//Enum values for PosTransType +const ( + PosTransType_EXERCISE = "1" + PosTransType_DO_NOT_EXERCISE = "2" + PosTransType_POSITION_ADJUSTMENT = "3" + PosTransType_POSITION_CHANGE_SUBMISSION_MARGIN_DISPOSITION = "4" + PosTransType_PLEDGE = "5" + PosTransType_LARGE_TRADER_SUBMISSION = "6" +) + +//Enum values for PosType +const ( + PosType_ALLOCATION_TRADE_QTY = "ALC" + PosType_OPTION_ASSIGNMENT = "AS" + PosType_AS_OF_TRADE_QTY = "ASF" + PosType_CORPORATE_ACTION_ADJUSTMENT = "CAA" + PosType_CREDIT_EVENT_ADJUSTMENT = "CEA" + PosType_NET_DELTA_QTY = "DLT" + PosType_DELIVERY_QTY = "DLV" + PosType_DELIVERY_NOTICE_QTY = "DN" + PosType_EXCHANGE_FOR_PHYSICAL_QTY = "EP" + PosType_ELECTRONIC_TRADE_QTY = "ETR" + PosType_OPTION_EXERCISE_QTY = "EX" + PosType_END_OF_DAY_QTY = "FIN" + PosType_INTRA_SPREAD_QTY = "IAS" + PosType_INTER_SPREAD_QTY = "IES" + PosType_ADJUSTMENT_QTY = "PA" + PosType_PIT_TRADE_QTY = "PIT" + PosType_PRIVATELY_NEGOTIATED_TRADE_QTY = "PNTN" + PosType_RECEIVE_QUANTITY = "RCV" + PosType_SUCCESSION_EVENT_ADJUSTMENT = "SEA" + PosType_START_OF_DAY_QTY = "SOD" + PosType_INTEGRAL_SPLIT = "SPL" + PosType_TRANSACTION_FROM_ASSIGNMENT = "TA" + PosType_TOTAL_TRANSACTION_QTY = "TOT" + PosType_TRANSACTION_QUANTITY = "TQ" + PosType_TRANSFER_TRADE_QTY = "TRF" + PosType_TRANSACTION_FROM_EXERCISE = "TX" + PosType_CROSS_MARGIN_QTY = "XM" +) + +//Enum values for PositionEffect +const ( + PositionEffect_CLOSE = "C" + PositionEffect_DEFAULT = "D" + PositionEffect_FIFO = "F" + PositionEffect_CLOSE_BUT_NOTIFY_ON_OPEN = "N" + PositionEffect_OPEN = "O" + PositionEffect_ROLLED = "R" +) + +//Enum values for PossDupFlag +const ( + PossDupFlag_NO = "N" + PossDupFlag_YES = "Y" +) + +//Enum values for PossResend +const ( + PossResend_NO = "N" + PossResend_YES = "Y" +) + +//Enum values for PreallocMethod +const ( + PreallocMethod_PRO_RATA = "0" + PreallocMethod_DO_NOT_PRO_RATA = "1" +) + +//Enum values for PreviouslyReported +const ( + PreviouslyReported_NO = "N" + PreviouslyReported_YES = "Y" +) + +//Enum values for PriceLimitType +const ( + PriceLimitType_PRICE = "0" + PriceLimitType_TICKS = "1" + PriceLimitType_PERCENTAGE = "2" +) + +//Enum values for PriceProtectionScope +const ( + PriceProtectionScope_NONE = "0" + PriceProtectionScope_LOCAL = "1" + PriceProtectionScope_NATIONAL = "2" + PriceProtectionScope_GLOBAL = "3" +) + +//Enum values for PriceQuoteMethod +const ( + PriceQuoteMethod_INTEREST_RATE_INDEX = "INT" + PriceQuoteMethod_INDEX = "INX" + PriceQuoteMethod_PERCENT_OF_PAR = "PCTPAR" + PriceQuoteMethod_STANDARD = "STD" +) + +//Enum values for PriceType +const ( + PriceType_PERCENTAGE = "1" + PriceType_FIXED_CABINET_TRADE_PRICE = "10" + PriceType_VARIABLE_CABINET_TRADE_PRICE = "11" + PriceType_PRODUCT_TICKS_IN_HALFS = "13" + PriceType_PRODUCT_TICKS_IN_FOURTHS = "14" + PriceType_PRODUCT_TICKS_IN_EIGHTS = "15" + PriceType_PRODUCT_TICKS_IN_SIXTEENTHS = "16" + PriceType_PRODUCT_TICKS_IN_THIRTY_SECONDS = "17" + PriceType_PRODUCT_TICKS_IN_SIXTY_FORTHS = "18" + PriceType_PRODUCT_TICKS_IN_ONE_TWENTY_EIGHTS = "19" + PriceType_PER_UNIT = "2" + PriceType_FIXED_AMOUNT = "3" + PriceType_DISCOUNT = "4" + PriceType_PREMIUM = "5" + PriceType_SPREAD = "6" + PriceType_TED_PRICE = "7" + PriceType_TED_YIELD = "8" + PriceType_YIELD = "9" +) + +//Enum values for PriorityIndicator +const ( + PriorityIndicator_PRIORITY_UNCHANGED = "0" + PriorityIndicator_LOST_PRIORITY_AS_RESULT_OF_ORDER_CHANGE = "1" +) + +//Enum values for ProcessCode +const ( + ProcessCode_REGULAR = "0" + ProcessCode_SOFT_DOLLAR = "1" + ProcessCode_STEP_IN = "2" + ProcessCode_STEP_OUT = "3" + ProcessCode_SOFT_DOLLAR_STEP_IN = "4" + ProcessCode_SOFT_DOLLAR_STEP_OUT = "5" + ProcessCode_PLAN_SPONSOR = "6" +) + +//Enum values for Product +const ( + Product_AGENCY = "1" + Product_MORTGAGE = "10" + Product_MUNICIPAL = "11" + Product_OTHER = "12" + Product_FINANCING = "13" + Product_COMMODITY = "2" + Product_CORPORATE = "3" + Product_CURRENCY = "4" + Product_EQUITY = "5" + Product_GOVERNMENT = "6" + Product_INDEX = "7" + Product_LOAN = "8" + Product_MONEYMARKET = "9" +) + +//Enum values for ProgRptReqs +const ( + ProgRptReqs_BUY_SIDE_EXPLICITLY_REQUESTS_STATUS_USING_STATUE_REQUEST = "1" + ProgRptReqs_SELL_SIDE_PERIODICALLY_SENDS_STATUS_USING_LIST_STATUS_PERIOD_OPTIONALLY_SPECIFIED_IN_PROGRESSPERIOD = "2" + ProgRptReqs_REAL_TIME_EXECUTION_REPORTS = "3" +) + +//Enum values for PublishTrdIndicator +const ( + PublishTrdIndicator_NO = "N" + PublishTrdIndicator_YES = "Y" +) + +//Enum values for PutOrCall +const ( + PutOrCall_PUT = "0" + PutOrCall_CALL = "1" +) + +//Enum values for QtyType +const ( + QtyType_UNITS = "0" + QtyType_CONTRACTS = "1" + QtyType_UNITS_OF_MEASURE_PER_TIME_UNIT = "2" +) + +//Enum values for QuantityType +const ( + QuantityType_SHARES = "1" + QuantityType_BONDS = "2" + QuantityType_CURRENTFACE = "3" + QuantityType_ORIGINALFACE = "4" + QuantityType_CURRENCY = "5" + QuantityType_CONTRACTS = "6" + QuantityType_OTHER = "7" + QuantityType_PAR = "8" +) + +//Enum values for QuoteAckStatus +const ( + QuoteAckStatus_ACCEPTED = "0" + QuoteAckStatus_CANCELED_FOR_SYMBOL = "1" + QuoteAckStatus_CANCELED_FOR_SECURITY_TYPE = "2" + QuoteAckStatus_CANCELED_FOR_UNDERLYING = "3" + QuoteAckStatus_CANCELED_ALL = "4" + QuoteAckStatus_REJECTED = "5" +) + +//Enum values for QuoteCancelType +const ( + QuoteCancelType_CANCEL_FOR_ONE_OR_MORE_SECURITIES = "1" + QuoteCancelType_CANCEL_FOR_SECURITY_TYPE = "2" + QuoteCancelType_CANCEL_FOR_UNDERLYING_SECURITY = "3" + QuoteCancelType_CANCEL_ALL_QUOTES = "4" + QuoteCancelType_CANCEL_QUOTE_SPECIFIED_IN_QUOTEID = "5" + QuoteCancelType_CANCEL_BY_QUOTETYPE = "6" + QuoteCancelType_CANCEL_FOR_SECURITY_ISSUER = "7" + QuoteCancelType_CANCEL_FOR_ISSUER_OF_UNDERLYING_SECURITY = "8" +) + +//Enum values for QuoteCondition +const ( + QuoteCondition_RESERVED_SAM = "0" + QuoteCondition_NO_ACTIVE_SAM = "1" + QuoteCondition_RESTRICTED = "2" + QuoteCondition_REST_OF_BOOK_VWAP = "3" + QuoteCondition_BETTER_PRICES_IN_CONDITIONAL_ORDERS = "4" + QuoteCondition_MEDIAN_PRICE = "5" + QuoteCondition_FULL_CURVE = "6" + QuoteCondition_FLAT_CURVE = "7" + QuoteCondition_OPEN_ACTIVE = "A" + QuoteCondition_CLOSED_INACTIVE = "B" + QuoteCondition_EXCHANGE_BEST = "C" + QuoteCondition_CONSOLIDATED_BEST = "D" + QuoteCondition_LOCKED = "E" + QuoteCondition_CROSSED = "F" + QuoteCondition_DEPTH = "G" + QuoteCondition_FAST_TRADING = "H" + QuoteCondition_NON_FIRM = "I" + QuoteCondition_OUTRIGHT_PRICE = "J" + QuoteCondition_IMPLIED_PRICE = "K" + QuoteCondition_MANUAL_SLOW_QUOTE = "L" + QuoteCondition_DEPTH_ON_OFFER = "M" + QuoteCondition_DEPTH_ON_BID = "N" + QuoteCondition_CLOSING = "O" + QuoteCondition_NEWS_DISSEMINATION = "P" + QuoteCondition_TRADING_RANGE = "Q" + QuoteCondition_ORDER_INFLUX = "R" + QuoteCondition_DUE_TO_RELATED = "S" + QuoteCondition_NEWS_PENDING = "T" + QuoteCondition_ADDITIONAL_INFO = "U" + QuoteCondition_ADDITIONAL_INFO_DUE_TO_RELATED = "V" + QuoteCondition_RESUME = "W" + QuoteCondition_VIEW_OF_COMMON = "X" + QuoteCondition_VOLUME_ALERT = "Y" + QuoteCondition_ORDER_IMBALANCE = "Z" + QuoteCondition_EQUIPMENT_CHANGEOVER = "a" + QuoteCondition_NO_OPEN = "b" + QuoteCondition_REGULAR_ETH = "c" + QuoteCondition_AUTOMATIC_EXECUTION = "d" + QuoteCondition_AUTOMATIC_EXECUTION_ETH = "e" + QuoteCondition_FAST_MARKET_ETH = "f " + QuoteCondition_INACTIVE_ETH = "g" + QuoteCondition_ROTATION = "h" + QuoteCondition_ROTATION_ETH = "i" + QuoteCondition_HALT = "j" + QuoteCondition_HALT_ETH = "k" + QuoteCondition_DUE_TO_NEWS_DISSEMINATION = "l" + QuoteCondition_DUE_TO_NEWS_PENDING = "m" + QuoteCondition_TRADING_RESUME = "n" + QuoteCondition_OUT_OF_SEQUENCE = "o" + QuoteCondition_BID_SPECIALIST = "p" + QuoteCondition_OFFER_SPECIALIST = "q" + QuoteCondition_BID_OFFER_SPECIALIST = "r" + QuoteCondition_END_OF_DAY_SAM = "s" + QuoteCondition_FORBIDDEN_SAM = "t" + QuoteCondition_FROZEN_SAM = "u" + QuoteCondition_PREOPENING_SAM = "v" + QuoteCondition_OPENING_SAM = "w" + QuoteCondition_OPEN_SAM = "x" + QuoteCondition_SURVEILLANCE_SAM = "y" + QuoteCondition_SUSPENDED_SAM = "z" +) + +//Enum values for QuoteEntryRejectReason +const ( + QuoteEntryRejectReason_UNKNOWN_SYMBOL = "1" + QuoteEntryRejectReason_EXHCNAGE = "2" + QuoteEntryRejectReason_QUOTE_EXCEEDS_LIMIT = "3" + QuoteEntryRejectReason_TOO_LATE_TO_ENTER = "4" + QuoteEntryRejectReason_UNKNOWN_QUOTE = "5" + QuoteEntryRejectReason_DUPLICATE_QUOTE = "6" + QuoteEntryRejectReason_INVALID_BID_ASK_SPREAD = "7" + QuoteEntryRejectReason_INVALID_PRICE = "8" + QuoteEntryRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY = "9" + QuoteEntryRejectReason_OTHER = "99" +) + +//Enum values for QuoteEntryStatus +const ( + QuoteEntryStatus_ACCEPTED = "0" + QuoteEntryStatus_LOCKED_MARKET_WARNING = "12" + QuoteEntryStatus_CROSS_MARKET_WARNING = "13" + QuoteEntryStatus_CANCELED_DUE_TO_LOCK_MARKET = "14" + QuoteEntryStatus_CANCELED_DUE_TO_CROSS_MARKET = "15" + QuoteEntryStatus_ACTIVE = "16" + QuoteEntryStatus_REJECTED = "5" + QuoteEntryStatus_REMOVED_FROM_MARKET = "6" + QuoteEntryStatus_EXPIRED = "7" +) + +//Enum values for QuotePriceType +const ( + QuotePriceType_PERCENT = "1" + QuotePriceType_YIELD = "10" + QuotePriceType_PER_SHARE = "2" + QuotePriceType_FIXED_AMOUNT = "3" + QuotePriceType_DISCOUNT = "4" + QuotePriceType_PREMIUM = "5" + QuotePriceType_SPREAD = "6" + QuotePriceType_TED_PRICE = "7" + QuotePriceType_TED_YIELD = "8" + QuotePriceType_YIELD_SPREAD = "9" +) + +//Enum values for QuoteRejectReason +const ( + QuoteRejectReason_UNKNOWN_SYMBOL = "1" + QuoteRejectReason_PRICE_EXCEEDS_CURRENT_PRICE_BAND = "10" + QuoteRejectReason_QUOTE_LOCKED = "11" + QuoteRejectReason_INVALID_OR_UNKNOWN_SECURITY_ISSUER = "12" + QuoteRejectReason_INVALID_OR_UNKNOWN_ISSUER_OF_UNDERLYING_SECURITY = "13" + QuoteRejectReason_EXCHANGE = "2" + QuoteRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT = "3" + QuoteRejectReason_TOO_LATE_TO_ENTER = "4" + QuoteRejectReason_UNKNOWN_QUOTE = "5" + QuoteRejectReason_DUPLICATE_QUOTE = "6" + QuoteRejectReason_INVALID_BID_ASK_SPREAD = "7" + QuoteRejectReason_INVALID_PRICE = "8" + QuoteRejectReason_NOT_AUTHORIZED_TO_QUOTE_SECURITY = "9" + QuoteRejectReason_OTHER = "99" +) + +//Enum values for QuoteRequestRejectReason +const ( + QuoteRequestRejectReason_UNKNOWN_SYMBOL = "1" + QuoteRequestRejectReason_PASS = "10" + QuoteRequestRejectReason_INSUFFICIENT_CREDIT = "11" + QuoteRequestRejectReason_EXCHANGE = "2" + QuoteRequestRejectReason_QUOTE_REQUEST_EXCEEDS_LIMIT = "3" + QuoteRequestRejectReason_TOO_LATE_TO_ENTER = "4" + QuoteRequestRejectReason_INVALID_PRICE = "5" + QuoteRequestRejectReason_NOT_AUTHORIZED_TO_REQUEST_QUOTE = "6" + QuoteRequestRejectReason_NO_MATCH_FOR_INQUIRY = "7" + QuoteRequestRejectReason_NO_MARKET_FOR_INSTRUMENT = "8" + QuoteRequestRejectReason_NO_INVENTORY = "9" + QuoteRequestRejectReason_OTHER = "99" +) + +//Enum values for QuoteRequestType +const ( + QuoteRequestType_MANUAL = "1" + QuoteRequestType_AUTOMATIC = "2" +) + +//Enum values for QuoteRespType +const ( + QuoteRespType_HIT_LIFT = "1" + QuoteRespType_COUNTER = "2" + QuoteRespType_EXPIRED = "3" + QuoteRespType_COVER = "4" + QuoteRespType_DONE_AWAY = "5" + QuoteRespType_PASS = "6" + QuoteRespType_END_TRADE = "7" + QuoteRespType_TIMED_OUT = "8" +) + +//Enum values for QuoteResponseLevel +const ( + QuoteResponseLevel_NO_ACKNOWLEDGEMENT = "0" + QuoteResponseLevel_ACKNOWLEDGE_ONLY_NEGATIVE_OR_ERRONEOUS_QUOTES = "1" + QuoteResponseLevel_ACKNOWLEDGE_EACH_QUOTE_MESSAGE = "2" + QuoteResponseLevel_SUMMARY_ACKNOWLEDGEMENT = "3" +) + +//Enum values for QuoteStatus +const ( + QuoteStatus_ACCEPTED = "0" + QuoteStatus_CANCEL_FOR_SYMBOL = "1" + QuoteStatus_PENDING = "10" + QuoteStatus_PASS = "11" + QuoteStatus_LOCKED_MARKET_WARNING = "12" + QuoteStatus_CROSS_MARKET_WARNING = "13" + QuoteStatus_CANCELED_DUE_TO_LOCK_MARKET = "14" + QuoteStatus_CANCELED_DUE_TO_CROSS_MARKET = "15" + QuoteStatus_ACTIVE = "16" + QuoteStatus_CANCELED = "17" + QuoteStatus_UNSOLICITED_QUOTE_REPLENISHMENT = "18" + QuoteStatus_PENDING_END_TRADE = "19" + QuoteStatus_CANCELED_FOR_SECURITY_TYPE = "2" + QuoteStatus_TOO_LATE_TO_END = "20" + QuoteStatus_CANCELED_FOR_UNDERLYING = "3" + QuoteStatus_CANCELED_ALL = "4" + QuoteStatus_REJECTED = "5" + QuoteStatus_REMOVED_FROM_MARKET = "6" + QuoteStatus_EXPIRED = "7" + QuoteStatus_QUERY = "8" + QuoteStatus_QUOTE_NOT_FOUND = "9" +) + +//Enum values for QuoteType +const ( + QuoteType_INDICATIVE = "0" + QuoteType_TRADEABLE = "1" + QuoteType_RESTRICTED_TRADEABLE = "2" + QuoteType_COUNTER = "3" +) + +//Enum values for RateSource +const ( + RateSource_BLOOMBERG = "0" + RateSource_REUTERS = "1" + RateSource_TELERATE = "2" + RateSource_OTHER = "99" +) + +//Enum values for RateSourceType +const ( + RateSourceType_PRIMARY = "0" + RateSourceType_SECONDARY = "1" +) + +//Enum values for RefOrdIDReason +const ( + RefOrdIDReason_GTC_FROM_PREVIOUS_DAY = "0" + RefOrdIDReason_PARTIAL_FILL_REMAINING = "1" + RefOrdIDReason_ORDER_CHANGED = "2" +) + +//Enum values for RefOrderIDSource +const ( + RefOrderIDSource_SECONDARYORDERID = "0" + RefOrderIDSource_ORDERID = "1" + RefOrderIDSource_MDENTRYID = "2" + RefOrderIDSource_QUOTEENTRYID = "3" + RefOrderIDSource_ORIGINAL_ORDER_ID = "4" +) + +//Enum values for RegistRejReasonCode +const ( + RegistRejReasonCode_INVALID_UNACCEPTABLE_ACCOUNT_TYPE = "1" + RegistRejReasonCode_INVALID_UNACEEPTABLE_INVESTOR_ID_SOURCE = "10" + RegistRejReasonCode_INVALID_UNACCEPTABLE_DATE_OF_BIRTH = "11" + RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_COUNTRY_OF_RESIDENCE = "12" + RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_DISTRIB_INSTNS = "13" + RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PERCENTAGE = "14" + RegistRejReasonCode_INVALID_UNACCEPTABLE_DISTRIB_PAYMENT_METHOD = "15" + RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NAME = "16" + RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_CODE = "17" + RegistRejReasonCode_INVALID_UNACCEPTABLE_CASH_DISTRIB_AGENT_ACCT_NUM = "18" + RegistRejReasonCode_INVALID_UNACCEPTABLE_TAX_EXEMPT_TYPE = "2" + RegistRejReasonCode_INVALID_UNACCEPTABLE_OWNERSHIP_TYPE = "3" + RegistRejReasonCode_INVALID_UNACCEPTABLE_NO_REG_DETAILS = "4" + RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_SEQ_NO = "5" + RegistRejReasonCode_INVALID_UNACCEPTABLE_REG_DETAILS = "6" + RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_DETAILS = "7" + RegistRejReasonCode_INVALID_UNACCEPTABLE_MAILING_INSTRUCTIONS = "8" + RegistRejReasonCode_INVALID_UNACCEPTABLE_INVESTOR_ID = "9" + RegistRejReasonCode_OTHER = "99" +) + +//Enum values for RegistStatus +const ( + RegistStatus_ACCEPTED = "A" + RegistStatus_HELD = "H" + RegistStatus_REMINDER = "N" + RegistStatus_REJECTED = "R" +) + +//Enum values for RegistTransType +const ( + RegistTransType_NEW = "0" + RegistTransType_REPLACE = "1" + RegistTransType_CANCEL = "2" +) + +//Enum values for ReportToExch +const ( + ReportToExch_NO = "N" + ReportToExch_YES = "Y" +) + +//Enum values for ResetSeqNumFlag +const ( + ResetSeqNumFlag_NO = "N" + ResetSeqNumFlag_YES = "Y" +) + +//Enum values for RespondentType +const ( + RespondentType_ALL_MARKET_PARTICIPANTS = "1" + RespondentType_SPECIFIED_MARKET_PARTICIPANTS = "2" + RespondentType_ALL_MARKET_MAKERS = "3" + RespondentType_PRIMARY_MARKET_MAKER = "4" +) + +//Enum values for ResponseTransportType +const ( + ResponseTransportType_INBAND = "0" + ResponseTransportType_OUT_OF_BAND = "1" +) + +//Enum values for RestructuringType +const ( + RestructuringType_FULL_RESTRUCTURING = "FR" + RestructuringType_MODIFIED_MOD_RESTRUCTURING = "MM" + RestructuringType_MODIFIED_RESTRUCTURING = "MR" + RestructuringType_NO_RESTRUCTURING_SPECIFIED = "XR" +) + +//Enum values for RiskInstrumentOperator +const ( + RiskInstrumentOperator_INCLUDE = "1" + RiskInstrumentOperator_EXCLUDE = "2" +) + +//Enum values for RiskLimitType +const ( + RiskLimitType_GROSS_LIMIT = "1" + RiskLimitType_NET_LIMIT = "2" + RiskLimitType_EXPOSURE = "3" + RiskLimitType_LONG_LIMIT = "4" + RiskLimitType_SHORT_LIMIT = "5" +) + +//Enum values for RoundingDirection +const ( + RoundingDirection_ROUND_TO_NEAREST = "0" + RoundingDirection_ROUND_DOWN = "1" + RoundingDirection_ROUND_UP = "2" +) + +//Enum values for RoutingType +const ( + RoutingType_TARGET_FIRM = "1" + RoutingType_TARGET_LIST = "2" + RoutingType_BLOCK_FIRM = "3" + RoutingType_BLOCK_LIST = "4" +) + +//Enum values for Rule80A +const ( + Rule80A_AGENCY_SINGLE_ORDER = "A" + Rule80A_SHORT_EXEMPT_TRANSACTION_B = "B" + Rule80A_PROPRIETARY_NON_ALGORITHMIC_PROGRAM_TRADE = "C" + Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_MEMBER_FIRM_ORG = "D" + Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_PRINCIPAL = "E" + Rule80A_SHORT_EXEMPT_TRANSACTION_F = "F" + Rule80A_SHORT_EXEMPT_TRANSACTION_H = "H" + Rule80A_INDIVIDUAL_INVESTOR_SINGLE_ORDER = "I" + Rule80A_PROPRIETARY_ALGORITHMIC_PROGRAM_TRADING = "J" + Rule80A_AGENCY_ALGORITHMIC_PROGRAM_TRADING = "K" + Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_AFFLIATED_WITH_THE_FIRM_CLEARING_THE_TRADE = "L" + Rule80A_PROGRAM_ORDER_INDEX_ARB_FOR_OTHER_MEMBER = "M" + Rule80A_AGENT_FOR_OTHER_MEMBER_NON_ALGORITHMIC_PROGRAM_TRADE = "N" + Rule80A_PROPRIETARY_TRANSACTIONS_FOR_COMPETING_MARKET_MAKER_THAT_IS_AFFILIATED_WITH_THE_CLEARING_MEMBER = "O" + Rule80A_PRINCIPAL = "P" + Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_A_NON_MEMBER_COMPTING_MARKET_MAKER = "R" + Rule80A_SPECIALIST_TRADES = "S" + Rule80A_TRANSACTIONS_FOR_THE_ACCOUNT_OF_AN_UNAFFILIATED_MEMBERS_COMPETING_MARKET_MAKER = "T" + Rule80A_AGENCY_INDEX_ARBITRAGE = "U" + Rule80A_ALL_OTHER_ORDERS_AS_AGENT_FOR_OTHER_MEMBER = "W" + Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_MEMBER_COMPETING_MARKET_MAKER_NOT_AFFILIATED_WITH_THE_FIRM_CLEARING_THE_TRADE = "X" + Rule80A_AGENCY_NON_ALGORITHMIC_PROGRAM_TRADE = "Y" + Rule80A_SHORT_EXEMPT_TRANSACTION_FOR_NON_MEMBER_COMPETING_MARKET_MAKER = "Z" +) + +//Enum values for Scope +const ( + Scope_LOCAL_MARKET = "1" + Scope_NATIONAL = "2" + Scope_GLOBAL = "3" +) + +//Enum values for SecDefStatus +const ( + SecDefStatus_PENDING_APPROVAL = "0" + SecDefStatus_APPROVED = "1" + SecDefStatus_REJECTED = "2" + SecDefStatus_UNAUTHORIZED_REQUEST = "3" + SecDefStatus_INVALID_DEFINITION_REQUEST = "4" +) + +//Enum values for SecurityIDSource +const ( + SecurityIDSource_CUSIP = "1" + SecurityIDSource_SEDOL = "2" + SecurityIDSource_QUIK = "3" + SecurityIDSource_ISIN_NUMBER = "4" + SecurityIDSource_RIC_CODE = "5" + SecurityIDSource_ISO_CURRENCY_CODE = "6" + SecurityIDSource_ISO_COUNTRY_CODE = "7" + SecurityIDSource_EXCHANGE_SYMBOL = "8" + SecurityIDSource_CONSOLIDATED_TAPE_ASSOCIATION = "9" + SecurityIDSource_BLOOMBERG_SYMBOL = "A" + SecurityIDSource_WERTPAPIER = "B" + SecurityIDSource_DUTCH = "C" + SecurityIDSource_VALOREN = "D" + SecurityIDSource_SICOVAM = "E" + SecurityIDSource_BELGIAN = "F" + SecurityIDSource_COMMON = "G" + SecurityIDSource_CLEARING_HOUSE = "H" + SecurityIDSource_ISDA_FPML_PRODUCT_SPECIFICATION = "I" + SecurityIDSource_OPTION_PRICE_REPORTING_AUTHORITY = "J" + SecurityIDSource_ISDA_FPML_PRODUCT_URL = "K" + SecurityIDSource_LETTER_OF_CREDIT = "L" + SecurityIDSource_MARKETPLACE_ASSIGNED_IDENTIFIER = "M" +) + +//Enum values for SecurityListRequestType +const ( + SecurityListRequestType_SYMBOL = "0" + SecurityListRequestType_SECURITYTYPE_AND_OR_CFICODE = "1" + SecurityListRequestType_PRODUCT = "2" + SecurityListRequestType_TRADINGSESSIONID = "3" + SecurityListRequestType_ALL_SECURITIES = "4" + SecurityListRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID = "5" +) + +//Enum values for SecurityListType +const ( + SecurityListType_INDUSTRY_CLASSIFICATION = "1" + SecurityListType_TRADING_LIST = "2" + SecurityListType_MARKET = "3" + SecurityListType_NEWSPAPER_LIST = "4" +) + +//Enum values for SecurityListTypeSource +const ( + SecurityListTypeSource_ICB = "1" + SecurityListTypeSource_NAICS = "2" + SecurityListTypeSource_GICS = "3" +) + +//Enum values for SecurityRequestResult +const ( + SecurityRequestResult_VALID_REQUEST = "0" + SecurityRequestResult_INVALID_OR_UNSUPPORTED_REQUEST = "1" + SecurityRequestResult_NO_INSTRUMENTS_FOUND_THAT_MATCH_SELECTION_CRITERIA = "2" + SecurityRequestResult_NOT_AUTHORIZED_TO_RETRIEVE_INSTRUMENT_DATA = "3" + SecurityRequestResult_INSTRUMENT_DATA_TEMPORARILY_UNAVAILABLE = "4" + SecurityRequestResult_REQUEST_FOR_INSTRUMENT_DATA_NOT_SUPPORTED = "5" +) + +//Enum values for SecurityRequestType +const ( + SecurityRequestType_REQUEST_SECURITY_IDENTITY_AND_SPECIFICATIONS = "0" + SecurityRequestType_REQUEST_SECURITY_IDENTITY_FOR_THE_SPECIFICATIONS_PROVIDED = "1" + SecurityRequestType_REQUEST_LIST_SECURITY_TYPES = "2" + SecurityRequestType_REQUEST_LIST_SECURITIES = "3" + SecurityRequestType_SYMBOL = "4" + SecurityRequestType_SECURITYTYPE_AND_OR_CFICODE = "5" + SecurityRequestType_PRODUCT = "6" + SecurityRequestType_TRADINGSESSIONID = "7" + SecurityRequestType_ALL_SECURITIES = "8" + SecurityRequestType_MARKETID_OR_MARKETID_PLUS_MARKETSEGMENTID = "9" +) + +//Enum values for SecurityResponseType +const ( + SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_AS_IS = "1" + SecurityResponseType_ACCEPT_SECURITY_PROPOSAL_WITH_REVISIONS_AS_INDICATED_IN_THE_MESSAGE = "2" + SecurityResponseType_LIST_OF_SECURITY_TYPES_RETURNED_PER_REQUEST = "3" + SecurityResponseType_LIST_OF_SECURITIES_RETURNED_PER_REQUEST = "4" + SecurityResponseType_REJECT_SECURITY_PROPOSAL = "5" + SecurityResponseType_CANNOT_MATCH_SELECTION_CRITERIA = "6" +) + +//Enum values for SecurityStatus +const ( + SecurityStatus_ACTIVE = "1" + SecurityStatus_INACTIVE = "2" +) + +//Enum values for SecurityTradingEvent +const ( + SecurityTradingEvent_ORDER_IMBALANCE_AUCTION_IS_EXTENDED = "1" + SecurityTradingEvent_TRADING_RESUMES = "2" + SecurityTradingEvent_PRICE_VOLATILITY_INTERRUPTION = "3" + SecurityTradingEvent_CHANGE_OF_TRADING_SESSION = "4" + SecurityTradingEvent_CHANGE_OF_TRADING_SUBSESSION = "5" + SecurityTradingEvent_CHANGE_OF_SECURITY_TRADING_STATUS = "6" + SecurityTradingEvent_CHANGE_OF_BOOK_TYPE = "7" + SecurityTradingEvent_CHANGE_OF_MARKET_DEPTH = "8" +) + +//Enum values for SecurityTradingStatus +const ( + SecurityTradingStatus_OPENING_DELAY = "1" + SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_SELL = "10" + SecurityTradingStatus_11 = "11" + SecurityTradingStatus_NO_MARKET_IMBALANCE = "12" + SecurityTradingStatus_NO_MARKET_ON_CLOSE_IMBALANCE = "13" + SecurityTradingStatus_ITS_PRE_OPENING = "14" + SecurityTradingStatus_NEW_PRICE_INDICATION = "15" + SecurityTradingStatus_TRADE_DISSEMINATION_TIME = "16" + SecurityTradingStatus_READY_TO_TRADE = "17" + SecurityTradingStatus_NOT_AVAILABLE_FOR_TRADING = "18" + SecurityTradingStatus_NOT_TRADED_ON_THIS_MARKET = "19" + SecurityTradingStatus_TRADING_HALT = "2" + SecurityTradingStatus_UNKNOWN_OR_INVALID = "20" + SecurityTradingStatus_PRE_OPEN = "21" + SecurityTradingStatus_OPENING_ROTATION = "22" + SecurityTradingStatus_FAST_MARKET = "23" + SecurityTradingStatus_PRE_CROSS = "24" + SecurityTradingStatus_CROSS = "25" + SecurityTradingStatus_POST_CLOSE = "26" + SecurityTradingStatus_RESUME = "3" + SecurityTradingStatus_NO_OPEN = "4" + SecurityTradingStatus_PRICE_INDICATION = "5" + SecurityTradingStatus_TRADING_RANGE_INDICATION = "6" + SecurityTradingStatus_MARKET_IMBALANCE_BUY = "7" + SecurityTradingStatus_MARKET_IMBALANCE_SELL = "8" + SecurityTradingStatus_MARKET_ON_CLOSE_IMBALANCE_BUY = "9" +) + +//Enum values for SecurityType +const ( + SecurityType_WILDCARD_ENTRY_FOR_USE_ON_SECURITY_DEFINITION_REQUEST = "?" + SecurityType_ASSET_BACKED_SECURITIES = "ABS" + SecurityType_AMENDED_RESTATED = "AMENDED" + SecurityType_OTHER_ANTICIPATION_NOTES = "AN" + SecurityType_BANKERS_ACCEPTANCE = "BA" + SecurityType_BANK_DEPOSITORY_NOTE = "BDN" + SecurityType_BANK_NOTES = "BN" + SecurityType_BILL_OF_EXCHANGES = "BOX" + SecurityType_BRADY_BOND = "BRADY" + SecurityType_BRIDGE_LOAN = "BRIDGE" + SecurityType_BUY_SELLBACK = "BUYSELL" + SecurityType_CANADIAN_MONEY_MARKETS = "CAMM" + SecurityType_CANADIAN_TREASURY_NOTES = "CAN" + SecurityType_CASH = "CASH" + SecurityType_CONVERTIBLE_BOND = "CB" + SecurityType_CERTIFICATE_OF_DEPOSIT = "CD" + SecurityType_CREDIT_DEFAULT_SWAP = "CDS" + SecurityType_CALL_LOANS = "CL" + SecurityType_CANADIAN_MORTGAGE_BONDS = "CMB" + SecurityType_CORP_MORTGAGE_BACKED_SECURITIES = "CMBS" + SecurityType_COLLATERALIZED_MORTGAGE_OBLIGATION = "CMO" + SecurityType_CERTIFICATE_OF_OBLIGATION = "COFO" + SecurityType_CERTIFICATE_OF_PARTICIPATION = "COFP" + SecurityType_CORPORATE_BOND = "CORP" + SecurityType_COMMERCIAL_PAPER = "CP" + SecurityType_CORPORATE_PRIVATE_PLACEMENT = "CPP" + SecurityType_COMMON_STOCK = "CS" + SecurityType_CANADIAN_TREASURY_BILLS = "CTB" + SecurityType_DEFAULTED = "DEFLTED" + SecurityType_DEBTOR_IN_POSSESSION = "DINP" + SecurityType_DEPOSIT_NOTES = "DN" + SecurityType_DUAL_CURRENCY = "DUAL" + SecurityType_EURO_CERTIFICATE_OF_DEPOSIT = "EUCD" + SecurityType_EURO_CORPORATE_BOND = "EUCORP" + SecurityType_EURO_COMMERCIAL_PAPER = "EUCP" + SecurityType_EURO_CORPORATE_FLOATING_RATE_NOTES = "EUFRN" + SecurityType_EURO_SOVEREIGNS = "EUSOV" + SecurityType_EURO_SUPRANATIONAL_COUPONS = "EUSUPRA" + SecurityType_FEDERAL_AGENCY_COUPON = "FAC" + SecurityType_FEDERAL_AGENCY_DISCOUNT_NOTE = "FADN" + SecurityType_FEDERAL_HOUSING_AUTHORITY = "FHA" + SecurityType_FEDERAL_HOME_LOAN = "FHL" + SecurityType_FEDERAL_NATIONAL_MORTGAGE_ASSOCIATION = "FN" + SecurityType_FOREIGN_EXCHANGE_CONTRACT = "FOR" + SecurityType_FORWARD = "FORWARD" + SecurityType_US_CORPORATE_FLOATING_RATE_NOTES = "FRN" + SecurityType_FUTURE = "FUT" + SecurityType_FX_FORWARD = "FXFWD" + SecurityType_NON_DELIVERABLE_FORWARD = "FXNDF" + SecurityType_FX_SPOT = "FXSPOT" + SecurityType_FX_SWAP = "FXSWAP" + SecurityType_GOVERNMENT_NATIONAL_MORTGAGE_ASSOCIATION = "GN" + SecurityType_GENERAL_OBLIGATION_BONDS = "GO" + SecurityType_TREASURIES_PLUS_AGENCY_DEBENTURE = "GOVT" + SecurityType_IOETTE_MORTGAGE = "IET" + SecurityType_INTEREST_RATE_SWAP = "IRS" + SecurityType_LETTER_OF_CREDIT = "LOFC" + SecurityType_LIQUIDITY_NOTE = "LQN" + SecurityType_MATURED = "MATURED" + SecurityType_MORTGAGE_BACKED_SECURITIES = "MBS" + SecurityType_MUTUAL_FUND = "MF" + SecurityType_MORTGAGE_INTEREST_ONLY = "MIO" + SecurityType_MULTILEG_INSTRUMENT = "MLEG" + SecurityType_MORTGAGE_PRINCIPAL_ONLY = "MPO" + SecurityType_MORTGAGE_PRIVATE_PLACEMENT = "MPP" + SecurityType_MISCELLANEOUS_PASS_THROUGH = "MPT" + SecurityType_MANDATORY_TENDER = "MT" + SecurityType_MEDIUM_TERM_NOTES = "MTN" + SecurityType_MUNICIPAL_BOND = "MUNI" + SecurityType_NO_SECURITY_TYPE = "NONE" + SecurityType_OVERNIGHT = "ONITE" + SecurityType_OPTIONS_ON_COMBO = "OOC" + SecurityType_OPTIONS_ON_FUTURES = "OOF" + SecurityType_OPTIONS_ON_PHYSICAL = "OOP" + SecurityType_OPTION = "OPT" + SecurityType_PRIVATE_EXPORT_FUNDING = "PEF" + SecurityType_PFANDBRIEFE = "PFAND" + SecurityType_PROMISSORY_NOTE = "PN" + SecurityType_AGENCY_POOLS = "POOL" + SecurityType_CANADIAN_PROVINCIAL_BONDS = "PROV" + SecurityType_PREFERRED_STOCK = "PS" + SecurityType_PLAZOS_FIJOS = "PZFJ" + SecurityType_REVENUE_ANTICIPATION_NOTE = "RAN" + SecurityType_REPLACED = "REPLACD" + SecurityType_REPURCHASE = "REPO" + SecurityType_RETIRED = "RETIRED" + SecurityType_REVENUE_BONDS = "REV" + SecurityType_REPURCHASE_AGREEMENT = "RP" + SecurityType_REVOLVER_LOAN = "RVLV" + SecurityType_REVOLVER_TERM_LOAN = "RVLVTRM" + SecurityType_REVERSE_REPURCHASE_AGREEMENT = "RVRP" + SecurityType_SECURITIES_LOAN = "SECLOAN" + SecurityType_SECURITIES_PLEDGE = "SECPLEDGE" + SecurityType_STUDENT_LOAN_MARKETING_ASSOCIATION = "SL" + SecurityType_SECURED_LIQUIDITY_NOTE = "SLQN" + SecurityType_SPECIAL_ASSESSMENT = "SPCLA" + SecurityType_SPECIAL_OBLIGATION = "SPCLO" + SecurityType_SPECIAL_TAX = "SPCLT" + SecurityType_SHORT_TERM_LOAN_NOTE = "STN" + SecurityType_STRUCTURED_NOTES = "STRUCT" + SecurityType_USD_SUPRANATIONAL_COUPONS = "SUPRA" + SecurityType_SWING_LINE_FACILITY = "SWING" + SecurityType_TAX_ANTICIPATION_NOTE = "TAN" + SecurityType_TAX_ALLOCATION = "TAXA" + SecurityType_TREASURY_BILL = "TB" + SecurityType_TO_BE_ANNOUNCED = "TBA" + SecurityType_US_TREASURY_BILL_TBILL = "TBILL" + SecurityType_US_TREASURY_BOND = "TBOND" + SecurityType_PRINCIPAL_STRIP_OF_A_CALLABLE_BOND_OR_NOTE = "TCAL" + SecurityType_TIME_DEPOSIT = "TD" + SecurityType_TAX_EXEMPT_COMMERCIAL_PAPER = "TECP" + SecurityType_TERM_LOAN = "TERM" + SecurityType_INTEREST_STRIP_FROM_ANY_BOND_OR_NOTE = "TINT" + SecurityType_TREASURY_INFLATION_PROTECTED_SECURITIES = "TIPS" + SecurityType_TERM_LIQUIDITY_NOTE = "TLQN" + SecurityType_TAXABLE_MUNICIPAL_CP = "TMCP" + SecurityType_US_TREASURY_NOTE_TNOTE = "TNOTE" + SecurityType_PRINCIPAL_STRIP_FROM_A_NON_CALLABLE_BOND_OR_NOTE = "TPRN" + SecurityType_TAX_REVENUE_ANTICIPATION_NOTE = "TRAN" + SecurityType_US_TREASURY_NOTE_UST = "UST" + SecurityType_US_TREASURY_BILL_USTB = "USTB" + SecurityType_VARIABLE_RATE_DEMAND_NOTE = "VRDN" + SecurityType_WARRANT = "WAR" + SecurityType_WITHDRAWN = "WITHDRN" + SecurityType_WILDCARD_ENTRY = "WLD" + SecurityType_EXTENDED_COMM_NOTE = "XCN" + SecurityType_INDEXED_LINKED = "XLINKD" + SecurityType_YANKEE_CORPORATE_BOND = "YANK" + SecurityType_YANKEE_CERTIFICATE_OF_DEPOSIT = "YCD" + SecurityType_CATS_TIGERS_LIONS = "ZOO" +) + +//Enum values for SecurityUpdateAction +const ( + SecurityUpdateAction_ADD = "A" + SecurityUpdateAction_DELETE = "D" + SecurityUpdateAction_MODIFY = "M" +) + +//Enum values for Seniority +const ( + Seniority_SUBORDINATED = "SB" + Seniority_SENIOR_SECURED = "SD" + Seniority_SENIOR = "SR" +) + +//Enum values for SessionRejectReason +const ( + SessionRejectReason_INVALID_TAG_NUMBER = "0" + SessionRejectReason_REQUIRED_TAG_MISSING = "1" + SessionRejectReason_SENDINGTIME_ACCURACY_PROBLEM = "10" + SessionRejectReason_INVALID_MSGTYPE = "11" + SessionRejectReason_XML_VALIDATION_ERROR = "12" + SessionRejectReason_TAG_APPEARS_MORE_THAN_ONCE = "13" + SessionRejectReason_TAG_SPECIFIED_OUT_OF_REQUIRED_ORDER = "14" + SessionRejectReason_REPEATING_GROUP_FIELDS_OUT_OF_ORDER = "15" + SessionRejectReason_INCORRECT_NUMINGROUP_COUNT_FOR_REPEATING_GROUP = "16" + SessionRejectReason_NON_DATA_VALUE_INCLUDES_FIELD_DELIMITER = "17" + SessionRejectReason_INVALID_UNSUPPORTED_APPLICATION_VERSION = "18" + SessionRejectReason_TAG_NOT_DEFINED_FOR_THIS_MESSAGE_TYPE = "2" + SessionRejectReason_UNDEFINED_TAG = "3" + SessionRejectReason_TAG_SPECIFIED_WITHOUT_A_VALUE = "4" + SessionRejectReason_VALUE_IS_INCORRECT = "5" + SessionRejectReason_INCORRECT_DATA_FORMAT_FOR_VALUE = "6" + SessionRejectReason_DECRYPTION_PROBLEM = "7" + SessionRejectReason_SIGNATURE_PROBLEM = "8" + SessionRejectReason_COMPID_PROBLEM = "9" + SessionRejectReason_OTHER = "99" +) + +//Enum values for SessionStatus +const ( + SessionStatus_SESSION_ACTIVE = "0" + SessionStatus_SESSION_PASSWORD_CHANGED = "1" + SessionStatus_SESSION_PASSWORD_DUE_TO_EXPIRE = "2" + SessionStatus_NEW_SESSION_PASSWORD_DOES_NOT_COMPLY_WITH_POLICY = "3" + SessionStatus_SESSION_LOGOUT_COMPLETE = "4" + SessionStatus_INVALID_USERNAME_OR_PASSWORD = "5" + SessionStatus_ACCOUNT_LOCKED = "6" + SessionStatus_LOGONS_ARE_NOT_ALLOWED_AT_THIS_TIME = "7" + SessionStatus_PASSWORD_EXPIRED = "8" +) + +//Enum values for SettlCurrFxRateCalc +const ( + SettlCurrFxRateCalc_DIVIDE = "D" + SettlCurrFxRateCalc_MULTIPLY = "M" +) + +//Enum values for SettlDeliveryType +const ( + SettlDeliveryType_VERSUS_PAYMENT_DELIVER = "0" + SettlDeliveryType_FREE_DELIVER = "1" + SettlDeliveryType_TRI_PARTY = "2" + SettlDeliveryType_HOLD_IN_CUSTODY = "3" +) + +//Enum values for SettlInstMode +const ( + SettlInstMode_DEFAULT = "0" + SettlInstMode_STANDING_INSTRUCTIONS_PROVIDED = "1" + SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_OVERRIDING = "2" + SettlInstMode_SPECIFIC_ALLOCATION_ACCOUNT_STANDING = "3" + SettlInstMode_SPECIFIC_ORDER_FOR_A_SINGLE_ACCOUNT = "4" + SettlInstMode_REQUEST_REJECT = "5" +) + +//Enum values for SettlInstReqRejCode +const ( + SettlInstReqRejCode_UNABLE_TO_PROCESS_REQUEST = "0" + SettlInstReqRejCode_UNKNOWN_ACCOUNT = "1" + SettlInstReqRejCode_NO_MATCHING_SETTLEMENT_INSTRUCTIONS_FOUND = "2" + SettlInstReqRejCode_OTHER = "99" +) + +//Enum values for SettlInstSource +const ( + SettlInstSource_BROKERS_INSTRUCTIONS = "1" + SettlInstSource_INSTITUTIONS_INSTRUCTIONS = "2" + SettlInstSource_INVESTOR = "3" +) + +//Enum values for SettlInstTransType +const ( + SettlInstTransType_CANCEL = "C" + SettlInstTransType_NEW = "N" + SettlInstTransType_REPLACE = "R" + SettlInstTransType_RESTATE = "T" +) + +//Enum values for SettlLocation +const ( + SettlLocation_CEDEL = "CED" + SettlLocation_DEPOSITORY_TRUST_COMPANY = "DTC" + SettlLocation_EURO_CLEAR = "EUR" + SettlLocation_FEDERAL_BOOK_ENTRY = "FED" + SettlLocation_LOCAL_MARKET_SETTLE_LOCATION = "ISO_Country_Code" + SettlLocation_PHYSICAL = "PNY" + SettlLocation_PARTICIPANT_TRUST_COMPANY = "PTC" +) + +//Enum values for SettlMethod +const ( + SettlMethod_CASH_SETTLEMENT_REQUIRED = "C" + SettlMethod_PHYSICAL_SETTLEMENT_REQUIRED = "P" +) + +//Enum values for SettlObligMode +const ( + SettlObligMode_PRELIMINARY = "1" + SettlObligMode_FINAL = "2" +) + +//Enum values for SettlObligSource +const ( + SettlObligSource_INSTRUCTIONS_OF_BROKER = "1" + SettlObligSource_INSTRUCTIONS_FOR_INSTITUTION = "2" + SettlObligSource_INVESTOR = "3" +) + +//Enum values for SettlObligTransType +const ( + SettlObligTransType_CANCEL = "C" + SettlObligTransType_NEW = "N" + SettlObligTransType_REPLACE = "R" + SettlObligTransType_RESTATE = "T" +) + +//Enum values for SettlPriceType +const ( + SettlPriceType_FINAL = "1" + SettlPriceType_THEORETICAL = "2" +) + +//Enum values for SettlSessID +const ( + SettlSessID_END_OF_DAY = "EOD" + SettlSessID_ELECTRONIC_TRADING_HOURS = "ETH" + SettlSessID_INTRADAY = "ITD" + SettlSessID_REGULAR_TRADING_HOURS = "RTH" +) + +//Enum values for SettlType +const ( + SettlType_REGULAR = "0" + SettlType_CASH = "1" + SettlType_NEXT_DAY = "2" + SettlType_T_PLUS_2 = "3" + SettlType_T_PLUS_3 = "4" + SettlType_T_PLUS_4 = "5" + SettlType_FUTURE = "6" + SettlType_WHEN_AND_IF_ISSUED = "7" + SettlType_SELLERS_OPTION = "8" + SettlType_T_PLUS_5 = "9" + SettlType_BROKEN_DATE = "B" + SettlType_FX_SPOT_NEXT_SETTLEMENT = "C" +) + +//Enum values for SettlmntTyp +const ( + SettlmntTyp_REGULAR = "0" + SettlmntTyp_CASH = "1" + SettlmntTyp_NEXT_DAY = "2" + SettlmntTyp_T_PLUS_2 = "3" + SettlmntTyp_T_PLUS_3 = "4" + SettlmntTyp_T_PLUS_4 = "5" + SettlmntTyp_FUTURE = "6" + SettlmntTyp_WHEN_AND_IF_ISSUED = "7" + SettlmntTyp_SELLERS_OPTION = "8" + SettlmntTyp_T_PLUS_5 = "9" + SettlmntTyp_T_PLUS_1 = "A" +) + +//Enum values for ShortSaleReason +const ( + ShortSaleReason_DEALER_SOLD_SHORT = "0" + ShortSaleReason_DEALER_SOLD_SHORT_EXEMPT = "1" + ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT = "2" + ShortSaleReason_SELLING_CUSTOMER_SOLD_SHORT_EXEMPT = "3" + ShortSaleReason_QUALIFIED_SERVICE_REPRESENTATIVE = "4" + ShortSaleReason_QSR_OR_AGU_CONTRA_SIDE_SOLD_SHORT_EXEMPT = "5" +) + +//Enum values for Side +const ( + Side_BUY = "1" + Side_SELL = "2" + Side_BUY_MINUS = "3" + Side_SELL_PLUS = "4" + Side_SELL_SHORT = "5" + Side_SELL_SHORT_EXEMPT = "6" + Side_UNDISCLOSED = "7" + Side_CROSS = "8" + Side_CROSS_SHORT = "9" + Side_CROSS_SHORT_EXEMPT = "A" + Side_AS_DEFINED = "B" + Side_OPPOSITE = "C" + Side_SUBSCRIBE = "D" + Side_REDEEM = "E" + Side_LEND = "F" + Side_BORROW = "G" +) + +//Enum values for SideMultiLegReportingType +const ( + SideMultiLegReportingType_SINGLE_SECURITY = "1" + SideMultiLegReportingType_INDIVIDUAL_LEG_OF_A_MULTILEG_SECURITY = "2" + SideMultiLegReportingType_MULTILEG_SECURITY = "3" +) + +//Enum values for SideTrdSubTyp +const ( + SideTrdSubTyp_CMTA = "0" + SideTrdSubTyp_INTERNAL_TRANSFER = "1" + SideTrdSubTyp_TRANSACTION_FROM_ASSIGNMENT = "10" + SideTrdSubTyp_EXTERNAL_TRANSFER = "2" + SideTrdSubTyp_REJECT_FOR_SUBMITTING_TRADE = "3" + SideTrdSubTyp_ADVISORY_FOR_CONTRA_SIDE = "4" + SideTrdSubTyp_OFFSET_DUE_TO_AN_ALLOCATION = "5" + SideTrdSubTyp_ONSET_DUE_TO_AN_ALLOCATION = "6" + SideTrdSubTyp_DIFFERENTIAL_SPREAD = "7" + SideTrdSubTyp_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT = "8" + SideTrdSubTyp_TRANSACTION_FROM_EXERCISE = "9" +) + +//Enum values for SideValueInd +const ( + SideValueInd_SIDE_VALUE_1 = "1" + SideValueInd_SIDE_VALUE_2 = "2" +) + +//Enum values for SolicitedFlag +const ( + SolicitedFlag_NO = "N" + SolicitedFlag_YES = "Y" +) + +//Enum values for StandInstDbType +const ( + StandInstDbType_OTHER = "0" + StandInstDbType_DTC_SID = "1" + StandInstDbType_THOMSON_ALERT = "2" + StandInstDbType_A_GLOBAL_CUSTODIAN = "3" + StandInstDbType_ACCOUNTNET = "4" +) + +//Enum values for StatsType +const ( + StatsType_EXCHANGE_LAST = "1" + StatsType_HIGH = "2" + StatsType_AVERAGE_PRICE = "3" + StatsType_TURNOVER = "4" +) + +//Enum values for StatusValue +const ( + StatusValue_CONNECTED = "1" + StatusValue_NOT_CONNECTED_2 = "2" + StatusValue_NOT_CONNECTED_3 = "3" + StatusValue_IN_PROCESS = "4" +) + +//Enum values for StipulationType +const ( + StipulationType_ABSOLUTE_PREPAYMENT_SPEED = "ABS" + StipulationType_ALTERNATIVE_MINIMUM_TAX = "AMT" + StipulationType_AUTO_REINVESTMENT_AT_RATE_OR_BETTER = "AUTOREINV" + StipulationType_AVAILABLE_OFFER_QUANTITY_TO_BE_SHOWN_TO_THE_STREET = "AVAILQTY" + StipulationType_AVERAGE_FICO_SCORE = "AVFICO" + StipulationType_AVERAGE_LOAN_SIZE = "AVSIZE" + StipulationType_BANK_QUALIFIED = "BANKQUAL" + StipulationType_BARGAIN_CONDITIONS = "BGNCON" + StipulationType_BROKERS_SALES_CREDIT = "BROKERCREDIT" + StipulationType_COUPON_RANGE = "COUPON" + StipulationType_CONSTANT_PREPAYMENT_PENALTY = "CPP" + StipulationType_CONSTANT_PREPAYMENT_RATE = "CPR" + StipulationType_CONSTANT_PREPAYMENT_YIELD = "CPY" + StipulationType_ISO_CURRENCY_CODE = "CURRENCY" + StipulationType_CUSTOM_START_END_DATE = "CUSTOMDATE" + StipulationType_DISCOUNT_RATE = "DISCOUNT" + StipulationType_GEOGRAPHICS_AND_RANGE = "GEOG" + StipulationType_VALUATION_DISCOUNT = "HAIRCUT" + StipulationType_FINAL_CPR_OF_HOME_EQUITY_PREPAYMENT_CURVE = "HEP" + StipulationType_INSURED = "INSURED" + StipulationType_OFFER_PRICE_TO_BE_SHOWN_TO_INTERNAL_BROKERS = "INTERNALPX" + StipulationType_OFFER_QUANTITY_TO_BE_SHOWN_TO_INTERNAL_BROKERS = "INTERNALQTY" + StipulationType_YEAR_OR_YEAR_MONTH_OF_ISSUE = "ISSUE" + StipulationType_ISSUERS_TICKER = "ISSUER" + StipulationType_ISSUE_SIZE_RANGE = "ISSUESIZE" + StipulationType_THE_MINIMUM_RESIDUAL_OFFER_QUANTITY = "LEAVEQTY" + StipulationType_LOOKBACK_DAYS = "LOOKBACK" + StipulationType_EXPLICIT_LOT_IDENTIFIER = "LOT" + StipulationType_LOT_VARIANCE = "LOTVAR" + StipulationType_MATURITY_YEAR_AND_MONTH = "MAT" + StipulationType_MATURITY_RANGE = "MATURITY" + StipulationType_MAXIMUM_LOAN_BALANCE = "MAXBAL" + StipulationType_MAXIMUMDENOMINATION = "MAXDNOM" + StipulationType_MAXIMUM_ORDER_SIZE = "MAXORDQTY" + StipulationType_MAXIMUM_SUBSTITUTIONS = "MAXSUBS" + StipulationType_PERCENT_OF_MANUFACTURED_HOUSING_PREPAYMENT_CURVE = "MHP" + StipulationType_MINIMUM_DENOMINATION = "MINDNOM" + StipulationType_MINIMUM_INCREMENT = "MININCR" + StipulationType_MINIMUM_QUANTITY = "MINQTY" + StipulationType_MONTHLY_PREPAYMENT_RATE = "MPR" + StipulationType_ORDER_QUANTITY_INCREMENT = "ORDRINCR" + StipulationType_PAYMENT_FREQUENCY_CALENDAR = "PAYFREQ" + StipulationType_NUMBER_OF_PIECES = "PIECES" + StipulationType_POOLS_MAXIMUM = "PMAX" + StipulationType_POOLSMINIMUM = "PMIN" + StipulationType_POOL_IDENTIFIER = "POOL" + StipulationType_PERCENT_OF_PROSPECTUS_PREPAYMENT_CURVE = "PPC" + StipulationType_POOLS_PER_LOT = "PPL" + StipulationType_POOLS_PER_MILLION = "PPM" + StipulationType_POOLS_PER_TRADE = "PPT" + StipulationType_PRICE_RANGE = "PRICE" + StipulationType_PRICING_FREQUENCY = "PRICEFREQ" + StipulationType_PRIMARY_OR_SECONDARY_MARKET_INDICATOR = "PRIMARY" + StipulationType_PRODUCTION_YEAR = "PROD" + StipulationType_CALL_PROTECTION = "PROTECT" + StipulationType_PERCENT_OF_BMA_PREPAYMENT_CURVE = "PSA" + StipulationType_PURPOSE = "PURPOSE" + StipulationType_BENCHMARK_PRICE_SOURCE = "PXSOURCE" + StipulationType_RATING_SOURCE_AND_RANGE = "RATING" + StipulationType_TYPE_OF_REDEMPTION = "REDEMPTION" + StipulationType_INTEREST_OF_ROLLING_OR_CLOSING_TRADE = "REFINT" + StipulationType_PRINCIPAL_OF_ROLLING_OR_CLOSING_TRADE = "REFPRIN" + StipulationType_REFERENCE_TO_ROLLING_OR_CLOSING_TRADE = "REFTRADE" + StipulationType_RESTRICTED = "RESTRICTED" + StipulationType_TYPE_OF_ROLL_TRADE = "ROLLTYPE" + StipulationType_BROKER_SALES_CREDIT_OVERRIDE = "SALESCREDITOVR" + StipulationType_MARKET_SECTOR = "SECTOR" + StipulationType_SECURITY_TYPE_INCLUDED_OR_EXCLUDED = "SECTYPE" + StipulationType_SINGLE_MONTHLY_MORTALITY = "SMM" + StipulationType_STRUCTURE = "STRUCT" + StipulationType_SUBSTITUTIONS_FREQUENCY = "SUBSFREQ" + StipulationType_SUBSTITUTIONS_LEFT = "SUBSLEFT" + StipulationType_FREEFORM_TEXT = "TEXT" + StipulationType_TRADERS_CREDIT = "TRADERCREDIT" + StipulationType_TRADE_VARIANCE = "TRDVAR" + StipulationType_WEIGHTED_AVERAGE_COUPON = "WAC" + StipulationType_WEIGHTED_AVERAGE_LIFE_COUPON = "WAL" + StipulationType_WEIGHTED_AVERAGE_LOAN_AGE = "WALA" + StipulationType_WEIGHTED_AVERAGE_MATURITY = "WAM" + StipulationType_WHOLE_POOL = "WHOLE" + StipulationType_YIELD_RANGE = "YIELD" + StipulationType_YIELD_TO_MATURITY = "YTM" +) + +//Enum values for StrategyParameterType +const ( + StrategyParameterType_INT = "1" + StrategyParameterType_AMT = "10" + StrategyParameterType_PERCENTAGE = "11" + StrategyParameterType_CHAR = "12" + StrategyParameterType_BOOLEAN = "13" + StrategyParameterType_STRING = "14" + StrategyParameterType_MULTIPLECHARVALUE = "15" + StrategyParameterType_CURRENCY = "16" + StrategyParameterType_EXCHANGE = "17" + StrategyParameterType_MONTHYEAR = "18" + StrategyParameterType_UTCTIMESTAMP = "19" + StrategyParameterType_LENGTH = "2" + StrategyParameterType_UTCTIMEONLY = "20" + StrategyParameterType_LOCALMKTDATE = "21" + StrategyParameterType_UTCDATEONLY = "22" + StrategyParameterType_DATA = "23" + StrategyParameterType_MULTIPLESTRINGVALUE = "24" + StrategyParameterType_COUNTRY = "25" + StrategyParameterType_LANGUAGE = "26" + StrategyParameterType_TZTIMEONLY = "27" + StrategyParameterType_TZTIMESTAMP = "28" + StrategyParameterType_TENOR = "29" + StrategyParameterType_NUMINGROUP = "3" + StrategyParameterType_SEQNUM = "4" + StrategyParameterType_TAGNUM = "5" + StrategyParameterType_FLOAT = "6" + StrategyParameterType_QTY = "7" + StrategyParameterType_PRICE = "8" + StrategyParameterType_PRICEOFFSET = "9" +) + +//Enum values for StreamAsgnAckType +const ( + StreamAsgnAckType_ASSIGNMENT_ACCEPTED = "0" + StreamAsgnAckType_ASSIGNMENT_REJECTED = "1" +) + +//Enum values for StreamAsgnRejReason +const ( + StreamAsgnRejReason_UNKNOWN_CLIENT = "0" + StreamAsgnRejReason_EXCEEDS_MAXIMUM_SIZE = "1" + StreamAsgnRejReason_UNKNOWN_OR_INVALID_CURRENCY_PAIR = "2" + StreamAsgnRejReason_NO_AVAILABLE_STREAM = "3" + StreamAsgnRejReason_OTHER = "99" +) + +//Enum values for StreamAsgnReqType +const ( + StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_NEW_CUSTOMER = "1" + StreamAsgnReqType_STREAM_ASSIGNMENT_FOR_EXISTING_CUSTOMER = "2" +) + +//Enum values for StreamAsgnType +const ( + StreamAsgnType_ASSIGNMENT = "1" + StreamAsgnType_REJECTED = "2" + StreamAsgnType_TERMINATE_UNASSIGN = "3" +) + +//Enum values for StrikePriceBoundaryMethod +const ( + StrikePriceBoundaryMethod_LESS_THAN_UNDERLYING_PRICE_IS_IN_THE_MONEY = "1" + StrikePriceBoundaryMethod_LESS_THAN_OR_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY = "2" + StrikePriceBoundaryMethod_EQUAL_TO_THE_UNDERLYING_PRICE_IS_IN_THE_MONEY = "3" + StrikePriceBoundaryMethod_GREATER_THAN_OR_EQUAL_TO_UNDERLYING_PRICE_IS_IN_THE_MONEY = "4" + StrikePriceBoundaryMethod_GREATER_THAN_UNDERLYING_IS_IN_THE_MONEY = "5" +) + +//Enum values for StrikePriceDeterminationMethod +const ( + StrikePriceDeterminationMethod_FIXED_STRIKE = "1" + StrikePriceDeterminationMethod_STRIKE_SET_AT_EXPIRATION_TO_UNDERLYING_OR_OTHER_VALUE = "2" + StrikePriceDeterminationMethod_STRIKE_SET_TO_AVERAGE_OF_UNDERLYING_SETTLEMENT_PRICE_ACROSS_THE_LIFE_OF_THE_OPTION = "3" + StrikePriceDeterminationMethod_STRIKE_SET_TO_OPTIMAL_VALUE = "4" +) + +//Enum values for SubscriptionRequestType +const ( + SubscriptionRequestType_SNAPSHOT = "0" + SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES = "1" + SubscriptionRequestType_DISABLE_PREVIOUS_SNAPSHOT_PLUS_UPDATE_REQUEST = "2" +) + +//Enum values for SymbolSfx +const ( + SymbolSfx_EUCP_WITH_LUMP_SUM_INTEREST_RATHER_THAN_DISCOUNT_PRICE = "CD" + SymbolSfx_WHEN_ISSUED_FOR_A_SECURITY_TO_BE_REISSUED_UNDER_AN_OLD_CUSIP_OR_ISIN = "WI" +) + +//Enum values for TargetStrategy +const ( + TargetStrategy_VWAP = "1" + TargetStrategy_RESERVEDANDAVAILABLEFORBILATERALLYAGREEDUPONUSERDEFINEDVALUES = "1000" + TargetStrategy_PARTICIPATE = "2" + TargetStrategy_MININIZE_MARKET_IMPACT = "3" +) + +//Enum values for TaxAdvantageType +const ( + TaxAdvantageType_NONE_NOT_APPLICABLE = "0" + TaxAdvantageType_MAXI_ISA = "1" + TaxAdvantageType_EMPLOYEE_10 = "10" + TaxAdvantageType_EMPLOYER_11 = "11" + TaxAdvantageType_EMPLOYER_12 = "12" + TaxAdvantageType_NON_FUND_PROTOTYPE_IRA = "13" + TaxAdvantageType_NON_FUND_QUALIFIED_PLAN = "14" + TaxAdvantageType_DEFINED_CONTRIBUTION_PLAN = "15" + TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_16 = "16" + TaxAdvantageType_INDIVIDUAL_RETIREMENT_ACCOUNT_17 = "17" + TaxAdvantageType_KEOGH = "18" + TaxAdvantageType_PROFIT_SHARING_PLAN = "19" + TaxAdvantageType_TESSA = "2" + TaxAdvantageType_401 = "20" + TaxAdvantageType_SELF_DIRECTED_IRA = "21" + TaxAdvantageType_403 = "22" + TaxAdvantageType_457 = "23" + TaxAdvantageType_ROTH_IRA_24 = "24" + TaxAdvantageType_ROTH_IRA_25 = "25" + TaxAdvantageType_ROTH_CONVERSION_IRA_26 = "26" + TaxAdvantageType_ROTH_CONVERSION_IRA_27 = "27" + TaxAdvantageType_EDUCATION_IRA_28 = "28" + TaxAdvantageType_EDUCATION_IRA_29 = "29" + TaxAdvantageType_MINI_CASH_ISA = "3" + TaxAdvantageType_MINI_STOCKS_AND_SHARES_ISA = "4" + TaxAdvantageType_MINI_INSURANCE_ISA = "5" + TaxAdvantageType_CURRENT_YEAR_PAYMENT = "6" + TaxAdvantageType_PRIOR_YEAR_PAYMENT = "7" + TaxAdvantageType_ASSET_TRANSFER = "8" + TaxAdvantageType_EMPLOYEE_9 = "9" + TaxAdvantageType_OTHER = "999" +) + +//Enum values for TerminationType +const ( + TerminationType_OVERNIGHT = "1" + TerminationType_TERM = "2" + TerminationType_FLEXIBLE = "3" + TerminationType_OPEN = "4" +) + +//Enum values for TestMessageIndicator +const ( + TestMessageIndicator_NO = "N" + TestMessageIndicator_YES = "Y" +) + +//Enum values for TickDirection +const ( + TickDirection_PLUS_TICK = "0" + TickDirection_ZERO_PLUS_TICK = "1" + TickDirection_MINUS_TICK = "2" + TickDirection_ZERO_MINUS_TICK = "3" +) + +//Enum values for TickRuleType +const ( + TickRuleType_REGULAR = "0" + TickRuleType_VARIABLE = "1" + TickRuleType_FIXED = "2" + TickRuleType_TRADED_AS_A_SPREAD_LEG = "3" + TickRuleType_SETTLED_AS_A_SPREAD_LEG = "4" +) + +//Enum values for TimeInForce +const ( + TimeInForce_DAY = "0" + TimeInForce_GOOD_TILL_CANCEL = "1" + TimeInForce_AT_THE_OPENING = "2" + TimeInForce_IMMEDIATE_OR_CANCEL = "3" + TimeInForce_FILL_OR_KILL = "4" + TimeInForce_GOOD_TILL_CROSSING = "5" + TimeInForce_GOOD_TILL_DATE = "6" + TimeInForce_AT_THE_CLOSE = "7" + TimeInForce_GOOD_THROUGH_CROSSING = "8" + TimeInForce_AT_CROSSING = "9" +) + +//Enum values for TimeUnit +const ( + TimeUnit_DAY = "D" + TimeUnit_HOUR = "H" + TimeUnit_MINUTE = "Min" + TimeUnit_MONTH = "Mo" + TimeUnit_SECOND = "S" + TimeUnit_WEEK = "Wk" + TimeUnit_YEAR = "Yr" +) + +//Enum values for TradSesEvent +const ( + TradSesEvent_TRADING_RESUMES = "0" + TradSesEvent_CHANGE_OF_TRADING_SESSION = "1" + TradSesEvent_CHANGE_OF_TRADING_SUBSESSION = "2" + TradSesEvent_CHANGE_OF_TRADING_STATUS = "3" +) + +//Enum values for TradSesMethod +const ( + TradSesMethod_ELECTRONIC = "1" + TradSesMethod_OPEN_OUTCRY = "2" + TradSesMethod_TWO_PARTY = "3" +) + +//Enum values for TradSesMode +const ( + TradSesMode_TESTING = "1" + TradSesMode_SIMULATED = "2" + TradSesMode_PRODUCTION = "3" +) + +//Enum values for TradSesStatus +const ( + TradSesStatus_UNKNOWN = "0" + TradSesStatus_HALTED = "1" + TradSesStatus_OPEN = "2" + TradSesStatus_CLOSED = "3" + TradSesStatus_PRE_OPEN = "4" + TradSesStatus_PRE_CLOSE = "5" + TradSesStatus_REQUEST_REJECTED = "6" +) + +//Enum values for TradSesStatusRejReason +const ( + TradSesStatusRejReason_UNKNOWN_OR_INVALID_TRADINGSESSIONID = "1" + TradSesStatusRejReason_OTHER = "99" +) + +//Enum values for TradeAllocIndicator +const ( + TradeAllocIndicator_ALLOCATION_NOT_REQUIRED = "0" + TradeAllocIndicator_ALLOCATION_REQUIRED = "1" + TradeAllocIndicator_USE_ALLOCATION_PROVIDED_WITH_THE_TRADE = "2" + TradeAllocIndicator_ALLOCATION_GIVE_UP_EXECUTOR = "3" + TradeAllocIndicator_ALLOCATION_FROM_EXECUTOR = "4" + TradeAllocIndicator_ALLOCATION_TO_CLAIM_ACCOUNT = "5" +) + +//Enum values for TradeCondition +const ( + TradeCondition_CANCEL = "0" + TradeCondition_IMPLIED_TRADE = "1" + TradeCondition_MARKETPLACE_ENTERED_TRADE = "2" + TradeCondition_MULT_ASSET_CLASS_MULTILEG_TRADE = "3" + TradeCondition_MULTILEG_TO_MULTILEG_TRADE = "4" + TradeCondition_CASH = "A" + TradeCondition_SPREAD = "AA" + TradeCondition_SPREAD_ETH = "AB" + TradeCondition_STRADDLE = "AC" + TradeCondition_STRADDLE_ETH = "AD" + TradeCondition_STOPPED = "AE" + TradeCondition_STOPPED_ETH = "AF" + TradeCondition_REGULAR_ETH = "AG" + TradeCondition_COMBO = "AH" + TradeCondition_COMBO_ETH = "AI" + TradeCondition_OFFICIAL_CLOSING_PRICE = "AJ" + TradeCondition_PRIOR_REFERENCE_PRICE = "AK" + TradeCondition_STOPPED_SOLD_LAST = "AL" + TradeCondition_STOPPED_OUT_OF_SEQUENCE = "AM" + TradeCondition_OFFICAL_CLOSING_PRICE = "AN" + TradeCondition_CROSSED_AO = "AO" + TradeCondition_FAST_MARKET = "AP" + TradeCondition_AUTOMATIC_EXECUTION = "AQ" + TradeCondition_FORM_T = "AR" + TradeCondition_BASKET_INDEX = "AS" + TradeCondition_BURST_BASKET = "AT" + TradeCondition_OUTSIDE_SPREAD = "AV" + TradeCondition_AVERAGE_PRICE_TRADE = "B" + TradeCondition_CASH_TRADE = "C" + TradeCondition_NEXT_DAY = "D" + TradeCondition_OPENING_REOPENING_TRADE_DETAIL = "E" + TradeCondition_INTRADAY_TRADE_DETAIL = "F" + TradeCondition_RULE_127_TRADE = "G" + TradeCondition_RULE_155_TRADE = "H" + TradeCondition_SOLD_LAST = "I" + TradeCondition_NEXT_DAY_TRADE = "J" + TradeCondition_OPENED = "K" + TradeCondition_SELLER = "L" + TradeCondition_SOLD = "M" + TradeCondition_STOPPED_STOCK = "N" + TradeCondition_IMBALANCE_MORE_BUYERS = "P" + TradeCondition_IMBALANCE_MORE_SELLERS = "Q" + TradeCondition_OPENING_PRICE = "R" + TradeCondition_BARGAIN_CONDITION = "S" + TradeCondition_CONVERTED_PRICE_INDICATOR = "T" + TradeCondition_EXCHANGE_LAST = "U" + TradeCondition_FINAL_PRICE_OF_SESSION = "V" + TradeCondition_EX_PIT = "W" + TradeCondition_CROSSED_X = "X" + TradeCondition_TRADES_RESULTING_FROM_MANUAL_SLOW_QUOTE = "Y" + TradeCondition_TRADES_RESULTING_FROM_INTERMARKET_SWEEP = "Z" + TradeCondition_VOLUME_ONLY = "a" + TradeCondition_DIRECT_PLUS = "b" + TradeCondition_ACQUISITION = "c" + TradeCondition_BUNCHED = "d" + TradeCondition_DISTRIBUTION = "e" + TradeCondition_BUNCHED_SALE = "f" + TradeCondition_SPLIT_TRADE = "g" + TradeCondition_CANCEL_STOPPED = "h" + TradeCondition_CANCEL_ETH = "i" + TradeCondition_CANCEL_STOPPED_ETH = "j" + TradeCondition_OUT_OF_SEQUENCE_ETH = "k" + TradeCondition_CANCEL_LAST_ETH = "l" + TradeCondition_SOLD_LAST_SALE_ETH = "m" + TradeCondition_CANCEL_LAST = "n" + TradeCondition_SOLD_LAST_SALE = "o" + TradeCondition_CANCEL_OPEN = "p" + TradeCondition_CANCEL_OPEN_ETH = "q" + TradeCondition_OPENED_SALE_ETH = "r" + TradeCondition_CANCEL_ONLY = "s" + TradeCondition_CANCEL_ONLY_ETH = "t" + TradeCondition_LATE_OPEN_ETH = "u" + TradeCondition_AUTO_EXECUTION_ETH = "v" + TradeCondition_REOPEN = "w" + TradeCondition_REOPEN_ETH = "x" + TradeCondition_ADJUSTED = "y" + TradeCondition_ADJUSTED_ETH = "z" +) + +//Enum values for TradeHandlingInstr +const ( + TradeHandlingInstr_TRADE_CONFIRMATION = "0" + TradeHandlingInstr_TWO_PARTY_REPORT = "1" + TradeHandlingInstr_ONE_PARTY_REPORT_FOR_MATCHING = "2" + TradeHandlingInstr_ONE_PARTY_REPORT_FOR_PASS_THROUGH = "3" + TradeHandlingInstr_AUTOMATED_FLOOR_ORDER_ROUTING = "4" + TradeHandlingInstr_TWO_PARTY_REPORT_FOR_CLAIM = "5" +) + +//Enum values for TradePublishIndicator +const ( + TradePublishIndicator_DO_NOT_PUBLISH_TRADE = "0" + TradePublishIndicator_PUBLISH_TRADE = "1" + TradePublishIndicator_DEFERRED_PUBLICATION = "2" +) + +//Enum values for TradeReportRejectReason +const ( + TradeReportRejectReason_SUCCESSFUL = "0" + TradeReportRejectReason_INVALID_PARTY_ONFORMATION = "1" + TradeReportRejectReason_UNKNOWN_INSTRUMENT = "2" + TradeReportRejectReason_UNAUTHORIZED_TO_REPORT_TRADES = "3" + TradeReportRejectReason_INVALID_TRADE_TYPE = "4" + TradeReportRejectReason_OTHER = "99" +) + +//Enum values for TradeReportTransType +const ( + TradeReportTransType_NEW = "0" + TradeReportTransType_CANCEL = "1" + TradeReportTransType_REPLACE = "2" + TradeReportTransType_RELEASE = "3" + TradeReportTransType_REVERSE = "4" + TradeReportTransType_CANCEL_DUE_TO_BACK_OUT_OF_TRADE = "5" +) + +//Enum values for TradeReportType +const ( + TradeReportType_SUBMIT = "0" + TradeReportType_ALLEGED_1 = "1" + TradeReportType_PENDED = "10" + TradeReportType_ALLEGED_NEW = "11" + TradeReportType_ALLEGED_ADDENDUM = "12" + TradeReportType_ALLEGED_NO_WAS = "13" + TradeReportType_ALLEGED_TRADE_REPORT_CANCEL = "14" + TradeReportType_ALLEGED_15 = "15" + TradeReportType_ACCEPT = "2" + TradeReportType_DECLINE = "3" + TradeReportType_ADDENDUM = "4" + TradeReportType_NO_WAS = "5" + TradeReportType_TRADE_REPORT_CANCEL = "6" + TradeReportType_7 = "7" + TradeReportType_DEFAULTED = "8" + TradeReportType_INVALID_CMTA = "9" +) + +//Enum values for TradeRequestResult +const ( + TradeRequestResult_SUCCESSFUL = "0" + TradeRequestResult_INVALID_OR_UNKNOWN_INSTRUMENT = "1" + TradeRequestResult_INVALID_TYPE_OF_TRADE_REQUESTED = "2" + TradeRequestResult_INVALID_PARTIES = "3" + TradeRequestResult_INVALID_TRANSPORT_TYPE_REQUESTED = "4" + TradeRequestResult_INVALID_DESTINATION_REQUESTED = "5" + TradeRequestResult_TRADEREQUESTTYPE_NOT_SUPPORTED = "8" + TradeRequestResult_NOT_AUTHORIZED = "9" + TradeRequestResult_OTHER = "99" +) + +//Enum values for TradeRequestStatus +const ( + TradeRequestStatus_ACCEPTED = "0" + TradeRequestStatus_COMPLETED = "1" + TradeRequestStatus_REJECTED = "2" +) + +//Enum values for TradeRequestType +const ( + TradeRequestType_ALL_TRADES = "0" + TradeRequestType_MATCHED_TRADES_MATCHING_CRITERIA_PROVIDED_ON_REQUEST = "1" + TradeRequestType_UNMATCHED_TRADES_THAT_MATCH_CRITERIA = "2" + TradeRequestType_UNREPORTED_TRADES_THAT_MATCH_CRITERIA = "3" + TradeRequestType_ADVISORIES_THAT_MATCH_CRITERIA = "4" +) + +//Enum values for TradeType +const ( + TradeType_AGENCY = "A" + TradeType_VWAP_GUARANTEE = "G" + TradeType_GUARANTEED_CLOSE = "J" + TradeType_RISK_TRADE = "R" +) + +//Enum values for TradedFlatSwitch +const ( + TradedFlatSwitch_NO = "N" + TradedFlatSwitch_YES = "Y" +) + +//Enum values for TradingSessionID +const ( + TradingSessionID_DAY = "1" + TradingSessionID_HALFDAY = "2" + TradingSessionID_MORNING = "3" + TradingSessionID_AFTERNOON = "4" + TradingSessionID_EVENING = "5" + TradingSessionID_AFTER_HOURS = "6" +) + +//Enum values for TradingSessionSubID +const ( + TradingSessionSubID_PRE_TRADING = "1" + TradingSessionSubID_OPENING_OR_OPENING_AUCTION = "2" + TradingSessionSubID_3 = "3" + TradingSessionSubID_CLOSING_OR_CLOSING_AUCTION = "4" + TradingSessionSubID_POST_TRADING = "5" + TradingSessionSubID_INTRADAY_AUCTION = "6" + TradingSessionSubID_QUIESCENT = "7" +) + +//Enum values for TrdRegTimestampType +const ( + TrdRegTimestampType_EXECUTION_TIME = "1" + TrdRegTimestampType_TIME_IN = "2" + TrdRegTimestampType_TIME_OUT = "3" + TrdRegTimestampType_BROKER_RECEIPT = "4" + TrdRegTimestampType_BROKER_EXECUTION = "5" + TrdRegTimestampType_DESK_RECEIPT = "6" + TrdRegTimestampType_SUBMISSION_TO_CLEARING = "7" +) + +//Enum values for TrdRptStatus +const ( + TrdRptStatus_ACCEPTED = "0" + TrdRptStatus_REJECTED = "1" + TrdRptStatus_ACCEPTED_WITH_ERRORS = "3" +) + +//Enum values for TrdSubType +const ( + TrdSubType_CMTA = "0" + TrdSubType_INTERNAL_TRANSFER_OR_ADJUSTMENT = "1" + TrdSubType_TRANSACTION_FROM_ASSIGNMENT = "10" + TrdSubType_ACATS = "11" + TrdSubType_AI = "14" + TrdSubType_B = "15" + TrdSubType_K = "16" + TrdSubType_LC = "17" + TrdSubType_M = "18" + TrdSubType_N = "19" + TrdSubType_EXTERNAL_TRANSFER_OR_TRANSFER_OF_ACCOUNT = "2" + TrdSubType_NM = "20" + TrdSubType_NR = "21" + TrdSubType_P = "22" + TrdSubType_PA = "23" + TrdSubType_PC = "24" + TrdSubType_PN = "25" + TrdSubType_R = "26" + TrdSubType_RO = "27" + TrdSubType_RT = "28" + TrdSubType_SW = "29" + TrdSubType_REJECT_FOR_SUBMITTING_SIDE = "3" + TrdSubType_T = "30" + TrdSubType_WN = "31" + TrdSubType_WT = "32" + TrdSubType_OFF_HOURS_TRADE = "33" + TrdSubType_ON_HOURS_TRADE = "34" + TrdSubType_OTC_QUOTE = "35" + TrdSubType_CONVERTED_SWAP = "36" + TrdSubType_CROSSED_TRADE = "37" + TrdSubType_INTERIM_PROTECTED_TRADE = "38" + TrdSubType_LARGE_IN_SCALE = "39" + TrdSubType_ADVISORY_FOR_CONTRA_SIDE = "4" + TrdSubType_OFFSET_DUE_TO_AN_ALLOCATION = "5" + TrdSubType_ONSET_DUE_TO_AN_ALLOCATION = "6" + TrdSubType_DIFFERENTIAL_SPREAD = "7" + TrdSubType_IMPLIED_SPREAD_LEG_EXECUTED_AGAINST_AN_OUTRIGHT = "8" + TrdSubType_TRANSACTION_FROM_EXERCISE = "9" +) + +//Enum values for TrdType +const ( + TrdType_REGULAR_TRADE = "0" + TrdType_BLOCK_TRADE_1 = "1" + TrdType_AFTER_HOURS_TRADE = "10" + TrdType_EXCHANGE_FOR_RISK = "11" + TrdType_EXCHANGE_FOR_SWAP = "12" + TrdType_EXCHANGE_OF_FUTURES_FOR = "13" + TrdType_EXCHANGE_OF_OPTIONS_FOR_OPTIONS = "14" + TrdType_TRADING_AT_SETTLEMENT = "15" + TrdType_ALL_OR_NONE = "16" + TrdType_FUTURES_LARGE_ORDER_EXECUTION = "17" + TrdType_EXCHANGE_OF_FUTURES_FOR_FUTURES = "18" + TrdType_OPTION_INTERIM_TRADE = "19" + TrdType_EFP = "2" + TrdType_OPTION_CABINET_TRADE = "20" + TrdType_PRIVATELY_NEGOTIATED_TRADES = "22" + TrdType_SUBSTITUTION_OF_FUTURES_FOR_FORWARDS = "23" + TrdType_ERROR_TRADE = "24" + TrdType_SPECIAL_CUM_DIVIDEND = "25" + TrdType_SPECIAL_EX_DIVIDEND = "26" + TrdType_SPECIAL_CUM_COUPON = "27" + TrdType_SPECIAL_EX_COUPON = "28" + TrdType_CASH_SETTLEMENT = "29" + TrdType_TRANSFER = "3" + TrdType_SPECIAL_PRICE = "30" + TrdType_GUARANTEED_DELIVERY = "31" + TrdType_SPECIAL_CUM_RIGHTS = "32" + TrdType_SPECIAL_EX_RIGHTS = "33" + TrdType_SPECIAL_CUM_CAPITAL_REPAYMENTS = "34" + TrdType_SPECIAL_EX_CAPITAL_REPAYMENTS = "35" + TrdType_SPECIAL_CUM_BONUS = "36" + TrdType_SPECIAL_EX_BONUS = "37" + TrdType_BLOCK_TRADE_38 = "38" + TrdType_WORKED_PRINCIPAL_TRADE = "39" + TrdType_LATE_TRADE = "4" + TrdType_BLOCK_TRADES = "40" + TrdType_NAME_CHANGE = "41" + TrdType_PORTFOLIO_TRANSFER = "42" + TrdType_PROROGATION_BUY = "43" + TrdType_PROROGATION_SELL = "44" + TrdType_OPTION_EXERCISE = "45" + TrdType_DELTA_NEUTRAL_TRANSACTION = "46" + TrdType_FINANCING_TRANSACTION = "47" + TrdType_NON_STANDARD_SETTLEMENT = "48" + TrdType_DERIVATIVE_RELATED_TRANSACTION = "49" + TrdType_T_TRADE = "5" + TrdType_PORTFOLIO_TRADE = "50" + TrdType_VOLUME_WEIGHTED_AVERAGE_TRADE = "51" + TrdType_EXCHANGE_GRANTED_TRADE = "52" + TrdType_REPURCHASE_AGREEMENT = "53" + TrdType_OTC = "54" + TrdType_EXCHANGE_BASIS_FACILITY = "55" + TrdType_WEIGHTED_AVERAGE_PRICE_TRADE = "6" + TrdType_BUNCHED_TRADE = "7" + TrdType_LATE_BUNCHED_TRADE = "8" + TrdType_PRIOR_REFERENCE_PRICE_TRADE = "9" +) + +//Enum values for TriggerAction +const ( + TriggerAction_ACTIVATE = "1" + TriggerAction_MODIFY = "2" + TriggerAction_CANCEL = "3" +) + +//Enum values for TriggerOrderType +const ( + TriggerOrderType_MARKET = "1" + TriggerOrderType_LIMIT = "2" +) + +//Enum values for TriggerPriceDirection +const ( + TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_DOWN_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE = "D" + TriggerPriceDirection_TRIGGER_IF_THE_PRICE_OF_THE_SPECIFIED_TYPE_GOES_UP_TO_OR_THROUGH_THE_SPECIFIED_TRIGGER_PRICE = "U" +) + +//Enum values for TriggerPriceType +const ( + TriggerPriceType_BEST_OFFER = "1" + TriggerPriceType_LAST_TRADE = "2" + TriggerPriceType_BEST_BID = "3" + TriggerPriceType_BEST_BID_OR_LAST_TRADE = "4" + TriggerPriceType_BEST_OFFER_OR_LAST_TRADE = "5" + TriggerPriceType_BEST_MID = "6" +) + +//Enum values for TriggerPriceTypeScope +const ( + TriggerPriceTypeScope_NONE = "0" + TriggerPriceTypeScope_LOCAL = "1" + TriggerPriceTypeScope_NATIONAL = "2" + TriggerPriceTypeScope_GLOBAL = "3" +) + +//Enum values for TriggerType +const ( + TriggerType_PARTIAL_EXECUTION = "1" + TriggerType_SPECIFIED_TRADING_SESSION = "2" + TriggerType_NEXT_AUCTION = "3" + TriggerType_PRICE_MOVEMENT = "4" +) + +//Enum values for UnderlyingCashType +const ( + UnderlyingCashType_DIFF = "DIFF" + UnderlyingCashType_FIXED = "FIXED" +) + +//Enum values for UnderlyingFXRateCalc +const ( + UnderlyingFXRateCalc_DIVIDE = "D" + UnderlyingFXRateCalc_MULTIPLY = "M" +) + +//Enum values for UnderlyingPriceDeterminationMethod +const ( + UnderlyingPriceDeterminationMethod_REGULAR = "1" + UnderlyingPriceDeterminationMethod_SPECIAL_REFERENCE = "2" + UnderlyingPriceDeterminationMethod_OPTIMAL_VALUE = "3" + UnderlyingPriceDeterminationMethod_AVERAGE_VALUE = "4" +) + +//Enum values for UnderlyingSettlementType +const ( + UnderlyingSettlementType_T_PLUS_1 = "2" + UnderlyingSettlementType_T_PLUS_3 = "4" + UnderlyingSettlementType_T_PLUS_4 = "5" +) + +//Enum values for UnitOfMeasure +const ( + UnitOfMeasure_ALLOWANCES = "Alw" + UnitOfMeasure_BARRELS = "Bbl" + UnitOfMeasure_BILLION_CUBIC_FEET = "Bcf" + UnitOfMeasure_BUSHELS = "Bu" + UnitOfMeasure_GALLONS = "Gal" + UnitOfMeasure_ONE_MILLION_BTU = "MMBtu" + UnitOfMeasure_MILLION_BARRELS = "MMbbl" + UnitOfMeasure_MEGAWATT_HOURS = "MWh" + UnitOfMeasure_US_DOLLARS = "USD" + UnitOfMeasure_POUNDS = "lbs" + UnitOfMeasure_TROY_OUNCES = "oz_tr" + UnitOfMeasure_METRIC_TONS = "t" + UnitOfMeasure_TONS = "tn" +) + +//Enum values for UnsolicitedIndicator +const ( + UnsolicitedIndicator_NO = "N" + UnsolicitedIndicator_YES = "Y" +) + +//Enum values for Urgency +const ( + Urgency_NORMAL = "0" + Urgency_FLASH = "1" + Urgency_BACKGROUND = "2" +) + +//Enum values for UserRequestType +const ( + UserRequestType_LOG_ON_USER = "1" + UserRequestType_LOG_OFF_USER = "2" + UserRequestType_CHANGE_PASSWORD_FOR_USER = "3" + UserRequestType_REQUEST_INDIVIDUAL_USER_STATUS = "4" +) + +//Enum values for UserStatus +const ( + UserStatus_LOGGED_IN = "1" + UserStatus_NOT_LOGGED_IN = "2" + UserStatus_USER_NOT_RECOGNISED = "3" + UserStatus_PASSWORD_INCORRECT = "4" + UserStatus_PASSWORD_CHANGED = "5" + UserStatus_OTHER = "6" + UserStatus_FORCED_USER_LOGOUT_BY_EXCHANGE = "7" + UserStatus_SESSION_SHUTDOWN_WARNING = "8" +) + +//Enum values for ValuationMethod +const ( + ValuationMethod_CDS_STYLE_COLLATERALIZATION_OF_MARKET_TO_MARKET_AND_COUPON = "CDS" + ValuationMethod_CDS_IN_DELIVERY = "CDSD" + ValuationMethod_PREMIUM_STYLE = "EQTY" + ValuationMethod_FUTURES_STYLE_MARK_TO_MARKET = "FUT" + ValuationMethod_FUTURES_STYLE_WITH_AN_ATTACHED_CASH_ADJUSTMENT = "FUTDA" +) + +//Enum values for VenueType +const ( + VenueType_ELECTRONIC = "E" + VenueType_PIT = "P" + VenueType_EX_PIT = "X" +) + +//Enum values for WorkingIndicator +const ( + WorkingIndicator_NO = "N" + WorkingIndicator_YES = "Y" +) + +//Enum values for YieldType +const ( + YieldType_AFTER_TAX_YIELD = "AFTERTAX" + YieldType_ANNUAL_YIELD = "ANNUAL" + YieldType_YIELD_AT_ISSUE = "ATISSUE" + YieldType_YIELD_TO_AVERAGE_LIFE_THE_YIELD_ASSUMING_THAT_ALL_SINKS = "AVGLIFE" + YieldType_YIELD_TO_AVG_MATURITY = "AVGMATURITY" + YieldType_BOOK_YIELD = "BOOK" + YieldType_YIELD_TO_NEXT_CALL = "CALL" + YieldType_YIELD_CHANGE_SINCE_CLOSE = "CHANGE" + YieldType_CLOSING_YIELD = "CLOSE" + YieldType_COMPOUND_YIELD = "COMPOUND" + YieldType_CURRENT_YIELD = "CURRENT" + YieldType_GVNT_EQUIVALENT_YIELD = "GOVTEQUIV" + YieldType_TRUE_GROSS_YIELD = "GROSS" + YieldType_YIELD_WITH_INFLATION_ASSUMPTION = "INFLATION" + YieldType_INVERSE_FLOATER_BOND_YIELD = "INVERSEFLOATER" + YieldType_MOST_RECENT_CLOSING_YIELD = "LASTCLOSE" + YieldType_CLOSING_YIELD_MOST_RECENT_MONTH = "LASTMONTH" + YieldType_CLOSING_YIELD_MOST_RECENT_QUARTER = "LASTQUARTER" + YieldType_CLOSING_YIELD_MOST_RECENT_YEAR = "LASTYEAR" + YieldType_YIELD_TO_LONGEST_AVERAGE_LIFE = "LONGAVGLIFE" + YieldType_YIELD_TO_LONGEST_AVERAGE = "LONGEST" + YieldType_MARK_TO_MARKET_YIELD = "MARK" + YieldType_YIELD_TO_MATURITY = "MATURITY" + YieldType_YIELD_TO_NEXT_REFUND = "NEXTREFUND" + YieldType_OPEN_AVERAGE_YIELD = "OPENAVG" + YieldType_PREVIOUS_CLOSE_YIELD = "PREVCLOSE" + YieldType_PROCEEDS_YIELD = "PROCEEDS" + YieldType_YIELD_TO_NEXT_PUT = "PUT" + YieldType_SEMI_ANNUAL_YIELD = "SEMIANNUAL" + YieldType_YIELD_TO_SHORTEST_AVERAGE_LIFE = "SHORTAVGLIFE" + YieldType_YIELD_TO_SHORTEST_AVERAGE = "SHORTEST" + YieldType_SIMPLE_YIELD = "SIMPLE" + YieldType_TAX_EQUIVALENT_YIELD = "TAXEQUIV" + YieldType_YIELD_TO_TENDER_DATE = "TENDER" + YieldType_TRUE_YIELD = "TRUE" + YieldType_YIELD_VALUE_OF_1_32_THE_AMOUNT_THAT_THE_YIELD_WILL_CHANGE_FOR_A_1_32ND_CHANGE_IN_PRICE = "VALUE1/32" + YieldType_YIELD_VALUE_OF_1_32 = "VALUE1_32" + YieldType_YIELD_TO_WORST = "WORST" +) diff --git a/vendor/github.com/quickfixgo/quickfix/errors.go b/vendor/github.com/quickfixgo/quickfix/errors.go new file mode 100644 index 0000000..c384211 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/errors.go @@ -0,0 +1,147 @@ +package quickfix + +import ( + "errors" + "fmt" +) + +//DoNotSend is a convenience error to indicate a DoNotSend in ToApp +var DoNotSend = errors.New("Do Not Send") + +//rejectReason enum values. +const ( + rejectReasonInvalidTagNumber = 0 + rejectReasonRequiredTagMissing = 1 + rejectReasonTagNotDefinedForThisMessageType = 2 + rejectReasonUnsupportedMessageType = 3 + rejectReasonTagSpecifiedWithoutAValue = 4 + rejectReasonValueIsIncorrect = 5 + rejectReasonConditionallyRequiredFieldMissing = 5 + rejectReasonIncorrectDataFormatForValue = 6 + rejectReasonCompIDProblem = 9 + rejectReasonSendingTimeAccuracyProblem = 10 + rejectReasonInvalidMsgType = 11 + rejectReasonTagAppearsMoreThanOnce = 13 + rejectReasonTagSpecifiedOutOfRequiredOrder = 14 + rejectReasonRepeatingGroupFieldsOutOfOrder = 15 + rejectReasonIncorrectNumInGroupCountForRepeatingGroup = 16 +) + +//MessageRejectError is a type of error that can correlate to a message reject. +type MessageRejectError interface { + error + + //RejectReason, tag 373 for session rejects, tag 380 for business rejects. + RejectReason() int + RefTagID() *Tag + IsBusinessReject() bool +} + +type messageRejectError struct { + rejectReason int + text string + refTagID *Tag + isBusinessReject bool +} + +func (e messageRejectError) Error() string { return e.text } +func (e messageRejectError) RefTagID() *Tag { return e.refTagID } +func (e messageRejectError) RejectReason() int { return e.rejectReason } +func (e messageRejectError) IsBusinessReject() bool { return e.isBusinessReject } + +//NewMessageRejectError returns a MessageRejectError with the given error message, reject reason, and optional reftagid +func NewMessageRejectError(err string, rejectReason int, refTagID *Tag) MessageRejectError { + return messageRejectError{text: err, rejectReason: rejectReason, refTagID: refTagID} +} + +//NewBusinessMessageRejectError returns a MessageRejectError with the given error mesage, reject reason, and optional reftagid. +//Reject is treated as a business level reject +func NewBusinessMessageRejectError(err string, rejectReason int, refTagID *Tag) MessageRejectError { + return messageRejectError{text: err, rejectReason: rejectReason, refTagID: refTagID, isBusinessReject: true} +} + +//IncorrectDataFormatForValue returns an error indicating a field that cannot be parsed as the type required. +func IncorrectDataFormatForValue(tag Tag) MessageRejectError { + return NewMessageRejectError("Incorrect data format for value", rejectReasonIncorrectDataFormatForValue, &tag) +} + +//repeatingGroupFieldsOutOfOrder returns an error indicating a problem parsing repeating groups fields +func repeatingGroupFieldsOutOfOrder(tag Tag, reason string) MessageRejectError { + if reason != "" { + reason = fmt.Sprintf("Repeating group fields out of order (%s)", reason) + } else { + reason = "Repeating group fields out of order" + } + return NewMessageRejectError(reason, rejectReasonRepeatingGroupFieldsOutOfOrder, &tag) +} + +//ValueIsIncorrect returns an error indicating a field with value that is not valid. +func ValueIsIncorrect(tag Tag) MessageRejectError { + return NewMessageRejectError("Value is incorrect (out of range) for this tag", rejectReasonValueIsIncorrect, &tag) +} + +//ConditionallyRequiredFieldMissing indicates that the requested field could not be found in the FIX message. +func ConditionallyRequiredFieldMissing(tag Tag) MessageRejectError { + return NewBusinessMessageRejectError(fmt.Sprintf("Conditionally Required Field Missing (%d)", tag), rejectReasonConditionallyRequiredFieldMissing, &tag) +} + +//valueIsIncorrectNoTag returns an error indicating a field with value that is not valid. +//FIXME: to be compliant with legacy tests, for certain value issues, do not include reftag? (11c_NewSeqNoLess) +func valueIsIncorrectNoTag() MessageRejectError { + return NewMessageRejectError("Value is incorrect (out of range) for this tag", rejectReasonValueIsIncorrect, nil) +} + +//InvalidMessageType returns an error to indicate an invalid message type +func InvalidMessageType() MessageRejectError { + return NewMessageRejectError("Invalid MsgType", rejectReasonInvalidMsgType, nil) +} + +//UnsupportedMessageType returns an error to indicate an unhandled message. +func UnsupportedMessageType() MessageRejectError { + return NewBusinessMessageRejectError("Unsupported Message Type", rejectReasonUnsupportedMessageType, nil) +} + +//TagNotDefinedForThisMessageType returns an error for an invalid tag appearing in a message. +func TagNotDefinedForThisMessageType(tag Tag) MessageRejectError { + return NewMessageRejectError("Tag not defined for this message type", rejectReasonTagNotDefinedForThisMessageType, &tag) +} + +//tagAppearsMoreThanOnce return an error for multiple tags in a message not detected as a repeating group. +func tagAppearsMoreThanOnce(tag Tag) MessageRejectError { + return NewMessageRejectError("Tag appears more than once", rejectReasonTagAppearsMoreThanOnce, &tag) +} + +//RequiredTagMissing returns a validation error when a required field cannot be found in a message. +func RequiredTagMissing(tag Tag) MessageRejectError { + return NewMessageRejectError("Required tag missing", rejectReasonRequiredTagMissing, &tag) +} + +//incorrectNumInGroupCountForRepeatingGroup returns a validation error when the num in group value for a group does not match actual group size. +func incorrectNumInGroupCountForRepeatingGroup(tag Tag) MessageRejectError { + return NewMessageRejectError("Incorrect NumInGroup count for repeating group", rejectReasonIncorrectNumInGroupCountForRepeatingGroup, &tag) +} + +//tagSpecifiedOutOfRequiredOrder returns validation error when the group order does not match the spec. +func tagSpecifiedOutOfRequiredOrder(tag Tag) MessageRejectError { + return NewMessageRejectError("Tag specified out of required order", rejectReasonTagSpecifiedOutOfRequiredOrder, &tag) +} + +//TagSpecifiedWithoutAValue returns a validation error for when a field has no value. +func TagSpecifiedWithoutAValue(tag Tag) MessageRejectError { + return NewMessageRejectError("Tag specified without a value", rejectReasonTagSpecifiedWithoutAValue, &tag) +} + +//InvalidTagNumber returns a validation error for messages with invalid tags. +func InvalidTagNumber(tag Tag) MessageRejectError { + return NewMessageRejectError("Invalid tag number", rejectReasonInvalidTagNumber, &tag) +} + +//compIDProblem creates a reject for msg where msg has invalid comp id values. +func compIDProblem() MessageRejectError { + return NewMessageRejectError("CompID problem", rejectReasonCompIDProblem, nil) +} + +//sendingTimeAccuracyProblem creates a reject for a msg with stale or invalid sending time. +func sendingTimeAccuracyProblem() MessageRejectError { + return NewMessageRejectError("SendingTime accuracy problem", rejectReasonSendingTimeAccuracyProblem, nil) +} diff --git a/vendor/github.com/quickfixgo/quickfix/field.go b/vendor/github.com/quickfixgo/quickfix/field.go new file mode 100644 index 0000000..9df747e --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/field.go @@ -0,0 +1,50 @@ +package quickfix + +//FieldValueWriter is an interface for writing field values +type FieldValueWriter interface { + //Writes out the contents of the FieldValue to a []byte + Write() []byte +} + +//FieldValueReader is an interface for reading field values +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 +} + +//The FieldValue interface is used to write/extract typed field values to/from raw bytes +type FieldValue interface { + FieldValueWriter + FieldValueReader +} + +//FieldWriter is an interface for a writing a field +type FieldWriter interface { + Tag() Tag + FieldValueWriter +} + +//Field is the interface implemented by all typed Fields in a Message +type Field interface { + FieldWriter + FieldValueReader +} + +//FieldGroupWriter is an interface for writing a FieldGroup +type FieldGroupWriter interface { + Tag() Tag + Write() TagValues +} + +//FieldGroupReader is an interface for reading a FieldGroup +type FieldGroupReader interface { + Tag() Tag + Read(TagValues) (TagValues, error) +} + +//FieldGroup is the interface implemented by all typed Groups in a Message +type FieldGroup interface { + Tag() Tag + Write() TagValues + Read(TagValues) (TagValues, error) +} diff --git a/vendor/github.com/quickfixgo/quickfix/field/field.go b/vendor/github.com/quickfixgo/quickfix/field/field.go new file mode 100644 index 0000000..da31e81 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/field/field.go @@ -0,0 +1,2 @@ +//Package field declares standard FIX fields. +package field diff --git a/vendor/github.com/quickfixgo/quickfix/field/fields.generated.go b/vendor/github.com/quickfixgo/quickfix/field/fields.generated.go new file mode 100644 index 0000000..24cf723 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/field/fields.generated.go @@ -0,0 +1,18421 @@ +package field + +import ( + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/tag" + + "time" +) + +//AccountField is a STRING field +type AccountField struct{ quickfix.FIXString } + +//Tag returns tag.Account (1) +func (f AccountField) Tag() quickfix.Tag { return tag.Account } + +//NewAccount returns a new AccountField initialized with val +func NewAccount(val string) AccountField { + return AccountField{quickfix.FIXString(val)} +} + +//AccountTypeField is a INT field +type AccountTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.AccountType (581) +func (f AccountTypeField) Tag() quickfix.Tag { return tag.AccountType } + +//NewAccountType returns a new AccountTypeField initialized with val +func NewAccountType(val int) AccountTypeField { + return AccountTypeField{quickfix.FIXInt(val)} +} + +//AccruedInterestAmtField is a AMT field +type AccruedInterestAmtField struct{ quickfix.FIXFloat } + +//Tag returns tag.AccruedInterestAmt (159) +func (f AccruedInterestAmtField) Tag() quickfix.Tag { return tag.AccruedInterestAmt } + +//NewAccruedInterestAmt returns a new AccruedInterestAmtField initialized with val +func NewAccruedInterestAmt(val float64) AccruedInterestAmtField { + return AccruedInterestAmtField{quickfix.FIXFloat(val)} +} + +//AccruedInterestRateField is a PERCENTAGE field +type AccruedInterestRateField struct{ quickfix.FIXFloat } + +//Tag returns tag.AccruedInterestRate (158) +func (f AccruedInterestRateField) Tag() quickfix.Tag { return tag.AccruedInterestRate } + +//NewAccruedInterestRate returns a new AccruedInterestRateField initialized with val +func NewAccruedInterestRate(val float64) AccruedInterestRateField { + return AccruedInterestRateField{quickfix.FIXFloat(val)} +} + +//AcctIDSourceField is a INT field +type AcctIDSourceField struct{ quickfix.FIXInt } + +//Tag returns tag.AcctIDSource (660) +func (f AcctIDSourceField) Tag() quickfix.Tag { return tag.AcctIDSource } + +//NewAcctIDSource returns a new AcctIDSourceField initialized with val +func NewAcctIDSource(val int) AcctIDSourceField { + return AcctIDSourceField{quickfix.FIXInt(val)} +} + +//AdjustmentField is a INT field +type AdjustmentField struct{ quickfix.FIXInt } + +//Tag returns tag.Adjustment (334) +func (f AdjustmentField) Tag() quickfix.Tag { return tag.Adjustment } + +//NewAdjustment returns a new AdjustmentField initialized with val +func NewAdjustment(val int) AdjustmentField { + return AdjustmentField{quickfix.FIXInt(val)} +} + +//AdjustmentTypeField is a INT field +type AdjustmentTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.AdjustmentType (718) +func (f AdjustmentTypeField) Tag() quickfix.Tag { return tag.AdjustmentType } + +//NewAdjustmentType returns a new AdjustmentTypeField initialized with val +func NewAdjustmentType(val int) AdjustmentTypeField { + return AdjustmentTypeField{quickfix.FIXInt(val)} +} + +//AdvIdField is a STRING field +type AdvIdField struct{ quickfix.FIXString } + +//Tag returns tag.AdvId (2) +func (f AdvIdField) Tag() quickfix.Tag { return tag.AdvId } + +//NewAdvId returns a new AdvIdField initialized with val +func NewAdvId(val string) AdvIdField { + return AdvIdField{quickfix.FIXString(val)} +} + +//AdvRefIDField is a STRING field +type AdvRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.AdvRefID (3) +func (f AdvRefIDField) Tag() quickfix.Tag { return tag.AdvRefID } + +//NewAdvRefID returns a new AdvRefIDField initialized with val +func NewAdvRefID(val string) AdvRefIDField { + return AdvRefIDField{quickfix.FIXString(val)} +} + +//AdvSideField is a CHAR field +type AdvSideField struct{ quickfix.FIXString } + +//Tag returns tag.AdvSide (4) +func (f AdvSideField) Tag() quickfix.Tag { return tag.AdvSide } + +//NewAdvSide returns a new AdvSideField initialized with val +func NewAdvSide(val string) AdvSideField { + return AdvSideField{quickfix.FIXString(val)} +} + +//AdvTransTypeField is a STRING field +type AdvTransTypeField struct{ quickfix.FIXString } + +//Tag returns tag.AdvTransType (5) +func (f AdvTransTypeField) Tag() quickfix.Tag { return tag.AdvTransType } + +//NewAdvTransType returns a new AdvTransTypeField initialized with val +func NewAdvTransType(val string) AdvTransTypeField { + return AdvTransTypeField{quickfix.FIXString(val)} +} + +//AffectedOrderIDField is a STRING field +type AffectedOrderIDField struct{ quickfix.FIXString } + +//Tag returns tag.AffectedOrderID (535) +func (f AffectedOrderIDField) Tag() quickfix.Tag { return tag.AffectedOrderID } + +//NewAffectedOrderID returns a new AffectedOrderIDField initialized with val +func NewAffectedOrderID(val string) AffectedOrderIDField { + return AffectedOrderIDField{quickfix.FIXString(val)} +} + +//AffectedSecondaryOrderIDField is a STRING field +type AffectedSecondaryOrderIDField struct{ quickfix.FIXString } + +//Tag returns tag.AffectedSecondaryOrderID (536) +func (f AffectedSecondaryOrderIDField) Tag() quickfix.Tag { return tag.AffectedSecondaryOrderID } + +//NewAffectedSecondaryOrderID returns a new AffectedSecondaryOrderIDField initialized with val +func NewAffectedSecondaryOrderID(val string) AffectedSecondaryOrderIDField { + return AffectedSecondaryOrderIDField{quickfix.FIXString(val)} +} + +//AffirmStatusField is a INT field +type AffirmStatusField struct{ quickfix.FIXInt } + +//Tag returns tag.AffirmStatus (940) +func (f AffirmStatusField) Tag() quickfix.Tag { return tag.AffirmStatus } + +//NewAffirmStatus returns a new AffirmStatusField initialized with val +func NewAffirmStatus(val int) AffirmStatusField { + return AffirmStatusField{quickfix.FIXInt(val)} +} + +//AggregatedBookField is a BOOLEAN field +type AggregatedBookField struct{ quickfix.FIXBoolean } + +//Tag returns tag.AggregatedBook (266) +func (f AggregatedBookField) Tag() quickfix.Tag { return tag.AggregatedBook } + +//NewAggregatedBook returns a new AggregatedBookField initialized with val +func NewAggregatedBook(val bool) AggregatedBookField { + return AggregatedBookField{quickfix.FIXBoolean(val)} +} + +//AggressorIndicatorField is a BOOLEAN field +type AggressorIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.AggressorIndicator (1057) +func (f AggressorIndicatorField) Tag() quickfix.Tag { return tag.AggressorIndicator } + +//NewAggressorIndicator returns a new AggressorIndicatorField initialized with val +func NewAggressorIndicator(val bool) AggressorIndicatorField { + return AggressorIndicatorField{quickfix.FIXBoolean(val)} +} + +//AgreementCurrencyField is a CURRENCY field +type AgreementCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.AgreementCurrency (918) +func (f AgreementCurrencyField) Tag() quickfix.Tag { return tag.AgreementCurrency } + +//NewAgreementCurrency returns a new AgreementCurrencyField initialized with val +func NewAgreementCurrency(val string) AgreementCurrencyField { + return AgreementCurrencyField{quickfix.FIXString(val)} +} + +//AgreementDateField is a LOCALMKTDATE field +type AgreementDateField struct{ quickfix.FIXString } + +//Tag returns tag.AgreementDate (915) +func (f AgreementDateField) Tag() quickfix.Tag { return tag.AgreementDate } + +//NewAgreementDate returns a new AgreementDateField initialized with val +func NewAgreementDate(val string) AgreementDateField { + return AgreementDateField{quickfix.FIXString(val)} +} + +//AgreementDescField is a STRING field +type AgreementDescField struct{ quickfix.FIXString } + +//Tag returns tag.AgreementDesc (913) +func (f AgreementDescField) Tag() quickfix.Tag { return tag.AgreementDesc } + +//NewAgreementDesc returns a new AgreementDescField initialized with val +func NewAgreementDesc(val string) AgreementDescField { + return AgreementDescField{quickfix.FIXString(val)} +} + +//AgreementIDField is a STRING field +type AgreementIDField struct{ quickfix.FIXString } + +//Tag returns tag.AgreementID (914) +func (f AgreementIDField) Tag() quickfix.Tag { return tag.AgreementID } + +//NewAgreementID returns a new AgreementIDField initialized with val +func NewAgreementID(val string) AgreementIDField { + return AgreementIDField{quickfix.FIXString(val)} +} + +//AllocAccountField is a STRING field +type AllocAccountField struct{ quickfix.FIXString } + +//Tag returns tag.AllocAccount (79) +func (f AllocAccountField) Tag() quickfix.Tag { return tag.AllocAccount } + +//NewAllocAccount returns a new AllocAccountField initialized with val +func NewAllocAccount(val string) AllocAccountField { + return AllocAccountField{quickfix.FIXString(val)} +} + +//AllocAccountTypeField is a INT field +type AllocAccountTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.AllocAccountType (798) +func (f AllocAccountTypeField) Tag() quickfix.Tag { return tag.AllocAccountType } + +//NewAllocAccountType returns a new AllocAccountTypeField initialized with val +func NewAllocAccountType(val int) AllocAccountTypeField { + return AllocAccountTypeField{quickfix.FIXInt(val)} +} + +//AllocAccruedInterestAmtField is a AMT field +type AllocAccruedInterestAmtField struct{ quickfix.FIXFloat } + +//Tag returns tag.AllocAccruedInterestAmt (742) +func (f AllocAccruedInterestAmtField) Tag() quickfix.Tag { return tag.AllocAccruedInterestAmt } + +//NewAllocAccruedInterestAmt returns a new AllocAccruedInterestAmtField initialized with val +func NewAllocAccruedInterestAmt(val float64) AllocAccruedInterestAmtField { + return AllocAccruedInterestAmtField{quickfix.FIXFloat(val)} +} + +//AllocAcctIDSourceField is a INT field +type AllocAcctIDSourceField struct{ quickfix.FIXInt } + +//Tag returns tag.AllocAcctIDSource (661) +func (f AllocAcctIDSourceField) Tag() quickfix.Tag { return tag.AllocAcctIDSource } + +//NewAllocAcctIDSource returns a new AllocAcctIDSourceField initialized with val +func NewAllocAcctIDSource(val int) AllocAcctIDSourceField { + return AllocAcctIDSourceField{quickfix.FIXInt(val)} +} + +//AllocAvgPxField is a PRICE field +type AllocAvgPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.AllocAvgPx (153) +func (f AllocAvgPxField) Tag() quickfix.Tag { return tag.AllocAvgPx } + +//NewAllocAvgPx returns a new AllocAvgPxField initialized with val +func NewAllocAvgPx(val float64) AllocAvgPxField { + return AllocAvgPxField{quickfix.FIXFloat(val)} +} + +//AllocCancReplaceReasonField is a INT field +type AllocCancReplaceReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.AllocCancReplaceReason (796) +func (f AllocCancReplaceReasonField) Tag() quickfix.Tag { return tag.AllocCancReplaceReason } + +//NewAllocCancReplaceReason returns a new AllocCancReplaceReasonField initialized with val +func NewAllocCancReplaceReason(val int) AllocCancReplaceReasonField { + return AllocCancReplaceReasonField{quickfix.FIXInt(val)} +} + +//AllocClearingFeeIndicatorField is a STRING field +type AllocClearingFeeIndicatorField struct{ quickfix.FIXString } + +//Tag returns tag.AllocClearingFeeIndicator (1136) +func (f AllocClearingFeeIndicatorField) Tag() quickfix.Tag { return tag.AllocClearingFeeIndicator } + +//NewAllocClearingFeeIndicator returns a new AllocClearingFeeIndicatorField initialized with val +func NewAllocClearingFeeIndicator(val string) AllocClearingFeeIndicatorField { + return AllocClearingFeeIndicatorField{quickfix.FIXString(val)} +} + +//AllocCustomerCapacityField is a STRING field +type AllocCustomerCapacityField struct{ quickfix.FIXString } + +//Tag returns tag.AllocCustomerCapacity (993) +func (f AllocCustomerCapacityField) Tag() quickfix.Tag { return tag.AllocCustomerCapacity } + +//NewAllocCustomerCapacity returns a new AllocCustomerCapacityField initialized with val +func NewAllocCustomerCapacity(val string) AllocCustomerCapacityField { + return AllocCustomerCapacityField{quickfix.FIXString(val)} +} + +//AllocHandlInstField is a INT field +type AllocHandlInstField struct{ quickfix.FIXInt } + +//Tag returns tag.AllocHandlInst (209) +func (f AllocHandlInstField) Tag() quickfix.Tag { return tag.AllocHandlInst } + +//NewAllocHandlInst returns a new AllocHandlInstField initialized with val +func NewAllocHandlInst(val int) AllocHandlInstField { + return AllocHandlInstField{quickfix.FIXInt(val)} +} + +//AllocIDField is a STRING field +type AllocIDField struct{ quickfix.FIXString } + +//Tag returns tag.AllocID (70) +func (f AllocIDField) Tag() quickfix.Tag { return tag.AllocID } + +//NewAllocID returns a new AllocIDField initialized with val +func NewAllocID(val string) AllocIDField { + return AllocIDField{quickfix.FIXString(val)} +} + +//AllocInterestAtMaturityField is a AMT field +type AllocInterestAtMaturityField struct{ quickfix.FIXFloat } + +//Tag returns tag.AllocInterestAtMaturity (741) +func (f AllocInterestAtMaturityField) Tag() quickfix.Tag { return tag.AllocInterestAtMaturity } + +//NewAllocInterestAtMaturity returns a new AllocInterestAtMaturityField initialized with val +func NewAllocInterestAtMaturity(val float64) AllocInterestAtMaturityField { + return AllocInterestAtMaturityField{quickfix.FIXFloat(val)} +} + +//AllocIntermedReqTypeField is a INT field +type AllocIntermedReqTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.AllocIntermedReqType (808) +func (f AllocIntermedReqTypeField) Tag() quickfix.Tag { return tag.AllocIntermedReqType } + +//NewAllocIntermedReqType returns a new AllocIntermedReqTypeField initialized with val +func NewAllocIntermedReqType(val int) AllocIntermedReqTypeField { + return AllocIntermedReqTypeField{quickfix.FIXInt(val)} +} + +//AllocLinkIDField is a STRING field +type AllocLinkIDField struct{ quickfix.FIXString } + +//Tag returns tag.AllocLinkID (196) +func (f AllocLinkIDField) Tag() quickfix.Tag { return tag.AllocLinkID } + +//NewAllocLinkID returns a new AllocLinkIDField initialized with val +func NewAllocLinkID(val string) AllocLinkIDField { + return AllocLinkIDField{quickfix.FIXString(val)} +} + +//AllocLinkTypeField is a INT field +type AllocLinkTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.AllocLinkType (197) +func (f AllocLinkTypeField) Tag() quickfix.Tag { return tag.AllocLinkType } + +//NewAllocLinkType returns a new AllocLinkTypeField initialized with val +func NewAllocLinkType(val int) AllocLinkTypeField { + return AllocLinkTypeField{quickfix.FIXInt(val)} +} + +//AllocMethodField is a INT field +type AllocMethodField struct{ quickfix.FIXInt } + +//Tag returns tag.AllocMethod (1002) +func (f AllocMethodField) Tag() quickfix.Tag { return tag.AllocMethod } + +//NewAllocMethod returns a new AllocMethodField initialized with val +func NewAllocMethod(val int) AllocMethodField { + return AllocMethodField{quickfix.FIXInt(val)} +} + +//AllocNetMoneyField is a AMT field +type AllocNetMoneyField struct{ quickfix.FIXFloat } + +//Tag returns tag.AllocNetMoney (154) +func (f AllocNetMoneyField) Tag() quickfix.Tag { return tag.AllocNetMoney } + +//NewAllocNetMoney returns a new AllocNetMoneyField initialized with val +func NewAllocNetMoney(val float64) AllocNetMoneyField { + return AllocNetMoneyField{quickfix.FIXFloat(val)} +} + +//AllocNoOrdersTypeField is a INT field +type AllocNoOrdersTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.AllocNoOrdersType (857) +func (f AllocNoOrdersTypeField) Tag() quickfix.Tag { return tag.AllocNoOrdersType } + +//NewAllocNoOrdersType returns a new AllocNoOrdersTypeField initialized with val +func NewAllocNoOrdersType(val int) AllocNoOrdersTypeField { + return AllocNoOrdersTypeField{quickfix.FIXInt(val)} +} + +//AllocPositionEffectField is a CHAR field +type AllocPositionEffectField struct{ quickfix.FIXString } + +//Tag returns tag.AllocPositionEffect (1047) +func (f AllocPositionEffectField) Tag() quickfix.Tag { return tag.AllocPositionEffect } + +//NewAllocPositionEffect returns a new AllocPositionEffectField initialized with val +func NewAllocPositionEffect(val string) AllocPositionEffectField { + return AllocPositionEffectField{quickfix.FIXString(val)} +} + +//AllocPriceField is a PRICE field +type AllocPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.AllocPrice (366) +func (f AllocPriceField) Tag() quickfix.Tag { return tag.AllocPrice } + +//NewAllocPrice returns a new AllocPriceField initialized with val +func NewAllocPrice(val float64) AllocPriceField { + return AllocPriceField{quickfix.FIXFloat(val)} +} + +//AllocQtyField is a QTY field +type AllocQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.AllocQty (80) +func (f AllocQtyField) Tag() quickfix.Tag { return tag.AllocQty } + +//NewAllocQty returns a new AllocQtyField initialized with val +func NewAllocQty(val float64) AllocQtyField { + return AllocQtyField{quickfix.FIXFloat(val)} +} + +//AllocRejCodeField is a INT field +type AllocRejCodeField struct{ quickfix.FIXInt } + +//Tag returns tag.AllocRejCode (88) +func (f AllocRejCodeField) Tag() quickfix.Tag { return tag.AllocRejCode } + +//NewAllocRejCode returns a new AllocRejCodeField initialized with val +func NewAllocRejCode(val int) AllocRejCodeField { + return AllocRejCodeField{quickfix.FIXInt(val)} +} + +//AllocReportIDField is a STRING field +type AllocReportIDField struct{ quickfix.FIXString } + +//Tag returns tag.AllocReportID (755) +func (f AllocReportIDField) Tag() quickfix.Tag { return tag.AllocReportID } + +//NewAllocReportID returns a new AllocReportIDField initialized with val +func NewAllocReportID(val string) AllocReportIDField { + return AllocReportIDField{quickfix.FIXString(val)} +} + +//AllocReportRefIDField is a STRING field +type AllocReportRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.AllocReportRefID (795) +func (f AllocReportRefIDField) Tag() quickfix.Tag { return tag.AllocReportRefID } + +//NewAllocReportRefID returns a new AllocReportRefIDField initialized with val +func NewAllocReportRefID(val string) AllocReportRefIDField { + return AllocReportRefIDField{quickfix.FIXString(val)} +} + +//AllocReportTypeField is a INT field +type AllocReportTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.AllocReportType (794) +func (f AllocReportTypeField) Tag() quickfix.Tag { return tag.AllocReportType } + +//NewAllocReportType returns a new AllocReportTypeField initialized with val +func NewAllocReportType(val int) AllocReportTypeField { + return AllocReportTypeField{quickfix.FIXInt(val)} +} + +//AllocSettlCurrAmtField is a AMT field +type AllocSettlCurrAmtField struct{ quickfix.FIXFloat } + +//Tag returns tag.AllocSettlCurrAmt (737) +func (f AllocSettlCurrAmtField) Tag() quickfix.Tag { return tag.AllocSettlCurrAmt } + +//NewAllocSettlCurrAmt returns a new AllocSettlCurrAmtField initialized with val +func NewAllocSettlCurrAmt(val float64) AllocSettlCurrAmtField { + return AllocSettlCurrAmtField{quickfix.FIXFloat(val)} +} + +//AllocSettlCurrencyField is a CURRENCY field +type AllocSettlCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.AllocSettlCurrency (736) +func (f AllocSettlCurrencyField) Tag() quickfix.Tag { return tag.AllocSettlCurrency } + +//NewAllocSettlCurrency returns a new AllocSettlCurrencyField initialized with val +func NewAllocSettlCurrency(val string) AllocSettlCurrencyField { + return AllocSettlCurrencyField{quickfix.FIXString(val)} +} + +//AllocSettlInstTypeField is a INT field +type AllocSettlInstTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.AllocSettlInstType (780) +func (f AllocSettlInstTypeField) Tag() quickfix.Tag { return tag.AllocSettlInstType } + +//NewAllocSettlInstType returns a new AllocSettlInstTypeField initialized with val +func NewAllocSettlInstType(val int) AllocSettlInstTypeField { + return AllocSettlInstTypeField{quickfix.FIXInt(val)} +} + +//AllocSharesField is a QTY field +type AllocSharesField struct{ quickfix.FIXFloat } + +//Tag returns tag.AllocShares (80) +func (f AllocSharesField) Tag() quickfix.Tag { return tag.AllocShares } + +//NewAllocShares returns a new AllocSharesField initialized with val +func NewAllocShares(val float64) AllocSharesField { + return AllocSharesField{quickfix.FIXFloat(val)} +} + +//AllocStatusField is a INT field +type AllocStatusField struct{ quickfix.FIXInt } + +//Tag returns tag.AllocStatus (87) +func (f AllocStatusField) Tag() quickfix.Tag { return tag.AllocStatus } + +//NewAllocStatus returns a new AllocStatusField initialized with val +func NewAllocStatus(val int) AllocStatusField { + return AllocStatusField{quickfix.FIXInt(val)} +} + +//AllocTextField is a STRING field +type AllocTextField struct{ quickfix.FIXString } + +//Tag returns tag.AllocText (161) +func (f AllocTextField) Tag() quickfix.Tag { return tag.AllocText } + +//NewAllocText returns a new AllocTextField initialized with val +func NewAllocText(val string) AllocTextField { + return AllocTextField{quickfix.FIXString(val)} +} + +//AllocTransTypeField is a CHAR field +type AllocTransTypeField struct{ quickfix.FIXString } + +//Tag returns tag.AllocTransType (71) +func (f AllocTransTypeField) Tag() quickfix.Tag { return tag.AllocTransType } + +//NewAllocTransType returns a new AllocTransTypeField initialized with val +func NewAllocTransType(val string) AllocTransTypeField { + return AllocTransTypeField{quickfix.FIXString(val)} +} + +//AllocTypeField is a INT field +type AllocTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.AllocType (626) +func (f AllocTypeField) Tag() quickfix.Tag { return tag.AllocType } + +//NewAllocType returns a new AllocTypeField initialized with val +func NewAllocType(val int) AllocTypeField { + return AllocTypeField{quickfix.FIXInt(val)} +} + +//AllowableOneSidednessCurrField is a CURRENCY field +type AllowableOneSidednessCurrField struct{ quickfix.FIXString } + +//Tag returns tag.AllowableOneSidednessCurr (767) +func (f AllowableOneSidednessCurrField) Tag() quickfix.Tag { return tag.AllowableOneSidednessCurr } + +//NewAllowableOneSidednessCurr returns a new AllowableOneSidednessCurrField initialized with val +func NewAllowableOneSidednessCurr(val string) AllowableOneSidednessCurrField { + return AllowableOneSidednessCurrField{quickfix.FIXString(val)} +} + +//AllowableOneSidednessPctField is a PERCENTAGE field +type AllowableOneSidednessPctField struct{ quickfix.FIXFloat } + +//Tag returns tag.AllowableOneSidednessPct (765) +func (f AllowableOneSidednessPctField) Tag() quickfix.Tag { return tag.AllowableOneSidednessPct } + +//NewAllowableOneSidednessPct returns a new AllowableOneSidednessPctField initialized with val +func NewAllowableOneSidednessPct(val float64) AllowableOneSidednessPctField { + return AllowableOneSidednessPctField{quickfix.FIXFloat(val)} +} + +//AllowableOneSidednessValueField is a AMT field +type AllowableOneSidednessValueField struct{ quickfix.FIXFloat } + +//Tag returns tag.AllowableOneSidednessValue (766) +func (f AllowableOneSidednessValueField) Tag() quickfix.Tag { return tag.AllowableOneSidednessValue } + +//NewAllowableOneSidednessValue returns a new AllowableOneSidednessValueField initialized with val +func NewAllowableOneSidednessValue(val float64) AllowableOneSidednessValueField { + return AllowableOneSidednessValueField{quickfix.FIXFloat(val)} +} + +//AltMDSourceIDField is a STRING field +type AltMDSourceIDField struct{ quickfix.FIXString } + +//Tag returns tag.AltMDSourceID (817) +func (f AltMDSourceIDField) Tag() quickfix.Tag { return tag.AltMDSourceID } + +//NewAltMDSourceID returns a new AltMDSourceIDField initialized with val +func NewAltMDSourceID(val string) AltMDSourceIDField { + return AltMDSourceIDField{quickfix.FIXString(val)} +} + +//ApplBegSeqNumField is a SEQNUM field +type ApplBegSeqNumField struct{ quickfix.FIXInt } + +//Tag returns tag.ApplBegSeqNum (1182) +func (f ApplBegSeqNumField) Tag() quickfix.Tag { return tag.ApplBegSeqNum } + +//NewApplBegSeqNum returns a new ApplBegSeqNumField initialized with val +func NewApplBegSeqNum(val int) ApplBegSeqNumField { + return ApplBegSeqNumField{quickfix.FIXInt(val)} +} + +//ApplEndSeqNumField is a SEQNUM field +type ApplEndSeqNumField struct{ quickfix.FIXInt } + +//Tag returns tag.ApplEndSeqNum (1183) +func (f ApplEndSeqNumField) Tag() quickfix.Tag { return tag.ApplEndSeqNum } + +//NewApplEndSeqNum returns a new ApplEndSeqNumField initialized with val +func NewApplEndSeqNum(val int) ApplEndSeqNumField { + return ApplEndSeqNumField{quickfix.FIXInt(val)} +} + +//ApplExtIDField is a INT field +type ApplExtIDField struct{ quickfix.FIXInt } + +//Tag returns tag.ApplExtID (1156) +func (f ApplExtIDField) Tag() quickfix.Tag { return tag.ApplExtID } + +//NewApplExtID returns a new ApplExtIDField initialized with val +func NewApplExtID(val int) ApplExtIDField { + return ApplExtIDField{quickfix.FIXInt(val)} +} + +//ApplIDField is a STRING field +type ApplIDField struct{ quickfix.FIXString } + +//Tag returns tag.ApplID (1180) +func (f ApplIDField) Tag() quickfix.Tag { return tag.ApplID } + +//NewApplID returns a new ApplIDField initialized with val +func NewApplID(val string) ApplIDField { + return ApplIDField{quickfix.FIXString(val)} +} + +//ApplLastSeqNumField is a SEQNUM field +type ApplLastSeqNumField struct{ quickfix.FIXInt } + +//Tag returns tag.ApplLastSeqNum (1350) +func (f ApplLastSeqNumField) Tag() quickfix.Tag { return tag.ApplLastSeqNum } + +//NewApplLastSeqNum returns a new ApplLastSeqNumField initialized with val +func NewApplLastSeqNum(val int) ApplLastSeqNumField { + return ApplLastSeqNumField{quickfix.FIXInt(val)} +} + +//ApplNewSeqNumField is a SEQNUM field +type ApplNewSeqNumField struct{ quickfix.FIXInt } + +//Tag returns tag.ApplNewSeqNum (1399) +func (f ApplNewSeqNumField) Tag() quickfix.Tag { return tag.ApplNewSeqNum } + +//NewApplNewSeqNum returns a new ApplNewSeqNumField initialized with val +func NewApplNewSeqNum(val int) ApplNewSeqNumField { + return ApplNewSeqNumField{quickfix.FIXInt(val)} +} + +//ApplQueueActionField is a INT field +type ApplQueueActionField struct{ quickfix.FIXInt } + +//Tag returns tag.ApplQueueAction (815) +func (f ApplQueueActionField) Tag() quickfix.Tag { return tag.ApplQueueAction } + +//NewApplQueueAction returns a new ApplQueueActionField initialized with val +func NewApplQueueAction(val int) ApplQueueActionField { + return ApplQueueActionField{quickfix.FIXInt(val)} +} + +//ApplQueueDepthField is a INT field +type ApplQueueDepthField struct{ quickfix.FIXInt } + +//Tag returns tag.ApplQueueDepth (813) +func (f ApplQueueDepthField) Tag() quickfix.Tag { return tag.ApplQueueDepth } + +//NewApplQueueDepth returns a new ApplQueueDepthField initialized with val +func NewApplQueueDepth(val int) ApplQueueDepthField { + return ApplQueueDepthField{quickfix.FIXInt(val)} +} + +//ApplQueueMaxField is a INT field +type ApplQueueMaxField struct{ quickfix.FIXInt } + +//Tag returns tag.ApplQueueMax (812) +func (f ApplQueueMaxField) Tag() quickfix.Tag { return tag.ApplQueueMax } + +//NewApplQueueMax returns a new ApplQueueMaxField initialized with val +func NewApplQueueMax(val int) ApplQueueMaxField { + return ApplQueueMaxField{quickfix.FIXInt(val)} +} + +//ApplQueueResolutionField is a INT field +type ApplQueueResolutionField struct{ quickfix.FIXInt } + +//Tag returns tag.ApplQueueResolution (814) +func (f ApplQueueResolutionField) Tag() quickfix.Tag { return tag.ApplQueueResolution } + +//NewApplQueueResolution returns a new ApplQueueResolutionField initialized with val +func NewApplQueueResolution(val int) ApplQueueResolutionField { + return ApplQueueResolutionField{quickfix.FIXInt(val)} +} + +//ApplReportIDField is a STRING field +type ApplReportIDField struct{ quickfix.FIXString } + +//Tag returns tag.ApplReportID (1356) +func (f ApplReportIDField) Tag() quickfix.Tag { return tag.ApplReportID } + +//NewApplReportID returns a new ApplReportIDField initialized with val +func NewApplReportID(val string) ApplReportIDField { + return ApplReportIDField{quickfix.FIXString(val)} +} + +//ApplReportTypeField is a INT field +type ApplReportTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.ApplReportType (1426) +func (f ApplReportTypeField) Tag() quickfix.Tag { return tag.ApplReportType } + +//NewApplReportType returns a new ApplReportTypeField initialized with val +func NewApplReportType(val int) ApplReportTypeField { + return ApplReportTypeField{quickfix.FIXInt(val)} +} + +//ApplReqIDField is a STRING field +type ApplReqIDField struct{ quickfix.FIXString } + +//Tag returns tag.ApplReqID (1346) +func (f ApplReqIDField) Tag() quickfix.Tag { return tag.ApplReqID } + +//NewApplReqID returns a new ApplReqIDField initialized with val +func NewApplReqID(val string) ApplReqIDField { + return ApplReqIDField{quickfix.FIXString(val)} +} + +//ApplReqTypeField is a INT field +type ApplReqTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.ApplReqType (1347) +func (f ApplReqTypeField) Tag() quickfix.Tag { return tag.ApplReqType } + +//NewApplReqType returns a new ApplReqTypeField initialized with val +func NewApplReqType(val int) ApplReqTypeField { + return ApplReqTypeField{quickfix.FIXInt(val)} +} + +//ApplResendFlagField is a BOOLEAN field +type ApplResendFlagField struct{ quickfix.FIXBoolean } + +//Tag returns tag.ApplResendFlag (1352) +func (f ApplResendFlagField) Tag() quickfix.Tag { return tag.ApplResendFlag } + +//NewApplResendFlag returns a new ApplResendFlagField initialized with val +func NewApplResendFlag(val bool) ApplResendFlagField { + return ApplResendFlagField{quickfix.FIXBoolean(val)} +} + +//ApplResponseErrorField is a INT field +type ApplResponseErrorField struct{ quickfix.FIXInt } + +//Tag returns tag.ApplResponseError (1354) +func (f ApplResponseErrorField) Tag() quickfix.Tag { return tag.ApplResponseError } + +//NewApplResponseError returns a new ApplResponseErrorField initialized with val +func NewApplResponseError(val int) ApplResponseErrorField { + return ApplResponseErrorField{quickfix.FIXInt(val)} +} + +//ApplResponseIDField is a STRING field +type ApplResponseIDField struct{ quickfix.FIXString } + +//Tag returns tag.ApplResponseID (1353) +func (f ApplResponseIDField) Tag() quickfix.Tag { return tag.ApplResponseID } + +//NewApplResponseID returns a new ApplResponseIDField initialized with val +func NewApplResponseID(val string) ApplResponseIDField { + return ApplResponseIDField{quickfix.FIXString(val)} +} + +//ApplResponseTypeField is a INT field +type ApplResponseTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.ApplResponseType (1348) +func (f ApplResponseTypeField) Tag() quickfix.Tag { return tag.ApplResponseType } + +//NewApplResponseType returns a new ApplResponseTypeField initialized with val +func NewApplResponseType(val int) ApplResponseTypeField { + return ApplResponseTypeField{quickfix.FIXInt(val)} +} + +//ApplSeqNumField is a SEQNUM field +type ApplSeqNumField struct{ quickfix.FIXInt } + +//Tag returns tag.ApplSeqNum (1181) +func (f ApplSeqNumField) Tag() quickfix.Tag { return tag.ApplSeqNum } + +//NewApplSeqNum returns a new ApplSeqNumField initialized with val +func NewApplSeqNum(val int) ApplSeqNumField { + return ApplSeqNumField{quickfix.FIXInt(val)} +} + +//ApplTotalMessageCountField is a INT field +type ApplTotalMessageCountField struct{ quickfix.FIXInt } + +//Tag returns tag.ApplTotalMessageCount (1349) +func (f ApplTotalMessageCountField) Tag() quickfix.Tag { return tag.ApplTotalMessageCount } + +//NewApplTotalMessageCount returns a new ApplTotalMessageCountField initialized with val +func NewApplTotalMessageCount(val int) ApplTotalMessageCountField { + return ApplTotalMessageCountField{quickfix.FIXInt(val)} +} + +//ApplVerIDField is a STRING field +type ApplVerIDField struct{ quickfix.FIXString } + +//Tag returns tag.ApplVerID (1128) +func (f ApplVerIDField) Tag() quickfix.Tag { return tag.ApplVerID } + +//NewApplVerID returns a new ApplVerIDField initialized with val +func NewApplVerID(val string) ApplVerIDField { + return ApplVerIDField{quickfix.FIXString(val)} +} + +//AsOfIndicatorField is a CHAR field +type AsOfIndicatorField struct{ quickfix.FIXString } + +//Tag returns tag.AsOfIndicator (1015) +func (f AsOfIndicatorField) Tag() quickfix.Tag { return tag.AsOfIndicator } + +//NewAsOfIndicator returns a new AsOfIndicatorField initialized with val +func NewAsOfIndicator(val string) AsOfIndicatorField { + return AsOfIndicatorField{quickfix.FIXString(val)} +} + +//AsgnReqIDField is a STRING field +type AsgnReqIDField struct{ quickfix.FIXString } + +//Tag returns tag.AsgnReqID (831) +func (f AsgnReqIDField) Tag() quickfix.Tag { return tag.AsgnReqID } + +//NewAsgnReqID returns a new AsgnReqIDField initialized with val +func NewAsgnReqID(val string) AsgnReqIDField { + return AsgnReqIDField{quickfix.FIXString(val)} +} + +//AsgnRptIDField is a STRING field +type AsgnRptIDField struct{ quickfix.FIXString } + +//Tag returns tag.AsgnRptID (833) +func (f AsgnRptIDField) Tag() quickfix.Tag { return tag.AsgnRptID } + +//NewAsgnRptID returns a new AsgnRptIDField initialized with val +func NewAsgnRptID(val string) AsgnRptIDField { + return AsgnRptIDField{quickfix.FIXString(val)} +} + +//AssignmentMethodField is a CHAR field +type AssignmentMethodField struct{ quickfix.FIXString } + +//Tag returns tag.AssignmentMethod (744) +func (f AssignmentMethodField) Tag() quickfix.Tag { return tag.AssignmentMethod } + +//NewAssignmentMethod returns a new AssignmentMethodField initialized with val +func NewAssignmentMethod(val string) AssignmentMethodField { + return AssignmentMethodField{quickfix.FIXString(val)} +} + +//AssignmentUnitField is a QTY field +type AssignmentUnitField struct{ quickfix.FIXFloat } + +//Tag returns tag.AssignmentUnit (745) +func (f AssignmentUnitField) Tag() quickfix.Tag { return tag.AssignmentUnit } + +//NewAssignmentUnit returns a new AssignmentUnitField initialized with val +func NewAssignmentUnit(val float64) AssignmentUnitField { + return AssignmentUnitField{quickfix.FIXFloat(val)} +} + +//AttachmentPointField is a PERCENTAGE field +type AttachmentPointField struct{ quickfix.FIXFloat } + +//Tag returns tag.AttachmentPoint (1457) +func (f AttachmentPointField) Tag() quickfix.Tag { return tag.AttachmentPoint } + +//NewAttachmentPoint returns a new AttachmentPointField initialized with val +func NewAttachmentPoint(val float64) AttachmentPointField { + return AttachmentPointField{quickfix.FIXFloat(val)} +} + +//AutoAcceptIndicatorField is a BOOLEAN field +type AutoAcceptIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.AutoAcceptIndicator (754) +func (f AutoAcceptIndicatorField) Tag() quickfix.Tag { return tag.AutoAcceptIndicator } + +//NewAutoAcceptIndicator returns a new AutoAcceptIndicatorField initialized with val +func NewAutoAcceptIndicator(val bool) AutoAcceptIndicatorField { + return AutoAcceptIndicatorField{quickfix.FIXBoolean(val)} +} + +//AvgParPxField is a PRICE field +type AvgParPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.AvgParPx (860) +func (f AvgParPxField) Tag() quickfix.Tag { return tag.AvgParPx } + +//NewAvgParPx returns a new AvgParPxField initialized with val +func NewAvgParPx(val float64) AvgParPxField { + return AvgParPxField{quickfix.FIXFloat(val)} +} + +//AvgPrxPrecisionField is a INT field +type AvgPrxPrecisionField struct{ quickfix.FIXInt } + +//Tag returns tag.AvgPrxPrecision (74) +func (f AvgPrxPrecisionField) Tag() quickfix.Tag { return tag.AvgPrxPrecision } + +//NewAvgPrxPrecision returns a new AvgPrxPrecisionField initialized with val +func NewAvgPrxPrecision(val int) AvgPrxPrecisionField { + return AvgPrxPrecisionField{quickfix.FIXInt(val)} +} + +//AvgPxField is a PRICE field +type AvgPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.AvgPx (6) +func (f AvgPxField) Tag() quickfix.Tag { return tag.AvgPx } + +//NewAvgPx returns a new AvgPxField initialized with val +func NewAvgPx(val float64) AvgPxField { + return AvgPxField{quickfix.FIXFloat(val)} +} + +//AvgPxIndicatorField is a INT field +type AvgPxIndicatorField struct{ quickfix.FIXInt } + +//Tag returns tag.AvgPxIndicator (819) +func (f AvgPxIndicatorField) Tag() quickfix.Tag { return tag.AvgPxIndicator } + +//NewAvgPxIndicator returns a new AvgPxIndicatorField initialized with val +func NewAvgPxIndicator(val int) AvgPxIndicatorField { + return AvgPxIndicatorField{quickfix.FIXInt(val)} +} + +//AvgPxPrecisionField is a INT field +type AvgPxPrecisionField struct{ quickfix.FIXInt } + +//Tag returns tag.AvgPxPrecision (74) +func (f AvgPxPrecisionField) Tag() quickfix.Tag { return tag.AvgPxPrecision } + +//NewAvgPxPrecision returns a new AvgPxPrecisionField initialized with val +func NewAvgPxPrecision(val int) AvgPxPrecisionField { + return AvgPxPrecisionField{quickfix.FIXInt(val)} +} + +//BasisFeatureDateField is a LOCALMKTDATE field +type BasisFeatureDateField struct{ quickfix.FIXString } + +//Tag returns tag.BasisFeatureDate (259) +func (f BasisFeatureDateField) Tag() quickfix.Tag { return tag.BasisFeatureDate } + +//NewBasisFeatureDate returns a new BasisFeatureDateField initialized with val +func NewBasisFeatureDate(val string) BasisFeatureDateField { + return BasisFeatureDateField{quickfix.FIXString(val)} +} + +//BasisFeaturePriceField is a PRICE field +type BasisFeaturePriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.BasisFeaturePrice (260) +func (f BasisFeaturePriceField) Tag() quickfix.Tag { return tag.BasisFeaturePrice } + +//NewBasisFeaturePrice returns a new BasisFeaturePriceField initialized with val +func NewBasisFeaturePrice(val float64) BasisFeaturePriceField { + return BasisFeaturePriceField{quickfix.FIXFloat(val)} +} + +//BasisPxTypeField is a CHAR field +type BasisPxTypeField struct{ quickfix.FIXString } + +//Tag returns tag.BasisPxType (419) +func (f BasisPxTypeField) Tag() quickfix.Tag { return tag.BasisPxType } + +//NewBasisPxType returns a new BasisPxTypeField initialized with val +func NewBasisPxType(val string) BasisPxTypeField { + return BasisPxTypeField{quickfix.FIXString(val)} +} + +//BeginSeqNoField is a SEQNUM field +type BeginSeqNoField struct{ quickfix.FIXInt } + +//Tag returns tag.BeginSeqNo (7) +func (f BeginSeqNoField) Tag() quickfix.Tag { return tag.BeginSeqNo } + +//NewBeginSeqNo returns a new BeginSeqNoField initialized with val +func NewBeginSeqNo(val int) BeginSeqNoField { + return BeginSeqNoField{quickfix.FIXInt(val)} +} + +//BeginStringField is a STRING field +type BeginStringField struct{ quickfix.FIXString } + +//Tag returns tag.BeginString (8) +func (f BeginStringField) Tag() quickfix.Tag { return tag.BeginString } + +//NewBeginString returns a new BeginStringField initialized with val +func NewBeginString(val string) BeginStringField { + return BeginStringField{quickfix.FIXString(val)} +} + +//BenchmarkField is a CHAR field +type BenchmarkField struct{ quickfix.FIXString } + +//Tag returns tag.Benchmark (219) +func (f BenchmarkField) Tag() quickfix.Tag { return tag.Benchmark } + +//NewBenchmark returns a new BenchmarkField initialized with val +func NewBenchmark(val string) BenchmarkField { + return BenchmarkField{quickfix.FIXString(val)} +} + +//BenchmarkCurveCurrencyField is a CURRENCY field +type BenchmarkCurveCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.BenchmarkCurveCurrency (220) +func (f BenchmarkCurveCurrencyField) Tag() quickfix.Tag { return tag.BenchmarkCurveCurrency } + +//NewBenchmarkCurveCurrency returns a new BenchmarkCurveCurrencyField initialized with val +func NewBenchmarkCurveCurrency(val string) BenchmarkCurveCurrencyField { + return BenchmarkCurveCurrencyField{quickfix.FIXString(val)} +} + +//BenchmarkCurveNameField is a STRING field +type BenchmarkCurveNameField struct{ quickfix.FIXString } + +//Tag returns tag.BenchmarkCurveName (221) +func (f BenchmarkCurveNameField) Tag() quickfix.Tag { return tag.BenchmarkCurveName } + +//NewBenchmarkCurveName returns a new BenchmarkCurveNameField initialized with val +func NewBenchmarkCurveName(val string) BenchmarkCurveNameField { + return BenchmarkCurveNameField{quickfix.FIXString(val)} +} + +//BenchmarkCurvePointField is a STRING field +type BenchmarkCurvePointField struct{ quickfix.FIXString } + +//Tag returns tag.BenchmarkCurvePoint (222) +func (f BenchmarkCurvePointField) Tag() quickfix.Tag { return tag.BenchmarkCurvePoint } + +//NewBenchmarkCurvePoint returns a new BenchmarkCurvePointField initialized with val +func NewBenchmarkCurvePoint(val string) BenchmarkCurvePointField { + return BenchmarkCurvePointField{quickfix.FIXString(val)} +} + +//BenchmarkPriceField is a PRICE field +type BenchmarkPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.BenchmarkPrice (662) +func (f BenchmarkPriceField) Tag() quickfix.Tag { return tag.BenchmarkPrice } + +//NewBenchmarkPrice returns a new BenchmarkPriceField initialized with val +func NewBenchmarkPrice(val float64) BenchmarkPriceField { + return BenchmarkPriceField{quickfix.FIXFloat(val)} +} + +//BenchmarkPriceTypeField is a INT field +type BenchmarkPriceTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.BenchmarkPriceType (663) +func (f BenchmarkPriceTypeField) Tag() quickfix.Tag { return tag.BenchmarkPriceType } + +//NewBenchmarkPriceType returns a new BenchmarkPriceTypeField initialized with val +func NewBenchmarkPriceType(val int) BenchmarkPriceTypeField { + return BenchmarkPriceTypeField{quickfix.FIXInt(val)} +} + +//BenchmarkSecurityIDField is a STRING field +type BenchmarkSecurityIDField struct{ quickfix.FIXString } + +//Tag returns tag.BenchmarkSecurityID (699) +func (f BenchmarkSecurityIDField) Tag() quickfix.Tag { return tag.BenchmarkSecurityID } + +//NewBenchmarkSecurityID returns a new BenchmarkSecurityIDField initialized with val +func NewBenchmarkSecurityID(val string) BenchmarkSecurityIDField { + return BenchmarkSecurityIDField{quickfix.FIXString(val)} +} + +//BenchmarkSecurityIDSourceField is a STRING field +type BenchmarkSecurityIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.BenchmarkSecurityIDSource (761) +func (f BenchmarkSecurityIDSourceField) Tag() quickfix.Tag { return tag.BenchmarkSecurityIDSource } + +//NewBenchmarkSecurityIDSource returns a new BenchmarkSecurityIDSourceField initialized with val +func NewBenchmarkSecurityIDSource(val string) BenchmarkSecurityIDSourceField { + return BenchmarkSecurityIDSourceField{quickfix.FIXString(val)} +} + +//BidDescriptorField is a STRING field +type BidDescriptorField struct{ quickfix.FIXString } + +//Tag returns tag.BidDescriptor (400) +func (f BidDescriptorField) Tag() quickfix.Tag { return tag.BidDescriptor } + +//NewBidDescriptor returns a new BidDescriptorField initialized with val +func NewBidDescriptor(val string) BidDescriptorField { + return BidDescriptorField{quickfix.FIXString(val)} +} + +//BidDescriptorTypeField is a INT field +type BidDescriptorTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.BidDescriptorType (399) +func (f BidDescriptorTypeField) Tag() quickfix.Tag { return tag.BidDescriptorType } + +//NewBidDescriptorType returns a new BidDescriptorTypeField initialized with val +func NewBidDescriptorType(val int) BidDescriptorTypeField { + return BidDescriptorTypeField{quickfix.FIXInt(val)} +} + +//BidForwardPointsField is a PRICEOFFSET field +type BidForwardPointsField struct{ quickfix.FIXFloat } + +//Tag returns tag.BidForwardPoints (189) +func (f BidForwardPointsField) Tag() quickfix.Tag { return tag.BidForwardPoints } + +//NewBidForwardPoints returns a new BidForwardPointsField initialized with val +func NewBidForwardPoints(val float64) BidForwardPointsField { + return BidForwardPointsField{quickfix.FIXFloat(val)} +} + +//BidForwardPoints2Field is a PRICEOFFSET field +type BidForwardPoints2Field struct{ quickfix.FIXFloat } + +//Tag returns tag.BidForwardPoints2 (642) +func (f BidForwardPoints2Field) Tag() quickfix.Tag { return tag.BidForwardPoints2 } + +//NewBidForwardPoints2 returns a new BidForwardPoints2Field initialized with val +func NewBidForwardPoints2(val float64) BidForwardPoints2Field { + return BidForwardPoints2Field{quickfix.FIXFloat(val)} +} + +//BidIDField is a STRING field +type BidIDField struct{ quickfix.FIXString } + +//Tag returns tag.BidID (390) +func (f BidIDField) Tag() quickfix.Tag { return tag.BidID } + +//NewBidID returns a new BidIDField initialized with val +func NewBidID(val string) BidIDField { + return BidIDField{quickfix.FIXString(val)} +} + +//BidPxField is a PRICE field +type BidPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.BidPx (132) +func (f BidPxField) Tag() quickfix.Tag { return tag.BidPx } + +//NewBidPx returns a new BidPxField initialized with val +func NewBidPx(val float64) BidPxField { + return BidPxField{quickfix.FIXFloat(val)} +} + +//BidRequestTransTypeField is a CHAR field +type BidRequestTransTypeField struct{ quickfix.FIXString } + +//Tag returns tag.BidRequestTransType (374) +func (f BidRequestTransTypeField) Tag() quickfix.Tag { return tag.BidRequestTransType } + +//NewBidRequestTransType returns a new BidRequestTransTypeField initialized with val +func NewBidRequestTransType(val string) BidRequestTransTypeField { + return BidRequestTransTypeField{quickfix.FIXString(val)} +} + +//BidSizeField is a QTY field +type BidSizeField struct{ quickfix.FIXFloat } + +//Tag returns tag.BidSize (134) +func (f BidSizeField) Tag() quickfix.Tag { return tag.BidSize } + +//NewBidSize returns a new BidSizeField initialized with val +func NewBidSize(val float64) BidSizeField { + return BidSizeField{quickfix.FIXFloat(val)} +} + +//BidSpotRateField is a PRICE field +type BidSpotRateField struct{ quickfix.FIXFloat } + +//Tag returns tag.BidSpotRate (188) +func (f BidSpotRateField) Tag() quickfix.Tag { return tag.BidSpotRate } + +//NewBidSpotRate returns a new BidSpotRateField initialized with val +func NewBidSpotRate(val float64) BidSpotRateField { + return BidSpotRateField{quickfix.FIXFloat(val)} +} + +//BidSwapPointsField is a PRICEOFFSET field +type BidSwapPointsField struct{ quickfix.FIXFloat } + +//Tag returns tag.BidSwapPoints (1065) +func (f BidSwapPointsField) Tag() quickfix.Tag { return tag.BidSwapPoints } + +//NewBidSwapPoints returns a new BidSwapPointsField initialized with val +func NewBidSwapPoints(val float64) BidSwapPointsField { + return BidSwapPointsField{quickfix.FIXFloat(val)} +} + +//BidTradeTypeField is a CHAR field +type BidTradeTypeField struct{ quickfix.FIXString } + +//Tag returns tag.BidTradeType (418) +func (f BidTradeTypeField) Tag() quickfix.Tag { return tag.BidTradeType } + +//NewBidTradeType returns a new BidTradeTypeField initialized with val +func NewBidTradeType(val string) BidTradeTypeField { + return BidTradeTypeField{quickfix.FIXString(val)} +} + +//BidTypeField is a INT field +type BidTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.BidType (394) +func (f BidTypeField) Tag() quickfix.Tag { return tag.BidType } + +//NewBidType returns a new BidTypeField initialized with val +func NewBidType(val int) BidTypeField { + return BidTypeField{quickfix.FIXInt(val)} +} + +//BidYieldField is a PERCENTAGE field +type BidYieldField struct{ quickfix.FIXFloat } + +//Tag returns tag.BidYield (632) +func (f BidYieldField) Tag() quickfix.Tag { return tag.BidYield } + +//NewBidYield returns a new BidYieldField initialized with val +func NewBidYield(val float64) BidYieldField { + return BidYieldField{quickfix.FIXFloat(val)} +} + +//BodyLengthField is a LENGTH field +type BodyLengthField struct{ quickfix.FIXInt } + +//Tag returns tag.BodyLength (9) +func (f BodyLengthField) Tag() quickfix.Tag { return tag.BodyLength } + +//NewBodyLength returns a new BodyLengthField initialized with val +func NewBodyLength(val int) BodyLengthField { + return BodyLengthField{quickfix.FIXInt(val)} +} + +//BookingRefIDField is a STRING field +type BookingRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.BookingRefID (466) +func (f BookingRefIDField) Tag() quickfix.Tag { return tag.BookingRefID } + +//NewBookingRefID returns a new BookingRefIDField initialized with val +func NewBookingRefID(val string) BookingRefIDField { + return BookingRefIDField{quickfix.FIXString(val)} +} + +//BookingTypeField is a INT field +type BookingTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.BookingType (775) +func (f BookingTypeField) Tag() quickfix.Tag { return tag.BookingType } + +//NewBookingType returns a new BookingTypeField initialized with val +func NewBookingType(val int) BookingTypeField { + return BookingTypeField{quickfix.FIXInt(val)} +} + +//BookingUnitField is a CHAR field +type BookingUnitField struct{ quickfix.FIXString } + +//Tag returns tag.BookingUnit (590) +func (f BookingUnitField) Tag() quickfix.Tag { return tag.BookingUnit } + +//NewBookingUnit returns a new BookingUnitField initialized with val +func NewBookingUnit(val string) BookingUnitField { + return BookingUnitField{quickfix.FIXString(val)} +} + +//BrokerOfCreditField is a STRING field +type BrokerOfCreditField struct{ quickfix.FIXString } + +//Tag returns tag.BrokerOfCredit (92) +func (f BrokerOfCreditField) Tag() quickfix.Tag { return tag.BrokerOfCredit } + +//NewBrokerOfCredit returns a new BrokerOfCreditField initialized with val +func NewBrokerOfCredit(val string) BrokerOfCreditField { + return BrokerOfCreditField{quickfix.FIXString(val)} +} + +//BusinessRejectReasonField is a INT field +type BusinessRejectReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.BusinessRejectReason (380) +func (f BusinessRejectReasonField) Tag() quickfix.Tag { return tag.BusinessRejectReason } + +//NewBusinessRejectReason returns a new BusinessRejectReasonField initialized with val +func NewBusinessRejectReason(val int) BusinessRejectReasonField { + return BusinessRejectReasonField{quickfix.FIXInt(val)} +} + +//BusinessRejectRefIDField is a STRING field +type BusinessRejectRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.BusinessRejectRefID (379) +func (f BusinessRejectRefIDField) Tag() quickfix.Tag { return tag.BusinessRejectRefID } + +//NewBusinessRejectRefID returns a new BusinessRejectRefIDField initialized with val +func NewBusinessRejectRefID(val string) BusinessRejectRefIDField { + return BusinessRejectRefIDField{quickfix.FIXString(val)} +} + +//BuyVolumeField is a QTY field +type BuyVolumeField struct{ quickfix.FIXFloat } + +//Tag returns tag.BuyVolume (330) +func (f BuyVolumeField) Tag() quickfix.Tag { return tag.BuyVolume } + +//NewBuyVolume returns a new BuyVolumeField initialized with val +func NewBuyVolume(val float64) BuyVolumeField { + return BuyVolumeField{quickfix.FIXFloat(val)} +} + +//CFICodeField is a STRING field +type CFICodeField struct{ quickfix.FIXString } + +//Tag returns tag.CFICode (461) +func (f CFICodeField) Tag() quickfix.Tag { return tag.CFICode } + +//NewCFICode returns a new CFICodeField initialized with val +func NewCFICode(val string) CFICodeField { + return CFICodeField{quickfix.FIXString(val)} +} + +//CPProgramField is a INT field +type CPProgramField struct{ quickfix.FIXInt } + +//Tag returns tag.CPProgram (875) +func (f CPProgramField) Tag() quickfix.Tag { return tag.CPProgram } + +//NewCPProgram returns a new CPProgramField initialized with val +func NewCPProgram(val int) CPProgramField { + return CPProgramField{quickfix.FIXInt(val)} +} + +//CPRegTypeField is a STRING field +type CPRegTypeField struct{ quickfix.FIXString } + +//Tag returns tag.CPRegType (876) +func (f CPRegTypeField) Tag() quickfix.Tag { return tag.CPRegType } + +//NewCPRegType returns a new CPRegTypeField initialized with val +func NewCPRegType(val string) CPRegTypeField { + return CPRegTypeField{quickfix.FIXString(val)} +} + +//CalculatedCcyLastQtyField is a QTY field +type CalculatedCcyLastQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.CalculatedCcyLastQty (1056) +func (f CalculatedCcyLastQtyField) Tag() quickfix.Tag { return tag.CalculatedCcyLastQty } + +//NewCalculatedCcyLastQty returns a new CalculatedCcyLastQtyField initialized with val +func NewCalculatedCcyLastQty(val float64) CalculatedCcyLastQtyField { + return CalculatedCcyLastQtyField{quickfix.FIXFloat(val)} +} + +//CancellationRightsField is a CHAR field +type CancellationRightsField struct{ quickfix.FIXString } + +//Tag returns tag.CancellationRights (480) +func (f CancellationRightsField) Tag() quickfix.Tag { return tag.CancellationRights } + +//NewCancellationRights returns a new CancellationRightsField initialized with val +func NewCancellationRights(val string) CancellationRightsField { + return CancellationRightsField{quickfix.FIXString(val)} +} + +//CapPriceField is a PRICE field +type CapPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.CapPrice (1199) +func (f CapPriceField) Tag() quickfix.Tag { return tag.CapPrice } + +//NewCapPrice returns a new CapPriceField initialized with val +func NewCapPrice(val float64) CapPriceField { + return CapPriceField{quickfix.FIXFloat(val)} +} + +//CardExpDateField is a LOCALMKTDATE field +type CardExpDateField struct{ quickfix.FIXString } + +//Tag returns tag.CardExpDate (490) +func (f CardExpDateField) Tag() quickfix.Tag { return tag.CardExpDate } + +//NewCardExpDate returns a new CardExpDateField initialized with val +func NewCardExpDate(val string) CardExpDateField { + return CardExpDateField{quickfix.FIXString(val)} +} + +//CardHolderNameField is a STRING field +type CardHolderNameField struct{ quickfix.FIXString } + +//Tag returns tag.CardHolderName (488) +func (f CardHolderNameField) Tag() quickfix.Tag { return tag.CardHolderName } + +//NewCardHolderName returns a new CardHolderNameField initialized with val +func NewCardHolderName(val string) CardHolderNameField { + return CardHolderNameField{quickfix.FIXString(val)} +} + +//CardIssNoField is a STRING field +type CardIssNoField struct{ quickfix.FIXString } + +//Tag returns tag.CardIssNo (491) +func (f CardIssNoField) Tag() quickfix.Tag { return tag.CardIssNo } + +//NewCardIssNo returns a new CardIssNoField initialized with val +func NewCardIssNo(val string) CardIssNoField { + return CardIssNoField{quickfix.FIXString(val)} +} + +//CardIssNumField is a STRING field +type CardIssNumField struct{ quickfix.FIXString } + +//Tag returns tag.CardIssNum (491) +func (f CardIssNumField) Tag() quickfix.Tag { return tag.CardIssNum } + +//NewCardIssNum returns a new CardIssNumField initialized with val +func NewCardIssNum(val string) CardIssNumField { + return CardIssNumField{quickfix.FIXString(val)} +} + +//CardNumberField is a STRING field +type CardNumberField struct{ quickfix.FIXString } + +//Tag returns tag.CardNumber (489) +func (f CardNumberField) Tag() quickfix.Tag { return tag.CardNumber } + +//NewCardNumber returns a new CardNumberField initialized with val +func NewCardNumber(val string) CardNumberField { + return CardNumberField{quickfix.FIXString(val)} +} + +//CardStartDateField is a LOCALMKTDATE field +type CardStartDateField struct{ quickfix.FIXString } + +//Tag returns tag.CardStartDate (503) +func (f CardStartDateField) Tag() quickfix.Tag { return tag.CardStartDate } + +//NewCardStartDate returns a new CardStartDateField initialized with val +func NewCardStartDate(val string) CardStartDateField { + return CardStartDateField{quickfix.FIXString(val)} +} + +//CashDistribAgentAcctNameField is a STRING field +type CashDistribAgentAcctNameField struct{ quickfix.FIXString } + +//Tag returns tag.CashDistribAgentAcctName (502) +func (f CashDistribAgentAcctNameField) Tag() quickfix.Tag { return tag.CashDistribAgentAcctName } + +//NewCashDistribAgentAcctName returns a new CashDistribAgentAcctNameField initialized with val +func NewCashDistribAgentAcctName(val string) CashDistribAgentAcctNameField { + return CashDistribAgentAcctNameField{quickfix.FIXString(val)} +} + +//CashDistribAgentAcctNumberField is a STRING field +type CashDistribAgentAcctNumberField struct{ quickfix.FIXString } + +//Tag returns tag.CashDistribAgentAcctNumber (500) +func (f CashDistribAgentAcctNumberField) Tag() quickfix.Tag { return tag.CashDistribAgentAcctNumber } + +//NewCashDistribAgentAcctNumber returns a new CashDistribAgentAcctNumberField initialized with val +func NewCashDistribAgentAcctNumber(val string) CashDistribAgentAcctNumberField { + return CashDistribAgentAcctNumberField{quickfix.FIXString(val)} +} + +//CashDistribAgentCodeField is a STRING field +type CashDistribAgentCodeField struct{ quickfix.FIXString } + +//Tag returns tag.CashDistribAgentCode (499) +func (f CashDistribAgentCodeField) Tag() quickfix.Tag { return tag.CashDistribAgentCode } + +//NewCashDistribAgentCode returns a new CashDistribAgentCodeField initialized with val +func NewCashDistribAgentCode(val string) CashDistribAgentCodeField { + return CashDistribAgentCodeField{quickfix.FIXString(val)} +} + +//CashDistribAgentNameField is a STRING field +type CashDistribAgentNameField struct{ quickfix.FIXString } + +//Tag returns tag.CashDistribAgentName (498) +func (f CashDistribAgentNameField) Tag() quickfix.Tag { return tag.CashDistribAgentName } + +//NewCashDistribAgentName returns a new CashDistribAgentNameField initialized with val +func NewCashDistribAgentName(val string) CashDistribAgentNameField { + return CashDistribAgentNameField{quickfix.FIXString(val)} +} + +//CashDistribCurrField is a CURRENCY field +type CashDistribCurrField struct{ quickfix.FIXString } + +//Tag returns tag.CashDistribCurr (478) +func (f CashDistribCurrField) Tag() quickfix.Tag { return tag.CashDistribCurr } + +//NewCashDistribCurr returns a new CashDistribCurrField initialized with val +func NewCashDistribCurr(val string) CashDistribCurrField { + return CashDistribCurrField{quickfix.FIXString(val)} +} + +//CashDistribPayRefField is a STRING field +type CashDistribPayRefField struct{ quickfix.FIXString } + +//Tag returns tag.CashDistribPayRef (501) +func (f CashDistribPayRefField) Tag() quickfix.Tag { return tag.CashDistribPayRef } + +//NewCashDistribPayRef returns a new CashDistribPayRefField initialized with val +func NewCashDistribPayRef(val string) CashDistribPayRefField { + return CashDistribPayRefField{quickfix.FIXString(val)} +} + +//CashMarginField is a CHAR field +type CashMarginField struct{ quickfix.FIXString } + +//Tag returns tag.CashMargin (544) +func (f CashMarginField) Tag() quickfix.Tag { return tag.CashMargin } + +//NewCashMargin returns a new CashMarginField initialized with val +func NewCashMargin(val string) CashMarginField { + return CashMarginField{quickfix.FIXString(val)} +} + +//CashOrderQtyField is a QTY field +type CashOrderQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.CashOrderQty (152) +func (f CashOrderQtyField) Tag() quickfix.Tag { return tag.CashOrderQty } + +//NewCashOrderQty returns a new CashOrderQtyField initialized with val +func NewCashOrderQty(val float64) CashOrderQtyField { + return CashOrderQtyField{quickfix.FIXFloat(val)} +} + +//CashOutstandingField is a AMT field +type CashOutstandingField struct{ quickfix.FIXFloat } + +//Tag returns tag.CashOutstanding (901) +func (f CashOutstandingField) Tag() quickfix.Tag { return tag.CashOutstanding } + +//NewCashOutstanding returns a new CashOutstandingField initialized with val +func NewCashOutstanding(val float64) CashOutstandingField { + return CashOutstandingField{quickfix.FIXFloat(val)} +} + +//CashSettlAgentAcctNameField is a STRING field +type CashSettlAgentAcctNameField struct{ quickfix.FIXString } + +//Tag returns tag.CashSettlAgentAcctName (185) +func (f CashSettlAgentAcctNameField) Tag() quickfix.Tag { return tag.CashSettlAgentAcctName } + +//NewCashSettlAgentAcctName returns a new CashSettlAgentAcctNameField initialized with val +func NewCashSettlAgentAcctName(val string) CashSettlAgentAcctNameField { + return CashSettlAgentAcctNameField{quickfix.FIXString(val)} +} + +//CashSettlAgentAcctNumField is a STRING field +type CashSettlAgentAcctNumField struct{ quickfix.FIXString } + +//Tag returns tag.CashSettlAgentAcctNum (184) +func (f CashSettlAgentAcctNumField) Tag() quickfix.Tag { return tag.CashSettlAgentAcctNum } + +//NewCashSettlAgentAcctNum returns a new CashSettlAgentAcctNumField initialized with val +func NewCashSettlAgentAcctNum(val string) CashSettlAgentAcctNumField { + return CashSettlAgentAcctNumField{quickfix.FIXString(val)} +} + +//CashSettlAgentCodeField is a STRING field +type CashSettlAgentCodeField struct{ quickfix.FIXString } + +//Tag returns tag.CashSettlAgentCode (183) +func (f CashSettlAgentCodeField) Tag() quickfix.Tag { return tag.CashSettlAgentCode } + +//NewCashSettlAgentCode returns a new CashSettlAgentCodeField initialized with val +func NewCashSettlAgentCode(val string) CashSettlAgentCodeField { + return CashSettlAgentCodeField{quickfix.FIXString(val)} +} + +//CashSettlAgentContactNameField is a STRING field +type CashSettlAgentContactNameField struct{ quickfix.FIXString } + +//Tag returns tag.CashSettlAgentContactName (186) +func (f CashSettlAgentContactNameField) Tag() quickfix.Tag { return tag.CashSettlAgentContactName } + +//NewCashSettlAgentContactName returns a new CashSettlAgentContactNameField initialized with val +func NewCashSettlAgentContactName(val string) CashSettlAgentContactNameField { + return CashSettlAgentContactNameField{quickfix.FIXString(val)} +} + +//CashSettlAgentContactPhoneField is a STRING field +type CashSettlAgentContactPhoneField struct{ quickfix.FIXString } + +//Tag returns tag.CashSettlAgentContactPhone (187) +func (f CashSettlAgentContactPhoneField) Tag() quickfix.Tag { return tag.CashSettlAgentContactPhone } + +//NewCashSettlAgentContactPhone returns a new CashSettlAgentContactPhoneField initialized with val +func NewCashSettlAgentContactPhone(val string) CashSettlAgentContactPhoneField { + return CashSettlAgentContactPhoneField{quickfix.FIXString(val)} +} + +//CashSettlAgentNameField is a STRING field +type CashSettlAgentNameField struct{ quickfix.FIXString } + +//Tag returns tag.CashSettlAgentName (182) +func (f CashSettlAgentNameField) Tag() quickfix.Tag { return tag.CashSettlAgentName } + +//NewCashSettlAgentName returns a new CashSettlAgentNameField initialized with val +func NewCashSettlAgentName(val string) CashSettlAgentNameField { + return CashSettlAgentNameField{quickfix.FIXString(val)} +} + +//CcyAmtField is a AMT field +type CcyAmtField struct{ quickfix.FIXFloat } + +//Tag returns tag.CcyAmt (1157) +func (f CcyAmtField) Tag() quickfix.Tag { return tag.CcyAmt } + +//NewCcyAmt returns a new CcyAmtField initialized with val +func NewCcyAmt(val float64) CcyAmtField { + return CcyAmtField{quickfix.FIXFloat(val)} +} + +//CheckSumField is a STRING field +type CheckSumField struct{ quickfix.FIXString } + +//Tag returns tag.CheckSum (10) +func (f CheckSumField) Tag() quickfix.Tag { return tag.CheckSum } + +//NewCheckSum returns a new CheckSumField initialized with val +func NewCheckSum(val string) CheckSumField { + return CheckSumField{quickfix.FIXString(val)} +} + +//ClOrdIDField is a STRING field +type ClOrdIDField struct{ quickfix.FIXString } + +//Tag returns tag.ClOrdID (11) +func (f ClOrdIDField) Tag() quickfix.Tag { return tag.ClOrdID } + +//NewClOrdID returns a new ClOrdIDField initialized with val +func NewClOrdID(val string) ClOrdIDField { + return ClOrdIDField{quickfix.FIXString(val)} +} + +//ClOrdLinkIDField is a STRING field +type ClOrdLinkIDField struct{ quickfix.FIXString } + +//Tag returns tag.ClOrdLinkID (583) +func (f ClOrdLinkIDField) Tag() quickfix.Tag { return tag.ClOrdLinkID } + +//NewClOrdLinkID returns a new ClOrdLinkIDField initialized with val +func NewClOrdLinkID(val string) ClOrdLinkIDField { + return ClOrdLinkIDField{quickfix.FIXString(val)} +} + +//ClearingAccountField is a STRING field +type ClearingAccountField struct{ quickfix.FIXString } + +//Tag returns tag.ClearingAccount (440) +func (f ClearingAccountField) Tag() quickfix.Tag { return tag.ClearingAccount } + +//NewClearingAccount returns a new ClearingAccountField initialized with val +func NewClearingAccount(val string) ClearingAccountField { + return ClearingAccountField{quickfix.FIXString(val)} +} + +//ClearingBusinessDateField is a LOCALMKTDATE field +type ClearingBusinessDateField struct{ quickfix.FIXString } + +//Tag returns tag.ClearingBusinessDate (715) +func (f ClearingBusinessDateField) Tag() quickfix.Tag { return tag.ClearingBusinessDate } + +//NewClearingBusinessDate returns a new ClearingBusinessDateField initialized with val +func NewClearingBusinessDate(val string) ClearingBusinessDateField { + return ClearingBusinessDateField{quickfix.FIXString(val)} +} + +//ClearingFeeIndicatorField is a STRING field +type ClearingFeeIndicatorField struct{ quickfix.FIXString } + +//Tag returns tag.ClearingFeeIndicator (635) +func (f ClearingFeeIndicatorField) Tag() quickfix.Tag { return tag.ClearingFeeIndicator } + +//NewClearingFeeIndicator returns a new ClearingFeeIndicatorField initialized with val +func NewClearingFeeIndicator(val string) ClearingFeeIndicatorField { + return ClearingFeeIndicatorField{quickfix.FIXString(val)} +} + +//ClearingFirmField is a STRING field +type ClearingFirmField struct{ quickfix.FIXString } + +//Tag returns tag.ClearingFirm (439) +func (f ClearingFirmField) Tag() quickfix.Tag { return tag.ClearingFirm } + +//NewClearingFirm returns a new ClearingFirmField initialized with val +func NewClearingFirm(val string) ClearingFirmField { + return ClearingFirmField{quickfix.FIXString(val)} +} + +//ClearingInstructionField is a INT field +type ClearingInstructionField struct{ quickfix.FIXInt } + +//Tag returns tag.ClearingInstruction (577) +func (f ClearingInstructionField) Tag() quickfix.Tag { return tag.ClearingInstruction } + +//NewClearingInstruction returns a new ClearingInstructionField initialized with val +func NewClearingInstruction(val int) ClearingInstructionField { + return ClearingInstructionField{quickfix.FIXInt(val)} +} + +//ClientBidIDField is a STRING field +type ClientBidIDField struct{ quickfix.FIXString } + +//Tag returns tag.ClientBidID (391) +func (f ClientBidIDField) Tag() quickfix.Tag { return tag.ClientBidID } + +//NewClientBidID returns a new ClientBidIDField initialized with val +func NewClientBidID(val string) ClientBidIDField { + return ClientBidIDField{quickfix.FIXString(val)} +} + +//ClientIDField is a STRING field +type ClientIDField struct{ quickfix.FIXString } + +//Tag returns tag.ClientID (109) +func (f ClientIDField) Tag() quickfix.Tag { return tag.ClientID } + +//NewClientID returns a new ClientIDField initialized with val +func NewClientID(val string) ClientIDField { + return ClientIDField{quickfix.FIXString(val)} +} + +//CollActionField is a INT field +type CollActionField struct{ quickfix.FIXInt } + +//Tag returns tag.CollAction (944) +func (f CollActionField) Tag() quickfix.Tag { return tag.CollAction } + +//NewCollAction returns a new CollActionField initialized with val +func NewCollAction(val int) CollActionField { + return CollActionField{quickfix.FIXInt(val)} +} + +//CollApplTypeField is a INT field +type CollApplTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.CollApplType (1043) +func (f CollApplTypeField) Tag() quickfix.Tag { return tag.CollApplType } + +//NewCollApplType returns a new CollApplTypeField initialized with val +func NewCollApplType(val int) CollApplTypeField { + return CollApplTypeField{quickfix.FIXInt(val)} +} + +//CollAsgnIDField is a STRING field +type CollAsgnIDField struct{ quickfix.FIXString } + +//Tag returns tag.CollAsgnID (902) +func (f CollAsgnIDField) Tag() quickfix.Tag { return tag.CollAsgnID } + +//NewCollAsgnID returns a new CollAsgnIDField initialized with val +func NewCollAsgnID(val string) CollAsgnIDField { + return CollAsgnIDField{quickfix.FIXString(val)} +} + +//CollAsgnReasonField is a INT field +type CollAsgnReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.CollAsgnReason (895) +func (f CollAsgnReasonField) Tag() quickfix.Tag { return tag.CollAsgnReason } + +//NewCollAsgnReason returns a new CollAsgnReasonField initialized with val +func NewCollAsgnReason(val int) CollAsgnReasonField { + return CollAsgnReasonField{quickfix.FIXInt(val)} +} + +//CollAsgnRefIDField is a STRING field +type CollAsgnRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.CollAsgnRefID (907) +func (f CollAsgnRefIDField) Tag() quickfix.Tag { return tag.CollAsgnRefID } + +//NewCollAsgnRefID returns a new CollAsgnRefIDField initialized with val +func NewCollAsgnRefID(val string) CollAsgnRefIDField { + return CollAsgnRefIDField{quickfix.FIXString(val)} +} + +//CollAsgnRejectReasonField is a INT field +type CollAsgnRejectReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.CollAsgnRejectReason (906) +func (f CollAsgnRejectReasonField) Tag() quickfix.Tag { return tag.CollAsgnRejectReason } + +//NewCollAsgnRejectReason returns a new CollAsgnRejectReasonField initialized with val +func NewCollAsgnRejectReason(val int) CollAsgnRejectReasonField { + return CollAsgnRejectReasonField{quickfix.FIXInt(val)} +} + +//CollAsgnRespTypeField is a INT field +type CollAsgnRespTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.CollAsgnRespType (905) +func (f CollAsgnRespTypeField) Tag() quickfix.Tag { return tag.CollAsgnRespType } + +//NewCollAsgnRespType returns a new CollAsgnRespTypeField initialized with val +func NewCollAsgnRespType(val int) CollAsgnRespTypeField { + return CollAsgnRespTypeField{quickfix.FIXInt(val)} +} + +//CollAsgnTransTypeField is a INT field +type CollAsgnTransTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.CollAsgnTransType (903) +func (f CollAsgnTransTypeField) Tag() quickfix.Tag { return tag.CollAsgnTransType } + +//NewCollAsgnTransType returns a new CollAsgnTransTypeField initialized with val +func NewCollAsgnTransType(val int) CollAsgnTransTypeField { + return CollAsgnTransTypeField{quickfix.FIXInt(val)} +} + +//CollInquiryIDField is a STRING field +type CollInquiryIDField struct{ quickfix.FIXString } + +//Tag returns tag.CollInquiryID (909) +func (f CollInquiryIDField) Tag() quickfix.Tag { return tag.CollInquiryID } + +//NewCollInquiryID returns a new CollInquiryIDField initialized with val +func NewCollInquiryID(val string) CollInquiryIDField { + return CollInquiryIDField{quickfix.FIXString(val)} +} + +//CollInquiryQualifierField is a INT field +type CollInquiryQualifierField struct{ quickfix.FIXInt } + +//Tag returns tag.CollInquiryQualifier (896) +func (f CollInquiryQualifierField) Tag() quickfix.Tag { return tag.CollInquiryQualifier } + +//NewCollInquiryQualifier returns a new CollInquiryQualifierField initialized with val +func NewCollInquiryQualifier(val int) CollInquiryQualifierField { + return CollInquiryQualifierField{quickfix.FIXInt(val)} +} + +//CollInquiryResultField is a INT field +type CollInquiryResultField struct{ quickfix.FIXInt } + +//Tag returns tag.CollInquiryResult (946) +func (f CollInquiryResultField) Tag() quickfix.Tag { return tag.CollInquiryResult } + +//NewCollInquiryResult returns a new CollInquiryResultField initialized with val +func NewCollInquiryResult(val int) CollInquiryResultField { + return CollInquiryResultField{quickfix.FIXInt(val)} +} + +//CollInquiryStatusField is a INT field +type CollInquiryStatusField struct{ quickfix.FIXInt } + +//Tag returns tag.CollInquiryStatus (945) +func (f CollInquiryStatusField) Tag() quickfix.Tag { return tag.CollInquiryStatus } + +//NewCollInquiryStatus returns a new CollInquiryStatusField initialized with val +func NewCollInquiryStatus(val int) CollInquiryStatusField { + return CollInquiryStatusField{quickfix.FIXInt(val)} +} + +//CollReqIDField is a STRING field +type CollReqIDField struct{ quickfix.FIXString } + +//Tag returns tag.CollReqID (894) +func (f CollReqIDField) Tag() quickfix.Tag { return tag.CollReqID } + +//NewCollReqID returns a new CollReqIDField initialized with val +func NewCollReqID(val string) CollReqIDField { + return CollReqIDField{quickfix.FIXString(val)} +} + +//CollRespIDField is a STRING field +type CollRespIDField struct{ quickfix.FIXString } + +//Tag returns tag.CollRespID (904) +func (f CollRespIDField) Tag() quickfix.Tag { return tag.CollRespID } + +//NewCollRespID returns a new CollRespIDField initialized with val +func NewCollRespID(val string) CollRespIDField { + return CollRespIDField{quickfix.FIXString(val)} +} + +//CollRptIDField is a STRING field +type CollRptIDField struct{ quickfix.FIXString } + +//Tag returns tag.CollRptID (908) +func (f CollRptIDField) Tag() quickfix.Tag { return tag.CollRptID } + +//NewCollRptID returns a new CollRptIDField initialized with val +func NewCollRptID(val string) CollRptIDField { + return CollRptIDField{quickfix.FIXString(val)} +} + +//CollStatusField is a INT field +type CollStatusField struct{ quickfix.FIXInt } + +//Tag returns tag.CollStatus (910) +func (f CollStatusField) Tag() quickfix.Tag { return tag.CollStatus } + +//NewCollStatus returns a new CollStatusField initialized with val +func NewCollStatus(val int) CollStatusField { + return CollStatusField{quickfix.FIXInt(val)} +} + +//CommCurrencyField is a CURRENCY field +type CommCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.CommCurrency (479) +func (f CommCurrencyField) Tag() quickfix.Tag { return tag.CommCurrency } + +//NewCommCurrency returns a new CommCurrencyField initialized with val +func NewCommCurrency(val string) CommCurrencyField { + return CommCurrencyField{quickfix.FIXString(val)} +} + +//CommTypeField is a CHAR field +type CommTypeField struct{ quickfix.FIXString } + +//Tag returns tag.CommType (13) +func (f CommTypeField) Tag() quickfix.Tag { return tag.CommType } + +//NewCommType returns a new CommTypeField initialized with val +func NewCommType(val string) CommTypeField { + return CommTypeField{quickfix.FIXString(val)} +} + +//CommissionField is a AMT field +type CommissionField struct{ quickfix.FIXFloat } + +//Tag returns tag.Commission (12) +func (f CommissionField) Tag() quickfix.Tag { return tag.Commission } + +//NewCommission returns a new CommissionField initialized with val +func NewCommission(val float64) CommissionField { + return CommissionField{quickfix.FIXFloat(val)} +} + +//ComplexEventConditionField is a INT field +type ComplexEventConditionField struct{ quickfix.FIXInt } + +//Tag returns tag.ComplexEventCondition (1490) +func (f ComplexEventConditionField) Tag() quickfix.Tag { return tag.ComplexEventCondition } + +//NewComplexEventCondition returns a new ComplexEventConditionField initialized with val +func NewComplexEventCondition(val int) ComplexEventConditionField { + return ComplexEventConditionField{quickfix.FIXInt(val)} +} + +//ComplexEventEndDateField is a UTCTIMESTAMP field +type ComplexEventEndDateField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.ComplexEventEndDate (1493) +func (f ComplexEventEndDateField) Tag() quickfix.Tag { return tag.ComplexEventEndDate } + +//NewComplexEventEndDate returns a new ComplexEventEndDateField initialized with val +func NewComplexEventEndDate(val time.Time) ComplexEventEndDateField { + return ComplexEventEndDateField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewComplexEventEndDateNoMillis returns a new ComplexEventEndDateField initialized with val without millisecs +func NewComplexEventEndDateNoMillis(val time.Time) ComplexEventEndDateField { + return ComplexEventEndDateField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//ComplexEventEndTimeField is a UTCTIMEONLY field +type ComplexEventEndTimeField struct{ quickfix.FIXString } + +//Tag returns tag.ComplexEventEndTime (1496) +func (f ComplexEventEndTimeField) Tag() quickfix.Tag { return tag.ComplexEventEndTime } + +//NewComplexEventEndTime returns a new ComplexEventEndTimeField initialized with val +func NewComplexEventEndTime(val string) ComplexEventEndTimeField { + return ComplexEventEndTimeField{quickfix.FIXString(val)} +} + +//ComplexEventPriceField is a PRICE field +type ComplexEventPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.ComplexEventPrice (1486) +func (f ComplexEventPriceField) Tag() quickfix.Tag { return tag.ComplexEventPrice } + +//NewComplexEventPrice returns a new ComplexEventPriceField initialized with val +func NewComplexEventPrice(val float64) ComplexEventPriceField { + return ComplexEventPriceField{quickfix.FIXFloat(val)} +} + +//ComplexEventPriceBoundaryMethodField is a INT field +type ComplexEventPriceBoundaryMethodField struct{ quickfix.FIXInt } + +//Tag returns tag.ComplexEventPriceBoundaryMethod (1487) +func (f ComplexEventPriceBoundaryMethodField) Tag() quickfix.Tag { + return tag.ComplexEventPriceBoundaryMethod +} + +//NewComplexEventPriceBoundaryMethod returns a new ComplexEventPriceBoundaryMethodField initialized with val +func NewComplexEventPriceBoundaryMethod(val int) ComplexEventPriceBoundaryMethodField { + return ComplexEventPriceBoundaryMethodField{quickfix.FIXInt(val)} +} + +//ComplexEventPriceBoundaryPrecisionField is a PERCENTAGE field +type ComplexEventPriceBoundaryPrecisionField struct{ quickfix.FIXFloat } + +//Tag returns tag.ComplexEventPriceBoundaryPrecision (1488) +func (f ComplexEventPriceBoundaryPrecisionField) Tag() quickfix.Tag { + return tag.ComplexEventPriceBoundaryPrecision +} + +//NewComplexEventPriceBoundaryPrecision returns a new ComplexEventPriceBoundaryPrecisionField initialized with val +func NewComplexEventPriceBoundaryPrecision(val float64) ComplexEventPriceBoundaryPrecisionField { + return ComplexEventPriceBoundaryPrecisionField{quickfix.FIXFloat(val)} +} + +//ComplexEventPriceTimeTypeField is a INT field +type ComplexEventPriceTimeTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.ComplexEventPriceTimeType (1489) +func (f ComplexEventPriceTimeTypeField) Tag() quickfix.Tag { return tag.ComplexEventPriceTimeType } + +//NewComplexEventPriceTimeType returns a new ComplexEventPriceTimeTypeField initialized with val +func NewComplexEventPriceTimeType(val int) ComplexEventPriceTimeTypeField { + return ComplexEventPriceTimeTypeField{quickfix.FIXInt(val)} +} + +//ComplexEventStartDateField is a UTCTIMESTAMP field +type ComplexEventStartDateField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.ComplexEventStartDate (1492) +func (f ComplexEventStartDateField) Tag() quickfix.Tag { return tag.ComplexEventStartDate } + +//NewComplexEventStartDate returns a new ComplexEventStartDateField initialized with val +func NewComplexEventStartDate(val time.Time) ComplexEventStartDateField { + return ComplexEventStartDateField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewComplexEventStartDateNoMillis returns a new ComplexEventStartDateField initialized with val without millisecs +func NewComplexEventStartDateNoMillis(val time.Time) ComplexEventStartDateField { + return ComplexEventStartDateField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//ComplexEventStartTimeField is a UTCTIMEONLY field +type ComplexEventStartTimeField struct{ quickfix.FIXString } + +//Tag returns tag.ComplexEventStartTime (1495) +func (f ComplexEventStartTimeField) Tag() quickfix.Tag { return tag.ComplexEventStartTime } + +//NewComplexEventStartTime returns a new ComplexEventStartTimeField initialized with val +func NewComplexEventStartTime(val string) ComplexEventStartTimeField { + return ComplexEventStartTimeField{quickfix.FIXString(val)} +} + +//ComplexEventTypeField is a INT field +type ComplexEventTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.ComplexEventType (1484) +func (f ComplexEventTypeField) Tag() quickfix.Tag { return tag.ComplexEventType } + +//NewComplexEventType returns a new ComplexEventTypeField initialized with val +func NewComplexEventType(val int) ComplexEventTypeField { + return ComplexEventTypeField{quickfix.FIXInt(val)} +} + +//ComplexOptPayoutAmountField is a AMT field +type ComplexOptPayoutAmountField struct{ quickfix.FIXFloat } + +//Tag returns tag.ComplexOptPayoutAmount (1485) +func (f ComplexOptPayoutAmountField) Tag() quickfix.Tag { return tag.ComplexOptPayoutAmount } + +//NewComplexOptPayoutAmount returns a new ComplexOptPayoutAmountField initialized with val +func NewComplexOptPayoutAmount(val float64) ComplexOptPayoutAmountField { + return ComplexOptPayoutAmountField{quickfix.FIXFloat(val)} +} + +//ComplianceIDField is a STRING field +type ComplianceIDField struct{ quickfix.FIXString } + +//Tag returns tag.ComplianceID (376) +func (f ComplianceIDField) Tag() quickfix.Tag { return tag.ComplianceID } + +//NewComplianceID returns a new ComplianceIDField initialized with val +func NewComplianceID(val string) ComplianceIDField { + return ComplianceIDField{quickfix.FIXString(val)} +} + +//ConcessionField is a AMT field +type ConcessionField struct{ quickfix.FIXFloat } + +//Tag returns tag.Concession (238) +func (f ConcessionField) Tag() quickfix.Tag { return tag.Concession } + +//NewConcession returns a new ConcessionField initialized with val +func NewConcession(val float64) ConcessionField { + return ConcessionField{quickfix.FIXFloat(val)} +} + +//ConfirmIDField is a STRING field +type ConfirmIDField struct{ quickfix.FIXString } + +//Tag returns tag.ConfirmID (664) +func (f ConfirmIDField) Tag() quickfix.Tag { return tag.ConfirmID } + +//NewConfirmID returns a new ConfirmIDField initialized with val +func NewConfirmID(val string) ConfirmIDField { + return ConfirmIDField{quickfix.FIXString(val)} +} + +//ConfirmRefIDField is a STRING field +type ConfirmRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.ConfirmRefID (772) +func (f ConfirmRefIDField) Tag() quickfix.Tag { return tag.ConfirmRefID } + +//NewConfirmRefID returns a new ConfirmRefIDField initialized with val +func NewConfirmRefID(val string) ConfirmRefIDField { + return ConfirmRefIDField{quickfix.FIXString(val)} +} + +//ConfirmRejReasonField is a INT field +type ConfirmRejReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.ConfirmRejReason (774) +func (f ConfirmRejReasonField) Tag() quickfix.Tag { return tag.ConfirmRejReason } + +//NewConfirmRejReason returns a new ConfirmRejReasonField initialized with val +func NewConfirmRejReason(val int) ConfirmRejReasonField { + return ConfirmRejReasonField{quickfix.FIXInt(val)} +} + +//ConfirmReqIDField is a STRING field +type ConfirmReqIDField struct{ quickfix.FIXString } + +//Tag returns tag.ConfirmReqID (859) +func (f ConfirmReqIDField) Tag() quickfix.Tag { return tag.ConfirmReqID } + +//NewConfirmReqID returns a new ConfirmReqIDField initialized with val +func NewConfirmReqID(val string) ConfirmReqIDField { + return ConfirmReqIDField{quickfix.FIXString(val)} +} + +//ConfirmStatusField is a INT field +type ConfirmStatusField struct{ quickfix.FIXInt } + +//Tag returns tag.ConfirmStatus (665) +func (f ConfirmStatusField) Tag() quickfix.Tag { return tag.ConfirmStatus } + +//NewConfirmStatus returns a new ConfirmStatusField initialized with val +func NewConfirmStatus(val int) ConfirmStatusField { + return ConfirmStatusField{quickfix.FIXInt(val)} +} + +//ConfirmTransTypeField is a INT field +type ConfirmTransTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.ConfirmTransType (666) +func (f ConfirmTransTypeField) Tag() quickfix.Tag { return tag.ConfirmTransType } + +//NewConfirmTransType returns a new ConfirmTransTypeField initialized with val +func NewConfirmTransType(val int) ConfirmTransTypeField { + return ConfirmTransTypeField{quickfix.FIXInt(val)} +} + +//ConfirmTypeField is a INT field +type ConfirmTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.ConfirmType (773) +func (f ConfirmTypeField) Tag() quickfix.Tag { return tag.ConfirmType } + +//NewConfirmType returns a new ConfirmTypeField initialized with val +func NewConfirmType(val int) ConfirmTypeField { + return ConfirmTypeField{quickfix.FIXInt(val)} +} + +//ContAmtCurrField is a CURRENCY field +type ContAmtCurrField struct{ quickfix.FIXString } + +//Tag returns tag.ContAmtCurr (521) +func (f ContAmtCurrField) Tag() quickfix.Tag { return tag.ContAmtCurr } + +//NewContAmtCurr returns a new ContAmtCurrField initialized with val +func NewContAmtCurr(val string) ContAmtCurrField { + return ContAmtCurrField{quickfix.FIXString(val)} +} + +//ContAmtTypeField is a INT field +type ContAmtTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.ContAmtType (519) +func (f ContAmtTypeField) Tag() quickfix.Tag { return tag.ContAmtType } + +//NewContAmtType returns a new ContAmtTypeField initialized with val +func NewContAmtType(val int) ContAmtTypeField { + return ContAmtTypeField{quickfix.FIXInt(val)} +} + +//ContAmtValueField is a FLOAT field +type ContAmtValueField struct{ quickfix.FIXFloat } + +//Tag returns tag.ContAmtValue (520) +func (f ContAmtValueField) Tag() quickfix.Tag { return tag.ContAmtValue } + +//NewContAmtValue returns a new ContAmtValueField initialized with val +func NewContAmtValue(val float64) ContAmtValueField { + return ContAmtValueField{quickfix.FIXFloat(val)} +} + +//ContIntRptIDField is a STRING field +type ContIntRptIDField struct{ quickfix.FIXString } + +//Tag returns tag.ContIntRptID (977) +func (f ContIntRptIDField) Tag() quickfix.Tag { return tag.ContIntRptID } + +//NewContIntRptID returns a new ContIntRptIDField initialized with val +func NewContIntRptID(val string) ContIntRptIDField { + return ContIntRptIDField{quickfix.FIXString(val)} +} + +//ContextPartyIDField is a STRING field +type ContextPartyIDField struct{ quickfix.FIXString } + +//Tag returns tag.ContextPartyID (1523) +func (f ContextPartyIDField) Tag() quickfix.Tag { return tag.ContextPartyID } + +//NewContextPartyID returns a new ContextPartyIDField initialized with val +func NewContextPartyID(val string) ContextPartyIDField { + return ContextPartyIDField{quickfix.FIXString(val)} +} + +//ContextPartyIDSourceField is a CHAR field +type ContextPartyIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.ContextPartyIDSource (1524) +func (f ContextPartyIDSourceField) Tag() quickfix.Tag { return tag.ContextPartyIDSource } + +//NewContextPartyIDSource returns a new ContextPartyIDSourceField initialized with val +func NewContextPartyIDSource(val string) ContextPartyIDSourceField { + return ContextPartyIDSourceField{quickfix.FIXString(val)} +} + +//ContextPartyRoleField is a INT field +type ContextPartyRoleField struct{ quickfix.FIXInt } + +//Tag returns tag.ContextPartyRole (1525) +func (f ContextPartyRoleField) Tag() quickfix.Tag { return tag.ContextPartyRole } + +//NewContextPartyRole returns a new ContextPartyRoleField initialized with val +func NewContextPartyRole(val int) ContextPartyRoleField { + return ContextPartyRoleField{quickfix.FIXInt(val)} +} + +//ContextPartySubIDField is a STRING field +type ContextPartySubIDField struct{ quickfix.FIXString } + +//Tag returns tag.ContextPartySubID (1527) +func (f ContextPartySubIDField) Tag() quickfix.Tag { return tag.ContextPartySubID } + +//NewContextPartySubID returns a new ContextPartySubIDField initialized with val +func NewContextPartySubID(val string) ContextPartySubIDField { + return ContextPartySubIDField{quickfix.FIXString(val)} +} + +//ContextPartySubIDTypeField is a INT field +type ContextPartySubIDTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.ContextPartySubIDType (1528) +func (f ContextPartySubIDTypeField) Tag() quickfix.Tag { return tag.ContextPartySubIDType } + +//NewContextPartySubIDType returns a new ContextPartySubIDTypeField initialized with val +func NewContextPartySubIDType(val int) ContextPartySubIDTypeField { + return ContextPartySubIDTypeField{quickfix.FIXInt(val)} +} + +//ContingencyTypeField is a INT field +type ContingencyTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.ContingencyType (1385) +func (f ContingencyTypeField) Tag() quickfix.Tag { return tag.ContingencyType } + +//NewContingencyType returns a new ContingencyTypeField initialized with val +func NewContingencyType(val int) ContingencyTypeField { + return ContingencyTypeField{quickfix.FIXInt(val)} +} + +//ContraBrokerField is a STRING field +type ContraBrokerField struct{ quickfix.FIXString } + +//Tag returns tag.ContraBroker (375) +func (f ContraBrokerField) Tag() quickfix.Tag { return tag.ContraBroker } + +//NewContraBroker returns a new ContraBrokerField initialized with val +func NewContraBroker(val string) ContraBrokerField { + return ContraBrokerField{quickfix.FIXString(val)} +} + +//ContraLegRefIDField is a STRING field +type ContraLegRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.ContraLegRefID (655) +func (f ContraLegRefIDField) Tag() quickfix.Tag { return tag.ContraLegRefID } + +//NewContraLegRefID returns a new ContraLegRefIDField initialized with val +func NewContraLegRefID(val string) ContraLegRefIDField { + return ContraLegRefIDField{quickfix.FIXString(val)} +} + +//ContraTradeQtyField is a QTY field +type ContraTradeQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.ContraTradeQty (437) +func (f ContraTradeQtyField) Tag() quickfix.Tag { return tag.ContraTradeQty } + +//NewContraTradeQty returns a new ContraTradeQtyField initialized with val +func NewContraTradeQty(val float64) ContraTradeQtyField { + return ContraTradeQtyField{quickfix.FIXFloat(val)} +} + +//ContraTradeTimeField is a UTCTIMESTAMP field +type ContraTradeTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.ContraTradeTime (438) +func (f ContraTradeTimeField) Tag() quickfix.Tag { return tag.ContraTradeTime } + +//NewContraTradeTime returns a new ContraTradeTimeField initialized with val +func NewContraTradeTime(val time.Time) ContraTradeTimeField { + return ContraTradeTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewContraTradeTimeNoMillis returns a new ContraTradeTimeField initialized with val without millisecs +func NewContraTradeTimeNoMillis(val time.Time) ContraTradeTimeField { + return ContraTradeTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//ContraTraderField is a STRING field +type ContraTraderField struct{ quickfix.FIXString } + +//Tag returns tag.ContraTrader (337) +func (f ContraTraderField) Tag() quickfix.Tag { return tag.ContraTrader } + +//NewContraTrader returns a new ContraTraderField initialized with val +func NewContraTrader(val string) ContraTraderField { + return ContraTraderField{quickfix.FIXString(val)} +} + +//ContractMultiplierField is a FLOAT field +type ContractMultiplierField struct{ quickfix.FIXFloat } + +//Tag returns tag.ContractMultiplier (231) +func (f ContractMultiplierField) Tag() quickfix.Tag { return tag.ContractMultiplier } + +//NewContractMultiplier returns a new ContractMultiplierField initialized with val +func NewContractMultiplier(val float64) ContractMultiplierField { + return ContractMultiplierField{quickfix.FIXFloat(val)} +} + +//ContractMultiplierUnitField is a INT field +type ContractMultiplierUnitField struct{ quickfix.FIXInt } + +//Tag returns tag.ContractMultiplierUnit (1435) +func (f ContractMultiplierUnitField) Tag() quickfix.Tag { return tag.ContractMultiplierUnit } + +//NewContractMultiplierUnit returns a new ContractMultiplierUnitField initialized with val +func NewContractMultiplierUnit(val int) ContractMultiplierUnitField { + return ContractMultiplierUnitField{quickfix.FIXInt(val)} +} + +//ContractSettlMonthField is a MONTHYEAR field +type ContractSettlMonthField struct{ quickfix.FIXString } + +//Tag returns tag.ContractSettlMonth (667) +func (f ContractSettlMonthField) Tag() quickfix.Tag { return tag.ContractSettlMonth } + +//NewContractSettlMonth returns a new ContractSettlMonthField initialized with val +func NewContractSettlMonth(val string) ContractSettlMonthField { + return ContractSettlMonthField{quickfix.FIXString(val)} +} + +//ContraryInstructionIndicatorField is a BOOLEAN field +type ContraryInstructionIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.ContraryInstructionIndicator (719) +func (f ContraryInstructionIndicatorField) Tag() quickfix.Tag { return tag.ContraryInstructionIndicator } + +//NewContraryInstructionIndicator returns a new ContraryInstructionIndicatorField initialized with val +func NewContraryInstructionIndicator(val bool) ContraryInstructionIndicatorField { + return ContraryInstructionIndicatorField{quickfix.FIXBoolean(val)} +} + +//CopyMsgIndicatorField is a BOOLEAN field +type CopyMsgIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.CopyMsgIndicator (797) +func (f CopyMsgIndicatorField) Tag() quickfix.Tag { return tag.CopyMsgIndicator } + +//NewCopyMsgIndicator returns a new CopyMsgIndicatorField initialized with val +func NewCopyMsgIndicator(val bool) CopyMsgIndicatorField { + return CopyMsgIndicatorField{quickfix.FIXBoolean(val)} +} + +//CorporateActionField is a MULTIPLECHARVALUE field +type CorporateActionField struct{ quickfix.FIXString } + +//Tag returns tag.CorporateAction (292) +func (f CorporateActionField) Tag() quickfix.Tag { return tag.CorporateAction } + +//NewCorporateAction returns a new CorporateActionField initialized with val +func NewCorporateAction(val string) CorporateActionField { + return CorporateActionField{quickfix.FIXString(val)} +} + +//CountryField is a COUNTRY field +type CountryField struct{ quickfix.FIXString } + +//Tag returns tag.Country (421) +func (f CountryField) Tag() quickfix.Tag { return tag.Country } + +//NewCountry returns a new CountryField initialized with val +func NewCountry(val string) CountryField { + return CountryField{quickfix.FIXString(val)} +} + +//CountryOfIssueField is a COUNTRY field +type CountryOfIssueField struct{ quickfix.FIXString } + +//Tag returns tag.CountryOfIssue (470) +func (f CountryOfIssueField) Tag() quickfix.Tag { return tag.CountryOfIssue } + +//NewCountryOfIssue returns a new CountryOfIssueField initialized with val +func NewCountryOfIssue(val string) CountryOfIssueField { + return CountryOfIssueField{quickfix.FIXString(val)} +} + +//CouponPaymentDateField is a LOCALMKTDATE field +type CouponPaymentDateField struct{ quickfix.FIXString } + +//Tag returns tag.CouponPaymentDate (224) +func (f CouponPaymentDateField) Tag() quickfix.Tag { return tag.CouponPaymentDate } + +//NewCouponPaymentDate returns a new CouponPaymentDateField initialized with val +func NewCouponPaymentDate(val string) CouponPaymentDateField { + return CouponPaymentDateField{quickfix.FIXString(val)} +} + +//CouponRateField is a PERCENTAGE field +type CouponRateField struct{ quickfix.FIXFloat } + +//Tag returns tag.CouponRate (223) +func (f CouponRateField) Tag() quickfix.Tag { return tag.CouponRate } + +//NewCouponRate returns a new CouponRateField initialized with val +func NewCouponRate(val float64) CouponRateField { + return CouponRateField{quickfix.FIXFloat(val)} +} + +//CoveredOrUncoveredField is a INT field +type CoveredOrUncoveredField struct{ quickfix.FIXInt } + +//Tag returns tag.CoveredOrUncovered (203) +func (f CoveredOrUncoveredField) Tag() quickfix.Tag { return tag.CoveredOrUncovered } + +//NewCoveredOrUncovered returns a new CoveredOrUncoveredField initialized with val +func NewCoveredOrUncovered(val int) CoveredOrUncoveredField { + return CoveredOrUncoveredField{quickfix.FIXInt(val)} +} + +//CreditRatingField is a STRING field +type CreditRatingField struct{ quickfix.FIXString } + +//Tag returns tag.CreditRating (255) +func (f CreditRatingField) Tag() quickfix.Tag { return tag.CreditRating } + +//NewCreditRating returns a new CreditRatingField initialized with val +func NewCreditRating(val string) CreditRatingField { + return CreditRatingField{quickfix.FIXString(val)} +} + +//CrossIDField is a STRING field +type CrossIDField struct{ quickfix.FIXString } + +//Tag returns tag.CrossID (548) +func (f CrossIDField) Tag() quickfix.Tag { return tag.CrossID } + +//NewCrossID returns a new CrossIDField initialized with val +func NewCrossID(val string) CrossIDField { + return CrossIDField{quickfix.FIXString(val)} +} + +//CrossPercentField is a PERCENTAGE field +type CrossPercentField struct{ quickfix.FIXFloat } + +//Tag returns tag.CrossPercent (413) +func (f CrossPercentField) Tag() quickfix.Tag { return tag.CrossPercent } + +//NewCrossPercent returns a new CrossPercentField initialized with val +func NewCrossPercent(val float64) CrossPercentField { + return CrossPercentField{quickfix.FIXFloat(val)} +} + +//CrossPrioritizationField is a INT field +type CrossPrioritizationField struct{ quickfix.FIXInt } + +//Tag returns tag.CrossPrioritization (550) +func (f CrossPrioritizationField) Tag() quickfix.Tag { return tag.CrossPrioritization } + +//NewCrossPrioritization returns a new CrossPrioritizationField initialized with val +func NewCrossPrioritization(val int) CrossPrioritizationField { + return CrossPrioritizationField{quickfix.FIXInt(val)} +} + +//CrossTypeField is a INT field +type CrossTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.CrossType (549) +func (f CrossTypeField) Tag() quickfix.Tag { return tag.CrossType } + +//NewCrossType returns a new CrossTypeField initialized with val +func NewCrossType(val int) CrossTypeField { + return CrossTypeField{quickfix.FIXInt(val)} +} + +//CstmApplVerIDField is a STRING field +type CstmApplVerIDField struct{ quickfix.FIXString } + +//Tag returns tag.CstmApplVerID (1129) +func (f CstmApplVerIDField) Tag() quickfix.Tag { return tag.CstmApplVerID } + +//NewCstmApplVerID returns a new CstmApplVerIDField initialized with val +func NewCstmApplVerID(val string) CstmApplVerIDField { + return CstmApplVerIDField{quickfix.FIXString(val)} +} + +//CumQtyField is a QTY field +type CumQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.CumQty (14) +func (f CumQtyField) Tag() quickfix.Tag { return tag.CumQty } + +//NewCumQty returns a new CumQtyField initialized with val +func NewCumQty(val float64) CumQtyField { + return CumQtyField{quickfix.FIXFloat(val)} +} + +//CurrencyField is a CURRENCY field +type CurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.Currency (15) +func (f CurrencyField) Tag() quickfix.Tag { return tag.Currency } + +//NewCurrency returns a new CurrencyField initialized with val +func NewCurrency(val string) CurrencyField { + return CurrencyField{quickfix.FIXString(val)} +} + +//CurrencyRatioField is a FLOAT field +type CurrencyRatioField struct{ quickfix.FIXFloat } + +//Tag returns tag.CurrencyRatio (1382) +func (f CurrencyRatioField) Tag() quickfix.Tag { return tag.CurrencyRatio } + +//NewCurrencyRatio returns a new CurrencyRatioField initialized with val +func NewCurrencyRatio(val float64) CurrencyRatioField { + return CurrencyRatioField{quickfix.FIXFloat(val)} +} + +//CustDirectedOrderField is a BOOLEAN field +type CustDirectedOrderField struct{ quickfix.FIXBoolean } + +//Tag returns tag.CustDirectedOrder (1029) +func (f CustDirectedOrderField) Tag() quickfix.Tag { return tag.CustDirectedOrder } + +//NewCustDirectedOrder returns a new CustDirectedOrderField initialized with val +func NewCustDirectedOrder(val bool) CustDirectedOrderField { + return CustDirectedOrderField{quickfix.FIXBoolean(val)} +} + +//CustOrderCapacityField is a INT field +type CustOrderCapacityField struct{ quickfix.FIXInt } + +//Tag returns tag.CustOrderCapacity (582) +func (f CustOrderCapacityField) Tag() quickfix.Tag { return tag.CustOrderCapacity } + +//NewCustOrderCapacity returns a new CustOrderCapacityField initialized with val +func NewCustOrderCapacity(val int) CustOrderCapacityField { + return CustOrderCapacityField{quickfix.FIXInt(val)} +} + +//CustOrderHandlingInstField is a MULTIPLESTRINGVALUE field +type CustOrderHandlingInstField struct{ quickfix.FIXString } + +//Tag returns tag.CustOrderHandlingInst (1031) +func (f CustOrderHandlingInstField) Tag() quickfix.Tag { return tag.CustOrderHandlingInst } + +//NewCustOrderHandlingInst returns a new CustOrderHandlingInstField initialized with val +func NewCustOrderHandlingInst(val string) CustOrderHandlingInstField { + return CustOrderHandlingInstField{quickfix.FIXString(val)} +} + +//CustomerOrFirmField is a INT field +type CustomerOrFirmField struct{ quickfix.FIXInt } + +//Tag returns tag.CustomerOrFirm (204) +func (f CustomerOrFirmField) Tag() quickfix.Tag { return tag.CustomerOrFirm } + +//NewCustomerOrFirm returns a new CustomerOrFirmField initialized with val +func NewCustomerOrFirm(val int) CustomerOrFirmField { + return CustomerOrFirmField{quickfix.FIXInt(val)} +} + +//CxlQtyField is a QTY field +type CxlQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.CxlQty (84) +func (f CxlQtyField) Tag() quickfix.Tag { return tag.CxlQty } + +//NewCxlQty returns a new CxlQtyField initialized with val +func NewCxlQty(val float64) CxlQtyField { + return CxlQtyField{quickfix.FIXFloat(val)} +} + +//CxlRejReasonField is a INT field +type CxlRejReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.CxlRejReason (102) +func (f CxlRejReasonField) Tag() quickfix.Tag { return tag.CxlRejReason } + +//NewCxlRejReason returns a new CxlRejReasonField initialized with val +func NewCxlRejReason(val int) CxlRejReasonField { + return CxlRejReasonField{quickfix.FIXInt(val)} +} + +//CxlRejResponseToField is a CHAR field +type CxlRejResponseToField struct{ quickfix.FIXString } + +//Tag returns tag.CxlRejResponseTo (434) +func (f CxlRejResponseToField) Tag() quickfix.Tag { return tag.CxlRejResponseTo } + +//NewCxlRejResponseTo returns a new CxlRejResponseToField initialized with val +func NewCxlRejResponseTo(val string) CxlRejResponseToField { + return CxlRejResponseToField{quickfix.FIXString(val)} +} + +//CxlTypeField is a CHAR field +type CxlTypeField struct{ quickfix.FIXString } + +//Tag returns tag.CxlType (125) +func (f CxlTypeField) Tag() quickfix.Tag { return tag.CxlType } + +//NewCxlType returns a new CxlTypeField initialized with val +func NewCxlType(val string) CxlTypeField { + return CxlTypeField{quickfix.FIXString(val)} +} + +//DKReasonField is a CHAR field +type DKReasonField struct{ quickfix.FIXString } + +//Tag returns tag.DKReason (127) +func (f DKReasonField) Tag() quickfix.Tag { return tag.DKReason } + +//NewDKReason returns a new DKReasonField initialized with val +func NewDKReason(val string) DKReasonField { + return DKReasonField{quickfix.FIXString(val)} +} + +//DateOfBirthField is a LOCALMKTDATE field +type DateOfBirthField struct{ quickfix.FIXString } + +//Tag returns tag.DateOfBirth (486) +func (f DateOfBirthField) Tag() quickfix.Tag { return tag.DateOfBirth } + +//NewDateOfBirth returns a new DateOfBirthField initialized with val +func NewDateOfBirth(val string) DateOfBirthField { + return DateOfBirthField{quickfix.FIXString(val)} +} + +//DatedDateField is a LOCALMKTDATE field +type DatedDateField struct{ quickfix.FIXString } + +//Tag returns tag.DatedDate (873) +func (f DatedDateField) Tag() quickfix.Tag { return tag.DatedDate } + +//NewDatedDate returns a new DatedDateField initialized with val +func NewDatedDate(val string) DatedDateField { + return DatedDateField{quickfix.FIXString(val)} +} + +//DayAvgPxField is a PRICE field +type DayAvgPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.DayAvgPx (426) +func (f DayAvgPxField) Tag() quickfix.Tag { return tag.DayAvgPx } + +//NewDayAvgPx returns a new DayAvgPxField initialized with val +func NewDayAvgPx(val float64) DayAvgPxField { + return DayAvgPxField{quickfix.FIXFloat(val)} +} + +//DayBookingInstField is a CHAR field +type DayBookingInstField struct{ quickfix.FIXString } + +//Tag returns tag.DayBookingInst (589) +func (f DayBookingInstField) Tag() quickfix.Tag { return tag.DayBookingInst } + +//NewDayBookingInst returns a new DayBookingInstField initialized with val +func NewDayBookingInst(val string) DayBookingInstField { + return DayBookingInstField{quickfix.FIXString(val)} +} + +//DayCumQtyField is a QTY field +type DayCumQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.DayCumQty (425) +func (f DayCumQtyField) Tag() quickfix.Tag { return tag.DayCumQty } + +//NewDayCumQty returns a new DayCumQtyField initialized with val +func NewDayCumQty(val float64) DayCumQtyField { + return DayCumQtyField{quickfix.FIXFloat(val)} +} + +//DayOrderQtyField is a QTY field +type DayOrderQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.DayOrderQty (424) +func (f DayOrderQtyField) Tag() quickfix.Tag { return tag.DayOrderQty } + +//NewDayOrderQty returns a new DayOrderQtyField initialized with val +func NewDayOrderQty(val float64) DayOrderQtyField { + return DayOrderQtyField{quickfix.FIXFloat(val)} +} + +//DealingCapacityField is a CHAR field +type DealingCapacityField struct{ quickfix.FIXString } + +//Tag returns tag.DealingCapacity (1048) +func (f DealingCapacityField) Tag() quickfix.Tag { return tag.DealingCapacity } + +//NewDealingCapacity returns a new DealingCapacityField initialized with val +func NewDealingCapacity(val string) DealingCapacityField { + return DealingCapacityField{quickfix.FIXString(val)} +} + +//DefBidSizeField is a QTY field +type DefBidSizeField struct{ quickfix.FIXFloat } + +//Tag returns tag.DefBidSize (293) +func (f DefBidSizeField) Tag() quickfix.Tag { return tag.DefBidSize } + +//NewDefBidSize returns a new DefBidSizeField initialized with val +func NewDefBidSize(val float64) DefBidSizeField { + return DefBidSizeField{quickfix.FIXFloat(val)} +} + +//DefOfferSizeField is a QTY field +type DefOfferSizeField struct{ quickfix.FIXFloat } + +//Tag returns tag.DefOfferSize (294) +func (f DefOfferSizeField) Tag() quickfix.Tag { return tag.DefOfferSize } + +//NewDefOfferSize returns a new DefOfferSizeField initialized with val +func NewDefOfferSize(val float64) DefOfferSizeField { + return DefOfferSizeField{quickfix.FIXFloat(val)} +} + +//DefaultApplExtIDField is a INT field +type DefaultApplExtIDField struct{ quickfix.FIXInt } + +//Tag returns tag.DefaultApplExtID (1407) +func (f DefaultApplExtIDField) Tag() quickfix.Tag { return tag.DefaultApplExtID } + +//NewDefaultApplExtID returns a new DefaultApplExtIDField initialized with val +func NewDefaultApplExtID(val int) DefaultApplExtIDField { + return DefaultApplExtIDField{quickfix.FIXInt(val)} +} + +//DefaultApplVerIDField is a STRING field +type DefaultApplVerIDField struct{ quickfix.FIXString } + +//Tag returns tag.DefaultApplVerID (1137) +func (f DefaultApplVerIDField) Tag() quickfix.Tag { return tag.DefaultApplVerID } + +//NewDefaultApplVerID returns a new DefaultApplVerIDField initialized with val +func NewDefaultApplVerID(val string) DefaultApplVerIDField { + return DefaultApplVerIDField{quickfix.FIXString(val)} +} + +//DefaultCstmApplVerIDField is a STRING field +type DefaultCstmApplVerIDField struct{ quickfix.FIXString } + +//Tag returns tag.DefaultCstmApplVerID (1408) +func (f DefaultCstmApplVerIDField) Tag() quickfix.Tag { return tag.DefaultCstmApplVerID } + +//NewDefaultCstmApplVerID returns a new DefaultCstmApplVerIDField initialized with val +func NewDefaultCstmApplVerID(val string) DefaultCstmApplVerIDField { + return DefaultCstmApplVerIDField{quickfix.FIXString(val)} +} + +//DefaultVerIndicatorField is a BOOLEAN field +type DefaultVerIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.DefaultVerIndicator (1410) +func (f DefaultVerIndicatorField) Tag() quickfix.Tag { return tag.DefaultVerIndicator } + +//NewDefaultVerIndicator returns a new DefaultVerIndicatorField initialized with val +func NewDefaultVerIndicator(val bool) DefaultVerIndicatorField { + return DefaultVerIndicatorField{quickfix.FIXBoolean(val)} +} + +//DeleteReasonField is a CHAR field +type DeleteReasonField struct{ quickfix.FIXString } + +//Tag returns tag.DeleteReason (285) +func (f DeleteReasonField) Tag() quickfix.Tag { return tag.DeleteReason } + +//NewDeleteReason returns a new DeleteReasonField initialized with val +func NewDeleteReason(val string) DeleteReasonField { + return DeleteReasonField{quickfix.FIXString(val)} +} + +//DeliverToCompIDField is a STRING field +type DeliverToCompIDField struct{ quickfix.FIXString } + +//Tag returns tag.DeliverToCompID (128) +func (f DeliverToCompIDField) Tag() quickfix.Tag { return tag.DeliverToCompID } + +//NewDeliverToCompID returns a new DeliverToCompIDField initialized with val +func NewDeliverToCompID(val string) DeliverToCompIDField { + return DeliverToCompIDField{quickfix.FIXString(val)} +} + +//DeliverToLocationIDField is a STRING field +type DeliverToLocationIDField struct{ quickfix.FIXString } + +//Tag returns tag.DeliverToLocationID (145) +func (f DeliverToLocationIDField) Tag() quickfix.Tag { return tag.DeliverToLocationID } + +//NewDeliverToLocationID returns a new DeliverToLocationIDField initialized with val +func NewDeliverToLocationID(val string) DeliverToLocationIDField { + return DeliverToLocationIDField{quickfix.FIXString(val)} +} + +//DeliverToSubIDField is a STRING field +type DeliverToSubIDField struct{ quickfix.FIXString } + +//Tag returns tag.DeliverToSubID (129) +func (f DeliverToSubIDField) Tag() quickfix.Tag { return tag.DeliverToSubID } + +//NewDeliverToSubID returns a new DeliverToSubIDField initialized with val +func NewDeliverToSubID(val string) DeliverToSubIDField { + return DeliverToSubIDField{quickfix.FIXString(val)} +} + +//DeliveryDateField is a LOCALMKTDATE field +type DeliveryDateField struct{ quickfix.FIXString } + +//Tag returns tag.DeliveryDate (743) +func (f DeliveryDateField) Tag() quickfix.Tag { return tag.DeliveryDate } + +//NewDeliveryDate returns a new DeliveryDateField initialized with val +func NewDeliveryDate(val string) DeliveryDateField { + return DeliveryDateField{quickfix.FIXString(val)} +} + +//DeliveryFormField is a INT field +type DeliveryFormField struct{ quickfix.FIXInt } + +//Tag returns tag.DeliveryForm (668) +func (f DeliveryFormField) Tag() quickfix.Tag { return tag.DeliveryForm } + +//NewDeliveryForm returns a new DeliveryFormField initialized with val +func NewDeliveryForm(val int) DeliveryFormField { + return DeliveryFormField{quickfix.FIXInt(val)} +} + +//DeliveryTypeField is a INT field +type DeliveryTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.DeliveryType (919) +func (f DeliveryTypeField) Tag() quickfix.Tag { return tag.DeliveryType } + +//NewDeliveryType returns a new DeliveryTypeField initialized with val +func NewDeliveryType(val int) DeliveryTypeField { + return DeliveryTypeField{quickfix.FIXInt(val)} +} + +//DerivFlexProductEligibilityIndicatorField is a BOOLEAN field +type DerivFlexProductEligibilityIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.DerivFlexProductEligibilityIndicator (1243) +func (f DerivFlexProductEligibilityIndicatorField) Tag() quickfix.Tag { + return tag.DerivFlexProductEligibilityIndicator +} + +//NewDerivFlexProductEligibilityIndicator returns a new DerivFlexProductEligibilityIndicatorField initialized with val +func NewDerivFlexProductEligibilityIndicator(val bool) DerivFlexProductEligibilityIndicatorField { + return DerivFlexProductEligibilityIndicatorField{quickfix.FIXBoolean(val)} +} + +//DerivativeCFICodeField is a STRING field +type DerivativeCFICodeField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeCFICode (1248) +func (f DerivativeCFICodeField) Tag() quickfix.Tag { return tag.DerivativeCFICode } + +//NewDerivativeCFICode returns a new DerivativeCFICodeField initialized with val +func NewDerivativeCFICode(val string) DerivativeCFICodeField { + return DerivativeCFICodeField{quickfix.FIXString(val)} +} + +//DerivativeCapPriceField is a PRICE field +type DerivativeCapPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.DerivativeCapPrice (1321) +func (f DerivativeCapPriceField) Tag() quickfix.Tag { return tag.DerivativeCapPrice } + +//NewDerivativeCapPrice returns a new DerivativeCapPriceField initialized with val +func NewDerivativeCapPrice(val float64) DerivativeCapPriceField { + return DerivativeCapPriceField{quickfix.FIXFloat(val)} +} + +//DerivativeContractMultiplierField is a FLOAT field +type DerivativeContractMultiplierField struct{ quickfix.FIXFloat } + +//Tag returns tag.DerivativeContractMultiplier (1266) +func (f DerivativeContractMultiplierField) Tag() quickfix.Tag { return tag.DerivativeContractMultiplier } + +//NewDerivativeContractMultiplier returns a new DerivativeContractMultiplierField initialized with val +func NewDerivativeContractMultiplier(val float64) DerivativeContractMultiplierField { + return DerivativeContractMultiplierField{quickfix.FIXFloat(val)} +} + +//DerivativeContractMultiplierUnitField is a INT field +type DerivativeContractMultiplierUnitField struct{ quickfix.FIXInt } + +//Tag returns tag.DerivativeContractMultiplierUnit (1438) +func (f DerivativeContractMultiplierUnitField) Tag() quickfix.Tag { + return tag.DerivativeContractMultiplierUnit +} + +//NewDerivativeContractMultiplierUnit returns a new DerivativeContractMultiplierUnitField initialized with val +func NewDerivativeContractMultiplierUnit(val int) DerivativeContractMultiplierUnitField { + return DerivativeContractMultiplierUnitField{quickfix.FIXInt(val)} +} + +//DerivativeContractSettlMonthField is a MONTHYEAR field +type DerivativeContractSettlMonthField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeContractSettlMonth (1285) +func (f DerivativeContractSettlMonthField) Tag() quickfix.Tag { return tag.DerivativeContractSettlMonth } + +//NewDerivativeContractSettlMonth returns a new DerivativeContractSettlMonthField initialized with val +func NewDerivativeContractSettlMonth(val string) DerivativeContractSettlMonthField { + return DerivativeContractSettlMonthField{quickfix.FIXString(val)} +} + +//DerivativeCountryOfIssueField is a COUNTRY field +type DerivativeCountryOfIssueField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeCountryOfIssue (1258) +func (f DerivativeCountryOfIssueField) Tag() quickfix.Tag { return tag.DerivativeCountryOfIssue } + +//NewDerivativeCountryOfIssue returns a new DerivativeCountryOfIssueField initialized with val +func NewDerivativeCountryOfIssue(val string) DerivativeCountryOfIssueField { + return DerivativeCountryOfIssueField{quickfix.FIXString(val)} +} + +//DerivativeEncodedIssuerField is a DATA field +type DerivativeEncodedIssuerField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeEncodedIssuer (1278) +func (f DerivativeEncodedIssuerField) Tag() quickfix.Tag { return tag.DerivativeEncodedIssuer } + +//NewDerivativeEncodedIssuer returns a new DerivativeEncodedIssuerField initialized with val +func NewDerivativeEncodedIssuer(val string) DerivativeEncodedIssuerField { + return DerivativeEncodedIssuerField{quickfix.FIXString(val)} +} + +//DerivativeEncodedIssuerLenField is a LENGTH field +type DerivativeEncodedIssuerLenField struct{ quickfix.FIXInt } + +//Tag returns tag.DerivativeEncodedIssuerLen (1277) +func (f DerivativeEncodedIssuerLenField) Tag() quickfix.Tag { return tag.DerivativeEncodedIssuerLen } + +//NewDerivativeEncodedIssuerLen returns a new DerivativeEncodedIssuerLenField initialized with val +func NewDerivativeEncodedIssuerLen(val int) DerivativeEncodedIssuerLenField { + return DerivativeEncodedIssuerLenField{quickfix.FIXInt(val)} +} + +//DerivativeEncodedSecurityDescField is a DATA field +type DerivativeEncodedSecurityDescField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeEncodedSecurityDesc (1281) +func (f DerivativeEncodedSecurityDescField) Tag() quickfix.Tag { + return tag.DerivativeEncodedSecurityDesc +} + +//NewDerivativeEncodedSecurityDesc returns a new DerivativeEncodedSecurityDescField initialized with val +func NewDerivativeEncodedSecurityDesc(val string) DerivativeEncodedSecurityDescField { + return DerivativeEncodedSecurityDescField{quickfix.FIXString(val)} +} + +//DerivativeEncodedSecurityDescLenField is a LENGTH field +type DerivativeEncodedSecurityDescLenField struct{ quickfix.FIXInt } + +//Tag returns tag.DerivativeEncodedSecurityDescLen (1280) +func (f DerivativeEncodedSecurityDescLenField) Tag() quickfix.Tag { + return tag.DerivativeEncodedSecurityDescLen +} + +//NewDerivativeEncodedSecurityDescLen returns a new DerivativeEncodedSecurityDescLenField initialized with val +func NewDerivativeEncodedSecurityDescLen(val int) DerivativeEncodedSecurityDescLenField { + return DerivativeEncodedSecurityDescLenField{quickfix.FIXInt(val)} +} + +//DerivativeEventDateField is a LOCALMKTDATE field +type DerivativeEventDateField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeEventDate (1288) +func (f DerivativeEventDateField) Tag() quickfix.Tag { return tag.DerivativeEventDate } + +//NewDerivativeEventDate returns a new DerivativeEventDateField initialized with val +func NewDerivativeEventDate(val string) DerivativeEventDateField { + return DerivativeEventDateField{quickfix.FIXString(val)} +} + +//DerivativeEventPxField is a PRICE field +type DerivativeEventPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.DerivativeEventPx (1290) +func (f DerivativeEventPxField) Tag() quickfix.Tag { return tag.DerivativeEventPx } + +//NewDerivativeEventPx returns a new DerivativeEventPxField initialized with val +func NewDerivativeEventPx(val float64) DerivativeEventPxField { + return DerivativeEventPxField{quickfix.FIXFloat(val)} +} + +//DerivativeEventTextField is a STRING field +type DerivativeEventTextField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeEventText (1291) +func (f DerivativeEventTextField) Tag() quickfix.Tag { return tag.DerivativeEventText } + +//NewDerivativeEventText returns a new DerivativeEventTextField initialized with val +func NewDerivativeEventText(val string) DerivativeEventTextField { + return DerivativeEventTextField{quickfix.FIXString(val)} +} + +//DerivativeEventTimeField is a UTCTIMESTAMP field +type DerivativeEventTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.DerivativeEventTime (1289) +func (f DerivativeEventTimeField) Tag() quickfix.Tag { return tag.DerivativeEventTime } + +//NewDerivativeEventTime returns a new DerivativeEventTimeField initialized with val +func NewDerivativeEventTime(val time.Time) DerivativeEventTimeField { + return DerivativeEventTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewDerivativeEventTimeNoMillis returns a new DerivativeEventTimeField initialized with val without millisecs +func NewDerivativeEventTimeNoMillis(val time.Time) DerivativeEventTimeField { + return DerivativeEventTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//DerivativeEventTypeField is a INT field +type DerivativeEventTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.DerivativeEventType (1287) +func (f DerivativeEventTypeField) Tag() quickfix.Tag { return tag.DerivativeEventType } + +//NewDerivativeEventType returns a new DerivativeEventTypeField initialized with val +func NewDerivativeEventType(val int) DerivativeEventTypeField { + return DerivativeEventTypeField{quickfix.FIXInt(val)} +} + +//DerivativeExerciseStyleField is a CHAR field +type DerivativeExerciseStyleField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeExerciseStyle (1299) +func (f DerivativeExerciseStyleField) Tag() quickfix.Tag { return tag.DerivativeExerciseStyle } + +//NewDerivativeExerciseStyle returns a new DerivativeExerciseStyleField initialized with val +func NewDerivativeExerciseStyle(val string) DerivativeExerciseStyleField { + return DerivativeExerciseStyleField{quickfix.FIXString(val)} +} + +//DerivativeFloorPriceField is a PRICE field +type DerivativeFloorPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.DerivativeFloorPrice (1322) +func (f DerivativeFloorPriceField) Tag() quickfix.Tag { return tag.DerivativeFloorPrice } + +//NewDerivativeFloorPrice returns a new DerivativeFloorPriceField initialized with val +func NewDerivativeFloorPrice(val float64) DerivativeFloorPriceField { + return DerivativeFloorPriceField{quickfix.FIXFloat(val)} +} + +//DerivativeFlowScheduleTypeField is a INT field +type DerivativeFlowScheduleTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.DerivativeFlowScheduleType (1442) +func (f DerivativeFlowScheduleTypeField) Tag() quickfix.Tag { return tag.DerivativeFlowScheduleType } + +//NewDerivativeFlowScheduleType returns a new DerivativeFlowScheduleTypeField initialized with val +func NewDerivativeFlowScheduleType(val int) DerivativeFlowScheduleTypeField { + return DerivativeFlowScheduleTypeField{quickfix.FIXInt(val)} +} + +//DerivativeFuturesValuationMethodField is a STRING field +type DerivativeFuturesValuationMethodField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeFuturesValuationMethod (1319) +func (f DerivativeFuturesValuationMethodField) Tag() quickfix.Tag { + return tag.DerivativeFuturesValuationMethod +} + +//NewDerivativeFuturesValuationMethod returns a new DerivativeFuturesValuationMethodField initialized with val +func NewDerivativeFuturesValuationMethod(val string) DerivativeFuturesValuationMethodField { + return DerivativeFuturesValuationMethodField{quickfix.FIXString(val)} +} + +//DerivativeInstrAttribTypeField is a INT field +type DerivativeInstrAttribTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.DerivativeInstrAttribType (1313) +func (f DerivativeInstrAttribTypeField) Tag() quickfix.Tag { return tag.DerivativeInstrAttribType } + +//NewDerivativeInstrAttribType returns a new DerivativeInstrAttribTypeField initialized with val +func NewDerivativeInstrAttribType(val int) DerivativeInstrAttribTypeField { + return DerivativeInstrAttribTypeField{quickfix.FIXInt(val)} +} + +//DerivativeInstrAttribValueField is a STRING field +type DerivativeInstrAttribValueField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeInstrAttribValue (1314) +func (f DerivativeInstrAttribValueField) Tag() quickfix.Tag { return tag.DerivativeInstrAttribValue } + +//NewDerivativeInstrAttribValue returns a new DerivativeInstrAttribValueField initialized with val +func NewDerivativeInstrAttribValue(val string) DerivativeInstrAttribValueField { + return DerivativeInstrAttribValueField{quickfix.FIXString(val)} +} + +//DerivativeInstrRegistryField is a STRING field +type DerivativeInstrRegistryField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeInstrRegistry (1257) +func (f DerivativeInstrRegistryField) Tag() quickfix.Tag { return tag.DerivativeInstrRegistry } + +//NewDerivativeInstrRegistry returns a new DerivativeInstrRegistryField initialized with val +func NewDerivativeInstrRegistry(val string) DerivativeInstrRegistryField { + return DerivativeInstrRegistryField{quickfix.FIXString(val)} +} + +//DerivativeInstrmtAssignmentMethodField is a CHAR field +type DerivativeInstrmtAssignmentMethodField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeInstrmtAssignmentMethod (1255) +func (f DerivativeInstrmtAssignmentMethodField) Tag() quickfix.Tag { + return tag.DerivativeInstrmtAssignmentMethod +} + +//NewDerivativeInstrmtAssignmentMethod returns a new DerivativeInstrmtAssignmentMethodField initialized with val +func NewDerivativeInstrmtAssignmentMethod(val string) DerivativeInstrmtAssignmentMethodField { + return DerivativeInstrmtAssignmentMethodField{quickfix.FIXString(val)} +} + +//DerivativeInstrumentPartyIDField is a STRING field +type DerivativeInstrumentPartyIDField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeInstrumentPartyID (1293) +func (f DerivativeInstrumentPartyIDField) Tag() quickfix.Tag { return tag.DerivativeInstrumentPartyID } + +//NewDerivativeInstrumentPartyID returns a new DerivativeInstrumentPartyIDField initialized with val +func NewDerivativeInstrumentPartyID(val string) DerivativeInstrumentPartyIDField { + return DerivativeInstrumentPartyIDField{quickfix.FIXString(val)} +} + +//DerivativeInstrumentPartyIDSourceField is a STRING field +type DerivativeInstrumentPartyIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeInstrumentPartyIDSource (1294) +func (f DerivativeInstrumentPartyIDSourceField) Tag() quickfix.Tag { + return tag.DerivativeInstrumentPartyIDSource +} + +//NewDerivativeInstrumentPartyIDSource returns a new DerivativeInstrumentPartyIDSourceField initialized with val +func NewDerivativeInstrumentPartyIDSource(val string) DerivativeInstrumentPartyIDSourceField { + return DerivativeInstrumentPartyIDSourceField{quickfix.FIXString(val)} +} + +//DerivativeInstrumentPartyRoleField is a INT field +type DerivativeInstrumentPartyRoleField struct{ quickfix.FIXInt } + +//Tag returns tag.DerivativeInstrumentPartyRole (1295) +func (f DerivativeInstrumentPartyRoleField) Tag() quickfix.Tag { + return tag.DerivativeInstrumentPartyRole +} + +//NewDerivativeInstrumentPartyRole returns a new DerivativeInstrumentPartyRoleField initialized with val +func NewDerivativeInstrumentPartyRole(val int) DerivativeInstrumentPartyRoleField { + return DerivativeInstrumentPartyRoleField{quickfix.FIXInt(val)} +} + +//DerivativeInstrumentPartySubIDField is a STRING field +type DerivativeInstrumentPartySubIDField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeInstrumentPartySubID (1297) +func (f DerivativeInstrumentPartySubIDField) Tag() quickfix.Tag { + return tag.DerivativeInstrumentPartySubID +} + +//NewDerivativeInstrumentPartySubID returns a new DerivativeInstrumentPartySubIDField initialized with val +func NewDerivativeInstrumentPartySubID(val string) DerivativeInstrumentPartySubIDField { + return DerivativeInstrumentPartySubIDField{quickfix.FIXString(val)} +} + +//DerivativeInstrumentPartySubIDTypeField is a INT field +type DerivativeInstrumentPartySubIDTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.DerivativeInstrumentPartySubIDType (1298) +func (f DerivativeInstrumentPartySubIDTypeField) Tag() quickfix.Tag { + return tag.DerivativeInstrumentPartySubIDType +} + +//NewDerivativeInstrumentPartySubIDType returns a new DerivativeInstrumentPartySubIDTypeField initialized with val +func NewDerivativeInstrumentPartySubIDType(val int) DerivativeInstrumentPartySubIDTypeField { + return DerivativeInstrumentPartySubIDTypeField{quickfix.FIXInt(val)} +} + +//DerivativeIssueDateField is a LOCALMKTDATE field +type DerivativeIssueDateField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeIssueDate (1276) +func (f DerivativeIssueDateField) Tag() quickfix.Tag { return tag.DerivativeIssueDate } + +//NewDerivativeIssueDate returns a new DerivativeIssueDateField initialized with val +func NewDerivativeIssueDate(val string) DerivativeIssueDateField { + return DerivativeIssueDateField{quickfix.FIXString(val)} +} + +//DerivativeIssuerField is a STRING field +type DerivativeIssuerField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeIssuer (1275) +func (f DerivativeIssuerField) Tag() quickfix.Tag { return tag.DerivativeIssuer } + +//NewDerivativeIssuer returns a new DerivativeIssuerField initialized with val +func NewDerivativeIssuer(val string) DerivativeIssuerField { + return DerivativeIssuerField{quickfix.FIXString(val)} +} + +//DerivativeListMethodField is a INT field +type DerivativeListMethodField struct{ quickfix.FIXInt } + +//Tag returns tag.DerivativeListMethod (1320) +func (f DerivativeListMethodField) Tag() quickfix.Tag { return tag.DerivativeListMethod } + +//NewDerivativeListMethod returns a new DerivativeListMethodField initialized with val +func NewDerivativeListMethod(val int) DerivativeListMethodField { + return DerivativeListMethodField{quickfix.FIXInt(val)} +} + +//DerivativeLocaleOfIssueField is a STRING field +type DerivativeLocaleOfIssueField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeLocaleOfIssue (1260) +func (f DerivativeLocaleOfIssueField) Tag() quickfix.Tag { return tag.DerivativeLocaleOfIssue } + +//NewDerivativeLocaleOfIssue returns a new DerivativeLocaleOfIssueField initialized with val +func NewDerivativeLocaleOfIssue(val string) DerivativeLocaleOfIssueField { + return DerivativeLocaleOfIssueField{quickfix.FIXString(val)} +} + +//DerivativeMaturityDateField is a LOCALMKTDATE field +type DerivativeMaturityDateField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeMaturityDate (1252) +func (f DerivativeMaturityDateField) Tag() quickfix.Tag { return tag.DerivativeMaturityDate } + +//NewDerivativeMaturityDate returns a new DerivativeMaturityDateField initialized with val +func NewDerivativeMaturityDate(val string) DerivativeMaturityDateField { + return DerivativeMaturityDateField{quickfix.FIXString(val)} +} + +//DerivativeMaturityMonthYearField is a MONTHYEAR field +type DerivativeMaturityMonthYearField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeMaturityMonthYear (1251) +func (f DerivativeMaturityMonthYearField) Tag() quickfix.Tag { return tag.DerivativeMaturityMonthYear } + +//NewDerivativeMaturityMonthYear returns a new DerivativeMaturityMonthYearField initialized with val +func NewDerivativeMaturityMonthYear(val string) DerivativeMaturityMonthYearField { + return DerivativeMaturityMonthYearField{quickfix.FIXString(val)} +} + +//DerivativeMaturityTimeField is a TZTIMEONLY field +type DerivativeMaturityTimeField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeMaturityTime (1253) +func (f DerivativeMaturityTimeField) Tag() quickfix.Tag { return tag.DerivativeMaturityTime } + +//NewDerivativeMaturityTime returns a new DerivativeMaturityTimeField initialized with val +func NewDerivativeMaturityTime(val string) DerivativeMaturityTimeField { + return DerivativeMaturityTimeField{quickfix.FIXString(val)} +} + +//DerivativeMinPriceIncrementField is a FLOAT field +type DerivativeMinPriceIncrementField struct{ quickfix.FIXFloat } + +//Tag returns tag.DerivativeMinPriceIncrement (1267) +func (f DerivativeMinPriceIncrementField) Tag() quickfix.Tag { return tag.DerivativeMinPriceIncrement } + +//NewDerivativeMinPriceIncrement returns a new DerivativeMinPriceIncrementField initialized with val +func NewDerivativeMinPriceIncrement(val float64) DerivativeMinPriceIncrementField { + return DerivativeMinPriceIncrementField{quickfix.FIXFloat(val)} +} + +//DerivativeMinPriceIncrementAmountField is a AMT field +type DerivativeMinPriceIncrementAmountField struct{ quickfix.FIXFloat } + +//Tag returns tag.DerivativeMinPriceIncrementAmount (1268) +func (f DerivativeMinPriceIncrementAmountField) Tag() quickfix.Tag { + return tag.DerivativeMinPriceIncrementAmount +} + +//NewDerivativeMinPriceIncrementAmount returns a new DerivativeMinPriceIncrementAmountField initialized with val +func NewDerivativeMinPriceIncrementAmount(val float64) DerivativeMinPriceIncrementAmountField { + return DerivativeMinPriceIncrementAmountField{quickfix.FIXFloat(val)} +} + +//DerivativeNTPositionLimitField is a INT field +type DerivativeNTPositionLimitField struct{ quickfix.FIXInt } + +//Tag returns tag.DerivativeNTPositionLimit (1274) +func (f DerivativeNTPositionLimitField) Tag() quickfix.Tag { return tag.DerivativeNTPositionLimit } + +//NewDerivativeNTPositionLimit returns a new DerivativeNTPositionLimitField initialized with val +func NewDerivativeNTPositionLimit(val int) DerivativeNTPositionLimitField { + return DerivativeNTPositionLimitField{quickfix.FIXInt(val)} +} + +//DerivativeOptAttributeField is a CHAR field +type DerivativeOptAttributeField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeOptAttribute (1265) +func (f DerivativeOptAttributeField) Tag() quickfix.Tag { return tag.DerivativeOptAttribute } + +//NewDerivativeOptAttribute returns a new DerivativeOptAttributeField initialized with val +func NewDerivativeOptAttribute(val string) DerivativeOptAttributeField { + return DerivativeOptAttributeField{quickfix.FIXString(val)} +} + +//DerivativeOptPayAmountField is a AMT field +type DerivativeOptPayAmountField struct{ quickfix.FIXFloat } + +//Tag returns tag.DerivativeOptPayAmount (1225) +func (f DerivativeOptPayAmountField) Tag() quickfix.Tag { return tag.DerivativeOptPayAmount } + +//NewDerivativeOptPayAmount returns a new DerivativeOptPayAmountField initialized with val +func NewDerivativeOptPayAmount(val float64) DerivativeOptPayAmountField { + return DerivativeOptPayAmountField{quickfix.FIXFloat(val)} +} + +//DerivativePositionLimitField is a INT field +type DerivativePositionLimitField struct{ quickfix.FIXInt } + +//Tag returns tag.DerivativePositionLimit (1273) +func (f DerivativePositionLimitField) Tag() quickfix.Tag { return tag.DerivativePositionLimit } + +//NewDerivativePositionLimit returns a new DerivativePositionLimitField initialized with val +func NewDerivativePositionLimit(val int) DerivativePositionLimitField { + return DerivativePositionLimitField{quickfix.FIXInt(val)} +} + +//DerivativePriceQuoteMethodField is a STRING field +type DerivativePriceQuoteMethodField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativePriceQuoteMethod (1318) +func (f DerivativePriceQuoteMethodField) Tag() quickfix.Tag { return tag.DerivativePriceQuoteMethod } + +//NewDerivativePriceQuoteMethod returns a new DerivativePriceQuoteMethodField initialized with val +func NewDerivativePriceQuoteMethod(val string) DerivativePriceQuoteMethodField { + return DerivativePriceQuoteMethodField{quickfix.FIXString(val)} +} + +//DerivativePriceUnitOfMeasureField is a STRING field +type DerivativePriceUnitOfMeasureField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativePriceUnitOfMeasure (1315) +func (f DerivativePriceUnitOfMeasureField) Tag() quickfix.Tag { return tag.DerivativePriceUnitOfMeasure } + +//NewDerivativePriceUnitOfMeasure returns a new DerivativePriceUnitOfMeasureField initialized with val +func NewDerivativePriceUnitOfMeasure(val string) DerivativePriceUnitOfMeasureField { + return DerivativePriceUnitOfMeasureField{quickfix.FIXString(val)} +} + +//DerivativePriceUnitOfMeasureQtyField is a QTY field +type DerivativePriceUnitOfMeasureQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.DerivativePriceUnitOfMeasureQty (1316) +func (f DerivativePriceUnitOfMeasureQtyField) Tag() quickfix.Tag { + return tag.DerivativePriceUnitOfMeasureQty +} + +//NewDerivativePriceUnitOfMeasureQty returns a new DerivativePriceUnitOfMeasureQtyField initialized with val +func NewDerivativePriceUnitOfMeasureQty(val float64) DerivativePriceUnitOfMeasureQtyField { + return DerivativePriceUnitOfMeasureQtyField{quickfix.FIXFloat(val)} +} + +//DerivativeProductField is a INT field +type DerivativeProductField struct{ quickfix.FIXInt } + +//Tag returns tag.DerivativeProduct (1246) +func (f DerivativeProductField) Tag() quickfix.Tag { return tag.DerivativeProduct } + +//NewDerivativeProduct returns a new DerivativeProductField initialized with val +func NewDerivativeProduct(val int) DerivativeProductField { + return DerivativeProductField{quickfix.FIXInt(val)} +} + +//DerivativeProductComplexField is a STRING field +type DerivativeProductComplexField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeProductComplex (1228) +func (f DerivativeProductComplexField) Tag() quickfix.Tag { return tag.DerivativeProductComplex } + +//NewDerivativeProductComplex returns a new DerivativeProductComplexField initialized with val +func NewDerivativeProductComplex(val string) DerivativeProductComplexField { + return DerivativeProductComplexField{quickfix.FIXString(val)} +} + +//DerivativePutOrCallField is a INT field +type DerivativePutOrCallField struct{ quickfix.FIXInt } + +//Tag returns tag.DerivativePutOrCall (1323) +func (f DerivativePutOrCallField) Tag() quickfix.Tag { return tag.DerivativePutOrCall } + +//NewDerivativePutOrCall returns a new DerivativePutOrCallField initialized with val +func NewDerivativePutOrCall(val int) DerivativePutOrCallField { + return DerivativePutOrCallField{quickfix.FIXInt(val)} +} + +//DerivativeSecurityAltIDField is a STRING field +type DerivativeSecurityAltIDField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeSecurityAltID (1219) +func (f DerivativeSecurityAltIDField) Tag() quickfix.Tag { return tag.DerivativeSecurityAltID } + +//NewDerivativeSecurityAltID returns a new DerivativeSecurityAltIDField initialized with val +func NewDerivativeSecurityAltID(val string) DerivativeSecurityAltIDField { + return DerivativeSecurityAltIDField{quickfix.FIXString(val)} +} + +//DerivativeSecurityAltIDSourceField is a STRING field +type DerivativeSecurityAltIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeSecurityAltIDSource (1220) +func (f DerivativeSecurityAltIDSourceField) Tag() quickfix.Tag { + return tag.DerivativeSecurityAltIDSource +} + +//NewDerivativeSecurityAltIDSource returns a new DerivativeSecurityAltIDSourceField initialized with val +func NewDerivativeSecurityAltIDSource(val string) DerivativeSecurityAltIDSourceField { + return DerivativeSecurityAltIDSourceField{quickfix.FIXString(val)} +} + +//DerivativeSecurityDescField is a STRING field +type DerivativeSecurityDescField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeSecurityDesc (1279) +func (f DerivativeSecurityDescField) Tag() quickfix.Tag { return tag.DerivativeSecurityDesc } + +//NewDerivativeSecurityDesc returns a new DerivativeSecurityDescField initialized with val +func NewDerivativeSecurityDesc(val string) DerivativeSecurityDescField { + return DerivativeSecurityDescField{quickfix.FIXString(val)} +} + +//DerivativeSecurityExchangeField is a EXCHANGE field +type DerivativeSecurityExchangeField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeSecurityExchange (1272) +func (f DerivativeSecurityExchangeField) Tag() quickfix.Tag { return tag.DerivativeSecurityExchange } + +//NewDerivativeSecurityExchange returns a new DerivativeSecurityExchangeField initialized with val +func NewDerivativeSecurityExchange(val string) DerivativeSecurityExchangeField { + return DerivativeSecurityExchangeField{quickfix.FIXString(val)} +} + +//DerivativeSecurityGroupField is a STRING field +type DerivativeSecurityGroupField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeSecurityGroup (1247) +func (f DerivativeSecurityGroupField) Tag() quickfix.Tag { return tag.DerivativeSecurityGroup } + +//NewDerivativeSecurityGroup returns a new DerivativeSecurityGroupField initialized with val +func NewDerivativeSecurityGroup(val string) DerivativeSecurityGroupField { + return DerivativeSecurityGroupField{quickfix.FIXString(val)} +} + +//DerivativeSecurityIDField is a STRING field +type DerivativeSecurityIDField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeSecurityID (1216) +func (f DerivativeSecurityIDField) Tag() quickfix.Tag { return tag.DerivativeSecurityID } + +//NewDerivativeSecurityID returns a new DerivativeSecurityIDField initialized with val +func NewDerivativeSecurityID(val string) DerivativeSecurityIDField { + return DerivativeSecurityIDField{quickfix.FIXString(val)} +} + +//DerivativeSecurityIDSourceField is a STRING field +type DerivativeSecurityIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeSecurityIDSource (1217) +func (f DerivativeSecurityIDSourceField) Tag() quickfix.Tag { return tag.DerivativeSecurityIDSource } + +//NewDerivativeSecurityIDSource returns a new DerivativeSecurityIDSourceField initialized with val +func NewDerivativeSecurityIDSource(val string) DerivativeSecurityIDSourceField { + return DerivativeSecurityIDSourceField{quickfix.FIXString(val)} +} + +//DerivativeSecurityListRequestTypeField is a INT field +type DerivativeSecurityListRequestTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.DerivativeSecurityListRequestType (1307) +func (f DerivativeSecurityListRequestTypeField) Tag() quickfix.Tag { + return tag.DerivativeSecurityListRequestType +} + +//NewDerivativeSecurityListRequestType returns a new DerivativeSecurityListRequestTypeField initialized with val +func NewDerivativeSecurityListRequestType(val int) DerivativeSecurityListRequestTypeField { + return DerivativeSecurityListRequestTypeField{quickfix.FIXInt(val)} +} + +//DerivativeSecurityStatusField is a STRING field +type DerivativeSecurityStatusField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeSecurityStatus (1256) +func (f DerivativeSecurityStatusField) Tag() quickfix.Tag { return tag.DerivativeSecurityStatus } + +//NewDerivativeSecurityStatus returns a new DerivativeSecurityStatusField initialized with val +func NewDerivativeSecurityStatus(val string) DerivativeSecurityStatusField { + return DerivativeSecurityStatusField{quickfix.FIXString(val)} +} + +//DerivativeSecuritySubTypeField is a STRING field +type DerivativeSecuritySubTypeField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeSecuritySubType (1250) +func (f DerivativeSecuritySubTypeField) Tag() quickfix.Tag { return tag.DerivativeSecuritySubType } + +//NewDerivativeSecuritySubType returns a new DerivativeSecuritySubTypeField initialized with val +func NewDerivativeSecuritySubType(val string) DerivativeSecuritySubTypeField { + return DerivativeSecuritySubTypeField{quickfix.FIXString(val)} +} + +//DerivativeSecurityTypeField is a STRING field +type DerivativeSecurityTypeField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeSecurityType (1249) +func (f DerivativeSecurityTypeField) Tag() quickfix.Tag { return tag.DerivativeSecurityType } + +//NewDerivativeSecurityType returns a new DerivativeSecurityTypeField initialized with val +func NewDerivativeSecurityType(val string) DerivativeSecurityTypeField { + return DerivativeSecurityTypeField{quickfix.FIXString(val)} +} + +//DerivativeSecurityXMLField is a DATA field +type DerivativeSecurityXMLField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeSecurityXML (1283) +func (f DerivativeSecurityXMLField) Tag() quickfix.Tag { return tag.DerivativeSecurityXML } + +//NewDerivativeSecurityXML returns a new DerivativeSecurityXMLField initialized with val +func NewDerivativeSecurityXML(val string) DerivativeSecurityXMLField { + return DerivativeSecurityXMLField{quickfix.FIXString(val)} +} + +//DerivativeSecurityXMLLenField is a LENGTH field +type DerivativeSecurityXMLLenField struct{ quickfix.FIXInt } + +//Tag returns tag.DerivativeSecurityXMLLen (1282) +func (f DerivativeSecurityXMLLenField) Tag() quickfix.Tag { return tag.DerivativeSecurityXMLLen } + +//NewDerivativeSecurityXMLLen returns a new DerivativeSecurityXMLLenField initialized with val +func NewDerivativeSecurityXMLLen(val int) DerivativeSecurityXMLLenField { + return DerivativeSecurityXMLLenField{quickfix.FIXInt(val)} +} + +//DerivativeSecurityXMLSchemaField is a STRING field +type DerivativeSecurityXMLSchemaField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeSecurityXMLSchema (1284) +func (f DerivativeSecurityXMLSchemaField) Tag() quickfix.Tag { return tag.DerivativeSecurityXMLSchema } + +//NewDerivativeSecurityXMLSchema returns a new DerivativeSecurityXMLSchemaField initialized with val +func NewDerivativeSecurityXMLSchema(val string) DerivativeSecurityXMLSchemaField { + return DerivativeSecurityXMLSchemaField{quickfix.FIXString(val)} +} + +//DerivativeSettlMethodField is a CHAR field +type DerivativeSettlMethodField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeSettlMethod (1317) +func (f DerivativeSettlMethodField) Tag() quickfix.Tag { return tag.DerivativeSettlMethod } + +//NewDerivativeSettlMethod returns a new DerivativeSettlMethodField initialized with val +func NewDerivativeSettlMethod(val string) DerivativeSettlMethodField { + return DerivativeSettlMethodField{quickfix.FIXString(val)} +} + +//DerivativeSettleOnOpenFlagField is a STRING field +type DerivativeSettleOnOpenFlagField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeSettleOnOpenFlag (1254) +func (f DerivativeSettleOnOpenFlagField) Tag() quickfix.Tag { return tag.DerivativeSettleOnOpenFlag } + +//NewDerivativeSettleOnOpenFlag returns a new DerivativeSettleOnOpenFlagField initialized with val +func NewDerivativeSettleOnOpenFlag(val string) DerivativeSettleOnOpenFlagField { + return DerivativeSettleOnOpenFlagField{quickfix.FIXString(val)} +} + +//DerivativeStateOrProvinceOfIssueField is a STRING field +type DerivativeStateOrProvinceOfIssueField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeStateOrProvinceOfIssue (1259) +func (f DerivativeStateOrProvinceOfIssueField) Tag() quickfix.Tag { + return tag.DerivativeStateOrProvinceOfIssue +} + +//NewDerivativeStateOrProvinceOfIssue returns a new DerivativeStateOrProvinceOfIssueField initialized with val +func NewDerivativeStateOrProvinceOfIssue(val string) DerivativeStateOrProvinceOfIssueField { + return DerivativeStateOrProvinceOfIssueField{quickfix.FIXString(val)} +} + +//DerivativeStrikeCurrencyField is a CURRENCY field +type DerivativeStrikeCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeStrikeCurrency (1262) +func (f DerivativeStrikeCurrencyField) Tag() quickfix.Tag { return tag.DerivativeStrikeCurrency } + +//NewDerivativeStrikeCurrency returns a new DerivativeStrikeCurrencyField initialized with val +func NewDerivativeStrikeCurrency(val string) DerivativeStrikeCurrencyField { + return DerivativeStrikeCurrencyField{quickfix.FIXString(val)} +} + +//DerivativeStrikeMultiplierField is a FLOAT field +type DerivativeStrikeMultiplierField struct{ quickfix.FIXFloat } + +//Tag returns tag.DerivativeStrikeMultiplier (1263) +func (f DerivativeStrikeMultiplierField) Tag() quickfix.Tag { return tag.DerivativeStrikeMultiplier } + +//NewDerivativeStrikeMultiplier returns a new DerivativeStrikeMultiplierField initialized with val +func NewDerivativeStrikeMultiplier(val float64) DerivativeStrikeMultiplierField { + return DerivativeStrikeMultiplierField{quickfix.FIXFloat(val)} +} + +//DerivativeStrikePriceField is a PRICE field +type DerivativeStrikePriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.DerivativeStrikePrice (1261) +func (f DerivativeStrikePriceField) Tag() quickfix.Tag { return tag.DerivativeStrikePrice } + +//NewDerivativeStrikePrice returns a new DerivativeStrikePriceField initialized with val +func NewDerivativeStrikePrice(val float64) DerivativeStrikePriceField { + return DerivativeStrikePriceField{quickfix.FIXFloat(val)} +} + +//DerivativeStrikeValueField is a FLOAT field +type DerivativeStrikeValueField struct{ quickfix.FIXFloat } + +//Tag returns tag.DerivativeStrikeValue (1264) +func (f DerivativeStrikeValueField) Tag() quickfix.Tag { return tag.DerivativeStrikeValue } + +//NewDerivativeStrikeValue returns a new DerivativeStrikeValueField initialized with val +func NewDerivativeStrikeValue(val float64) DerivativeStrikeValueField { + return DerivativeStrikeValueField{quickfix.FIXFloat(val)} +} + +//DerivativeSymbolField is a STRING field +type DerivativeSymbolField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeSymbol (1214) +func (f DerivativeSymbolField) Tag() quickfix.Tag { return tag.DerivativeSymbol } + +//NewDerivativeSymbol returns a new DerivativeSymbolField initialized with val +func NewDerivativeSymbol(val string) DerivativeSymbolField { + return DerivativeSymbolField{quickfix.FIXString(val)} +} + +//DerivativeSymbolSfxField is a STRING field +type DerivativeSymbolSfxField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeSymbolSfx (1215) +func (f DerivativeSymbolSfxField) Tag() quickfix.Tag { return tag.DerivativeSymbolSfx } + +//NewDerivativeSymbolSfx returns a new DerivativeSymbolSfxField initialized with val +func NewDerivativeSymbolSfx(val string) DerivativeSymbolSfxField { + return DerivativeSymbolSfxField{quickfix.FIXString(val)} +} + +//DerivativeTimeUnitField is a STRING field +type DerivativeTimeUnitField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeTimeUnit (1271) +func (f DerivativeTimeUnitField) Tag() quickfix.Tag { return tag.DerivativeTimeUnit } + +//NewDerivativeTimeUnit returns a new DerivativeTimeUnitField initialized with val +func NewDerivativeTimeUnit(val string) DerivativeTimeUnitField { + return DerivativeTimeUnitField{quickfix.FIXString(val)} +} + +//DerivativeUnitOfMeasureField is a STRING field +type DerivativeUnitOfMeasureField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeUnitOfMeasure (1269) +func (f DerivativeUnitOfMeasureField) Tag() quickfix.Tag { return tag.DerivativeUnitOfMeasure } + +//NewDerivativeUnitOfMeasure returns a new DerivativeUnitOfMeasureField initialized with val +func NewDerivativeUnitOfMeasure(val string) DerivativeUnitOfMeasureField { + return DerivativeUnitOfMeasureField{quickfix.FIXString(val)} +} + +//DerivativeUnitOfMeasureQtyField is a QTY field +type DerivativeUnitOfMeasureQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.DerivativeUnitOfMeasureQty (1270) +func (f DerivativeUnitOfMeasureQtyField) Tag() quickfix.Tag { return tag.DerivativeUnitOfMeasureQty } + +//NewDerivativeUnitOfMeasureQty returns a new DerivativeUnitOfMeasureQtyField initialized with val +func NewDerivativeUnitOfMeasureQty(val float64) DerivativeUnitOfMeasureQtyField { + return DerivativeUnitOfMeasureQtyField{quickfix.FIXFloat(val)} +} + +//DerivativeValuationMethodField is a STRING field +type DerivativeValuationMethodField struct{ quickfix.FIXString } + +//Tag returns tag.DerivativeValuationMethod (1319) +func (f DerivativeValuationMethodField) Tag() quickfix.Tag { return tag.DerivativeValuationMethod } + +//NewDerivativeValuationMethod returns a new DerivativeValuationMethodField initialized with val +func NewDerivativeValuationMethod(val string) DerivativeValuationMethodField { + return DerivativeValuationMethodField{quickfix.FIXString(val)} +} + +//DesignationField is a STRING field +type DesignationField struct{ quickfix.FIXString } + +//Tag returns tag.Designation (494) +func (f DesignationField) Tag() quickfix.Tag { return tag.Designation } + +//NewDesignation returns a new DesignationField initialized with val +func NewDesignation(val string) DesignationField { + return DesignationField{quickfix.FIXString(val)} +} + +//DeskIDField is a STRING field +type DeskIDField struct{ quickfix.FIXString } + +//Tag returns tag.DeskID (284) +func (f DeskIDField) Tag() quickfix.Tag { return tag.DeskID } + +//NewDeskID returns a new DeskIDField initialized with val +func NewDeskID(val string) DeskIDField { + return DeskIDField{quickfix.FIXString(val)} +} + +//DeskOrderHandlingInstField is a MULTIPLESTRINGVALUE field +type DeskOrderHandlingInstField struct{ quickfix.FIXString } + +//Tag returns tag.DeskOrderHandlingInst (1035) +func (f DeskOrderHandlingInstField) Tag() quickfix.Tag { return tag.DeskOrderHandlingInst } + +//NewDeskOrderHandlingInst returns a new DeskOrderHandlingInstField initialized with val +func NewDeskOrderHandlingInst(val string) DeskOrderHandlingInstField { + return DeskOrderHandlingInstField{quickfix.FIXString(val)} +} + +//DeskTypeField is a STRING field +type DeskTypeField struct{ quickfix.FIXString } + +//Tag returns tag.DeskType (1033) +func (f DeskTypeField) Tag() quickfix.Tag { return tag.DeskType } + +//NewDeskType returns a new DeskTypeField initialized with val +func NewDeskType(val string) DeskTypeField { + return DeskTypeField{quickfix.FIXString(val)} +} + +//DeskTypeSourceField is a INT field +type DeskTypeSourceField struct{ quickfix.FIXInt } + +//Tag returns tag.DeskTypeSource (1034) +func (f DeskTypeSourceField) Tag() quickfix.Tag { return tag.DeskTypeSource } + +//NewDeskTypeSource returns a new DeskTypeSourceField initialized with val +func NewDeskTypeSource(val int) DeskTypeSourceField { + return DeskTypeSourceField{quickfix.FIXInt(val)} +} + +//DetachmentPointField is a PERCENTAGE field +type DetachmentPointField struct{ quickfix.FIXFloat } + +//Tag returns tag.DetachmentPoint (1458) +func (f DetachmentPointField) Tag() quickfix.Tag { return tag.DetachmentPoint } + +//NewDetachmentPoint returns a new DetachmentPointField initialized with val +func NewDetachmentPoint(val float64) DetachmentPointField { + return DetachmentPointField{quickfix.FIXFloat(val)} +} + +//DiscretionInstField is a CHAR field +type DiscretionInstField struct{ quickfix.FIXString } + +//Tag returns tag.DiscretionInst (388) +func (f DiscretionInstField) Tag() quickfix.Tag { return tag.DiscretionInst } + +//NewDiscretionInst returns a new DiscretionInstField initialized with val +func NewDiscretionInst(val string) DiscretionInstField { + return DiscretionInstField{quickfix.FIXString(val)} +} + +//DiscretionLimitTypeField is a INT field +type DiscretionLimitTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.DiscretionLimitType (843) +func (f DiscretionLimitTypeField) Tag() quickfix.Tag { return tag.DiscretionLimitType } + +//NewDiscretionLimitType returns a new DiscretionLimitTypeField initialized with val +func NewDiscretionLimitType(val int) DiscretionLimitTypeField { + return DiscretionLimitTypeField{quickfix.FIXInt(val)} +} + +//DiscretionMoveTypeField is a INT field +type DiscretionMoveTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.DiscretionMoveType (841) +func (f DiscretionMoveTypeField) Tag() quickfix.Tag { return tag.DiscretionMoveType } + +//NewDiscretionMoveType returns a new DiscretionMoveTypeField initialized with val +func NewDiscretionMoveType(val int) DiscretionMoveTypeField { + return DiscretionMoveTypeField{quickfix.FIXInt(val)} +} + +//DiscretionOffsetField is a PRICEOFFSET field +type DiscretionOffsetField struct{ quickfix.FIXFloat } + +//Tag returns tag.DiscretionOffset (389) +func (f DiscretionOffsetField) Tag() quickfix.Tag { return tag.DiscretionOffset } + +//NewDiscretionOffset returns a new DiscretionOffsetField initialized with val +func NewDiscretionOffset(val float64) DiscretionOffsetField { + return DiscretionOffsetField{quickfix.FIXFloat(val)} +} + +//DiscretionOffsetTypeField is a INT field +type DiscretionOffsetTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.DiscretionOffsetType (842) +func (f DiscretionOffsetTypeField) Tag() quickfix.Tag { return tag.DiscretionOffsetType } + +//NewDiscretionOffsetType returns a new DiscretionOffsetTypeField initialized with val +func NewDiscretionOffsetType(val int) DiscretionOffsetTypeField { + return DiscretionOffsetTypeField{quickfix.FIXInt(val)} +} + +//DiscretionOffsetValueField is a FLOAT field +type DiscretionOffsetValueField struct{ quickfix.FIXFloat } + +//Tag returns tag.DiscretionOffsetValue (389) +func (f DiscretionOffsetValueField) Tag() quickfix.Tag { return tag.DiscretionOffsetValue } + +//NewDiscretionOffsetValue returns a new DiscretionOffsetValueField initialized with val +func NewDiscretionOffsetValue(val float64) DiscretionOffsetValueField { + return DiscretionOffsetValueField{quickfix.FIXFloat(val)} +} + +//DiscretionPriceField is a PRICE field +type DiscretionPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.DiscretionPrice (845) +func (f DiscretionPriceField) Tag() quickfix.Tag { return tag.DiscretionPrice } + +//NewDiscretionPrice returns a new DiscretionPriceField initialized with val +func NewDiscretionPrice(val float64) DiscretionPriceField { + return DiscretionPriceField{quickfix.FIXFloat(val)} +} + +//DiscretionRoundDirectionField is a INT field +type DiscretionRoundDirectionField struct{ quickfix.FIXInt } + +//Tag returns tag.DiscretionRoundDirection (844) +func (f DiscretionRoundDirectionField) Tag() quickfix.Tag { return tag.DiscretionRoundDirection } + +//NewDiscretionRoundDirection returns a new DiscretionRoundDirectionField initialized with val +func NewDiscretionRoundDirection(val int) DiscretionRoundDirectionField { + return DiscretionRoundDirectionField{quickfix.FIXInt(val)} +} + +//DiscretionScopeField is a INT field +type DiscretionScopeField struct{ quickfix.FIXInt } + +//Tag returns tag.DiscretionScope (846) +func (f DiscretionScopeField) Tag() quickfix.Tag { return tag.DiscretionScope } + +//NewDiscretionScope returns a new DiscretionScopeField initialized with val +func NewDiscretionScope(val int) DiscretionScopeField { + return DiscretionScopeField{quickfix.FIXInt(val)} +} + +//DisplayHighQtyField is a QTY field +type DisplayHighQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.DisplayHighQty (1086) +func (f DisplayHighQtyField) Tag() quickfix.Tag { return tag.DisplayHighQty } + +//NewDisplayHighQty returns a new DisplayHighQtyField initialized with val +func NewDisplayHighQty(val float64) DisplayHighQtyField { + return DisplayHighQtyField{quickfix.FIXFloat(val)} +} + +//DisplayLowQtyField is a QTY field +type DisplayLowQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.DisplayLowQty (1085) +func (f DisplayLowQtyField) Tag() quickfix.Tag { return tag.DisplayLowQty } + +//NewDisplayLowQty returns a new DisplayLowQtyField initialized with val +func NewDisplayLowQty(val float64) DisplayLowQtyField { + return DisplayLowQtyField{quickfix.FIXFloat(val)} +} + +//DisplayMethodField is a CHAR field +type DisplayMethodField struct{ quickfix.FIXString } + +//Tag returns tag.DisplayMethod (1084) +func (f DisplayMethodField) Tag() quickfix.Tag { return tag.DisplayMethod } + +//NewDisplayMethod returns a new DisplayMethodField initialized with val +func NewDisplayMethod(val string) DisplayMethodField { + return DisplayMethodField{quickfix.FIXString(val)} +} + +//DisplayMinIncrField is a QTY field +type DisplayMinIncrField struct{ quickfix.FIXFloat } + +//Tag returns tag.DisplayMinIncr (1087) +func (f DisplayMinIncrField) Tag() quickfix.Tag { return tag.DisplayMinIncr } + +//NewDisplayMinIncr returns a new DisplayMinIncrField initialized with val +func NewDisplayMinIncr(val float64) DisplayMinIncrField { + return DisplayMinIncrField{quickfix.FIXFloat(val)} +} + +//DisplayQtyField is a QTY field +type DisplayQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.DisplayQty (1138) +func (f DisplayQtyField) Tag() quickfix.Tag { return tag.DisplayQty } + +//NewDisplayQty returns a new DisplayQtyField initialized with val +func NewDisplayQty(val float64) DisplayQtyField { + return DisplayQtyField{quickfix.FIXFloat(val)} +} + +//DisplayWhenField is a CHAR field +type DisplayWhenField struct{ quickfix.FIXString } + +//Tag returns tag.DisplayWhen (1083) +func (f DisplayWhenField) Tag() quickfix.Tag { return tag.DisplayWhen } + +//NewDisplayWhen returns a new DisplayWhenField initialized with val +func NewDisplayWhen(val string) DisplayWhenField { + return DisplayWhenField{quickfix.FIXString(val)} +} + +//DistribPaymentMethodField is a INT field +type DistribPaymentMethodField struct{ quickfix.FIXInt } + +//Tag returns tag.DistribPaymentMethod (477) +func (f DistribPaymentMethodField) Tag() quickfix.Tag { return tag.DistribPaymentMethod } + +//NewDistribPaymentMethod returns a new DistribPaymentMethodField initialized with val +func NewDistribPaymentMethod(val int) DistribPaymentMethodField { + return DistribPaymentMethodField{quickfix.FIXInt(val)} +} + +//DistribPercentageField is a PERCENTAGE field +type DistribPercentageField struct{ quickfix.FIXFloat } + +//Tag returns tag.DistribPercentage (512) +func (f DistribPercentageField) Tag() quickfix.Tag { return tag.DistribPercentage } + +//NewDistribPercentage returns a new DistribPercentageField initialized with val +func NewDistribPercentage(val float64) DistribPercentageField { + return DistribPercentageField{quickfix.FIXFloat(val)} +} + +//DividendYieldField is a PERCENTAGE field +type DividendYieldField struct{ quickfix.FIXFloat } + +//Tag returns tag.DividendYield (1380) +func (f DividendYieldField) Tag() quickfix.Tag { return tag.DividendYield } + +//NewDividendYield returns a new DividendYieldField initialized with val +func NewDividendYield(val float64) DividendYieldField { + return DividendYieldField{quickfix.FIXFloat(val)} +} + +//DlvyInstField is a STRING field +type DlvyInstField struct{ quickfix.FIXString } + +//Tag returns tag.DlvyInst (86) +func (f DlvyInstField) Tag() quickfix.Tag { return tag.DlvyInst } + +//NewDlvyInst returns a new DlvyInstField initialized with val +func NewDlvyInst(val string) DlvyInstField { + return DlvyInstField{quickfix.FIXString(val)} +} + +//DlvyInstTypeField is a CHAR field +type DlvyInstTypeField struct{ quickfix.FIXString } + +//Tag returns tag.DlvyInstType (787) +func (f DlvyInstTypeField) Tag() quickfix.Tag { return tag.DlvyInstType } + +//NewDlvyInstType returns a new DlvyInstTypeField initialized with val +func NewDlvyInstType(val string) DlvyInstTypeField { + return DlvyInstTypeField{quickfix.FIXString(val)} +} + +//DueToRelatedField is a BOOLEAN field +type DueToRelatedField struct{ quickfix.FIXBoolean } + +//Tag returns tag.DueToRelated (329) +func (f DueToRelatedField) Tag() quickfix.Tag { return tag.DueToRelated } + +//NewDueToRelated returns a new DueToRelatedField initialized with val +func NewDueToRelated(val bool) DueToRelatedField { + return DueToRelatedField{quickfix.FIXBoolean(val)} +} + +//EFPTrackingErrorField is a PERCENTAGE field +type EFPTrackingErrorField struct{ quickfix.FIXFloat } + +//Tag returns tag.EFPTrackingError (405) +func (f EFPTrackingErrorField) Tag() quickfix.Tag { return tag.EFPTrackingError } + +//NewEFPTrackingError returns a new EFPTrackingErrorField initialized with val +func NewEFPTrackingError(val float64) EFPTrackingErrorField { + return EFPTrackingErrorField{quickfix.FIXFloat(val)} +} + +//EffectiveTimeField is a UTCTIMESTAMP field +type EffectiveTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.EffectiveTime (168) +func (f EffectiveTimeField) Tag() quickfix.Tag { return tag.EffectiveTime } + +//NewEffectiveTime returns a new EffectiveTimeField initialized with val +func NewEffectiveTime(val time.Time) EffectiveTimeField { + return EffectiveTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewEffectiveTimeNoMillis returns a new EffectiveTimeField initialized with val without millisecs +func NewEffectiveTimeNoMillis(val time.Time) EffectiveTimeField { + return EffectiveTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//EmailThreadIDField is a STRING field +type EmailThreadIDField struct{ quickfix.FIXString } + +//Tag returns tag.EmailThreadID (164) +func (f EmailThreadIDField) Tag() quickfix.Tag { return tag.EmailThreadID } + +//NewEmailThreadID returns a new EmailThreadIDField initialized with val +func NewEmailThreadID(val string) EmailThreadIDField { + return EmailThreadIDField{quickfix.FIXString(val)} +} + +//EmailTypeField is a CHAR field +type EmailTypeField struct{ quickfix.FIXString } + +//Tag returns tag.EmailType (94) +func (f EmailTypeField) Tag() quickfix.Tag { return tag.EmailType } + +//NewEmailType returns a new EmailTypeField initialized with val +func NewEmailType(val string) EmailTypeField { + return EmailTypeField{quickfix.FIXString(val)} +} + +//EncodedAllocTextField is a DATA field +type EncodedAllocTextField struct{ quickfix.FIXString } + +//Tag returns tag.EncodedAllocText (361) +func (f EncodedAllocTextField) Tag() quickfix.Tag { return tag.EncodedAllocText } + +//NewEncodedAllocText returns a new EncodedAllocTextField initialized with val +func NewEncodedAllocText(val string) EncodedAllocTextField { + return EncodedAllocTextField{quickfix.FIXString(val)} +} + +//EncodedAllocTextLenField is a LENGTH field +type EncodedAllocTextLenField struct{ quickfix.FIXInt } + +//Tag returns tag.EncodedAllocTextLen (360) +func (f EncodedAllocTextLenField) Tag() quickfix.Tag { return tag.EncodedAllocTextLen } + +//NewEncodedAllocTextLen returns a new EncodedAllocTextLenField initialized with val +func NewEncodedAllocTextLen(val int) EncodedAllocTextLenField { + return EncodedAllocTextLenField{quickfix.FIXInt(val)} +} + +//EncodedHeadlineField is a DATA field +type EncodedHeadlineField struct{ quickfix.FIXString } + +//Tag returns tag.EncodedHeadline (359) +func (f EncodedHeadlineField) Tag() quickfix.Tag { return tag.EncodedHeadline } + +//NewEncodedHeadline returns a new EncodedHeadlineField initialized with val +func NewEncodedHeadline(val string) EncodedHeadlineField { + return EncodedHeadlineField{quickfix.FIXString(val)} +} + +//EncodedHeadlineLenField is a LENGTH field +type EncodedHeadlineLenField struct{ quickfix.FIXInt } + +//Tag returns tag.EncodedHeadlineLen (358) +func (f EncodedHeadlineLenField) Tag() quickfix.Tag { return tag.EncodedHeadlineLen } + +//NewEncodedHeadlineLen returns a new EncodedHeadlineLenField initialized with val +func NewEncodedHeadlineLen(val int) EncodedHeadlineLenField { + return EncodedHeadlineLenField{quickfix.FIXInt(val)} +} + +//EncodedIssuerField is a DATA field +type EncodedIssuerField struct{ quickfix.FIXString } + +//Tag returns tag.EncodedIssuer (349) +func (f EncodedIssuerField) Tag() quickfix.Tag { return tag.EncodedIssuer } + +//NewEncodedIssuer returns a new EncodedIssuerField initialized with val +func NewEncodedIssuer(val string) EncodedIssuerField { + return EncodedIssuerField{quickfix.FIXString(val)} +} + +//EncodedIssuerLenField is a LENGTH field +type EncodedIssuerLenField struct{ quickfix.FIXInt } + +//Tag returns tag.EncodedIssuerLen (348) +func (f EncodedIssuerLenField) Tag() quickfix.Tag { return tag.EncodedIssuerLen } + +//NewEncodedIssuerLen returns a new EncodedIssuerLenField initialized with val +func NewEncodedIssuerLen(val int) EncodedIssuerLenField { + return EncodedIssuerLenField{quickfix.FIXInt(val)} +} + +//EncodedLegIssuerField is a DATA field +type EncodedLegIssuerField struct{ quickfix.FIXString } + +//Tag returns tag.EncodedLegIssuer (619) +func (f EncodedLegIssuerField) Tag() quickfix.Tag { return tag.EncodedLegIssuer } + +//NewEncodedLegIssuer returns a new EncodedLegIssuerField initialized with val +func NewEncodedLegIssuer(val string) EncodedLegIssuerField { + return EncodedLegIssuerField{quickfix.FIXString(val)} +} + +//EncodedLegIssuerLenField is a LENGTH field +type EncodedLegIssuerLenField struct{ quickfix.FIXInt } + +//Tag returns tag.EncodedLegIssuerLen (618) +func (f EncodedLegIssuerLenField) Tag() quickfix.Tag { return tag.EncodedLegIssuerLen } + +//NewEncodedLegIssuerLen returns a new EncodedLegIssuerLenField initialized with val +func NewEncodedLegIssuerLen(val int) EncodedLegIssuerLenField { + return EncodedLegIssuerLenField{quickfix.FIXInt(val)} +} + +//EncodedLegSecurityDescField is a DATA field +type EncodedLegSecurityDescField struct{ quickfix.FIXString } + +//Tag returns tag.EncodedLegSecurityDesc (622) +func (f EncodedLegSecurityDescField) Tag() quickfix.Tag { return tag.EncodedLegSecurityDesc } + +//NewEncodedLegSecurityDesc returns a new EncodedLegSecurityDescField initialized with val +func NewEncodedLegSecurityDesc(val string) EncodedLegSecurityDescField { + return EncodedLegSecurityDescField{quickfix.FIXString(val)} +} + +//EncodedLegSecurityDescLenField is a LENGTH field +type EncodedLegSecurityDescLenField struct{ quickfix.FIXInt } + +//Tag returns tag.EncodedLegSecurityDescLen (621) +func (f EncodedLegSecurityDescLenField) Tag() quickfix.Tag { return tag.EncodedLegSecurityDescLen } + +//NewEncodedLegSecurityDescLen returns a new EncodedLegSecurityDescLenField initialized with val +func NewEncodedLegSecurityDescLen(val int) EncodedLegSecurityDescLenField { + return EncodedLegSecurityDescLenField{quickfix.FIXInt(val)} +} + +//EncodedListExecInstField is a DATA field +type EncodedListExecInstField struct{ quickfix.FIXString } + +//Tag returns tag.EncodedListExecInst (353) +func (f EncodedListExecInstField) Tag() quickfix.Tag { return tag.EncodedListExecInst } + +//NewEncodedListExecInst returns a new EncodedListExecInstField initialized with val +func NewEncodedListExecInst(val string) EncodedListExecInstField { + return EncodedListExecInstField{quickfix.FIXString(val)} +} + +//EncodedListExecInstLenField is a LENGTH field +type EncodedListExecInstLenField struct{ quickfix.FIXInt } + +//Tag returns tag.EncodedListExecInstLen (352) +func (f EncodedListExecInstLenField) Tag() quickfix.Tag { return tag.EncodedListExecInstLen } + +//NewEncodedListExecInstLen returns a new EncodedListExecInstLenField initialized with val +func NewEncodedListExecInstLen(val int) EncodedListExecInstLenField { + return EncodedListExecInstLenField{quickfix.FIXInt(val)} +} + +//EncodedListStatusTextField is a DATA field +type EncodedListStatusTextField struct{ quickfix.FIXString } + +//Tag returns tag.EncodedListStatusText (446) +func (f EncodedListStatusTextField) Tag() quickfix.Tag { return tag.EncodedListStatusText } + +//NewEncodedListStatusText returns a new EncodedListStatusTextField initialized with val +func NewEncodedListStatusText(val string) EncodedListStatusTextField { + return EncodedListStatusTextField{quickfix.FIXString(val)} +} + +//EncodedListStatusTextLenField is a LENGTH field +type EncodedListStatusTextLenField struct{ quickfix.FIXInt } + +//Tag returns tag.EncodedListStatusTextLen (445) +func (f EncodedListStatusTextLenField) Tag() quickfix.Tag { return tag.EncodedListStatusTextLen } + +//NewEncodedListStatusTextLen returns a new EncodedListStatusTextLenField initialized with val +func NewEncodedListStatusTextLen(val int) EncodedListStatusTextLenField { + return EncodedListStatusTextLenField{quickfix.FIXInt(val)} +} + +//EncodedMktSegmDescField is a DATA field +type EncodedMktSegmDescField struct{ quickfix.FIXString } + +//Tag returns tag.EncodedMktSegmDesc (1398) +func (f EncodedMktSegmDescField) Tag() quickfix.Tag { return tag.EncodedMktSegmDesc } + +//NewEncodedMktSegmDesc returns a new EncodedMktSegmDescField initialized with val +func NewEncodedMktSegmDesc(val string) EncodedMktSegmDescField { + return EncodedMktSegmDescField{quickfix.FIXString(val)} +} + +//EncodedMktSegmDescLenField is a LENGTH field +type EncodedMktSegmDescLenField struct{ quickfix.FIXInt } + +//Tag returns tag.EncodedMktSegmDescLen (1397) +func (f EncodedMktSegmDescLenField) Tag() quickfix.Tag { return tag.EncodedMktSegmDescLen } + +//NewEncodedMktSegmDescLen returns a new EncodedMktSegmDescLenField initialized with val +func NewEncodedMktSegmDescLen(val int) EncodedMktSegmDescLenField { + return EncodedMktSegmDescLenField{quickfix.FIXInt(val)} +} + +//EncodedSecurityDescField is a DATA field +type EncodedSecurityDescField struct{ quickfix.FIXString } + +//Tag returns tag.EncodedSecurityDesc (351) +func (f EncodedSecurityDescField) Tag() quickfix.Tag { return tag.EncodedSecurityDesc } + +//NewEncodedSecurityDesc returns a new EncodedSecurityDescField initialized with val +func NewEncodedSecurityDesc(val string) EncodedSecurityDescField { + return EncodedSecurityDescField{quickfix.FIXString(val)} +} + +//EncodedSecurityDescLenField is a LENGTH field +type EncodedSecurityDescLenField struct{ quickfix.FIXInt } + +//Tag returns tag.EncodedSecurityDescLen (350) +func (f EncodedSecurityDescLenField) Tag() quickfix.Tag { return tag.EncodedSecurityDescLen } + +//NewEncodedSecurityDescLen returns a new EncodedSecurityDescLenField initialized with val +func NewEncodedSecurityDescLen(val int) EncodedSecurityDescLenField { + return EncodedSecurityDescLenField{quickfix.FIXInt(val)} +} + +//EncodedSecurityListDescField is a DATA field +type EncodedSecurityListDescField struct{ quickfix.FIXString } + +//Tag returns tag.EncodedSecurityListDesc (1469) +func (f EncodedSecurityListDescField) Tag() quickfix.Tag { return tag.EncodedSecurityListDesc } + +//NewEncodedSecurityListDesc returns a new EncodedSecurityListDescField initialized with val +func NewEncodedSecurityListDesc(val string) EncodedSecurityListDescField { + return EncodedSecurityListDescField{quickfix.FIXString(val)} +} + +//EncodedSecurityListDescLenField is a LENGTH field +type EncodedSecurityListDescLenField struct{ quickfix.FIXInt } + +//Tag returns tag.EncodedSecurityListDescLen (1468) +func (f EncodedSecurityListDescLenField) Tag() quickfix.Tag { return tag.EncodedSecurityListDescLen } + +//NewEncodedSecurityListDescLen returns a new EncodedSecurityListDescLenField initialized with val +func NewEncodedSecurityListDescLen(val int) EncodedSecurityListDescLenField { + return EncodedSecurityListDescLenField{quickfix.FIXInt(val)} +} + +//EncodedSubjectField is a DATA field +type EncodedSubjectField struct{ quickfix.FIXString } + +//Tag returns tag.EncodedSubject (357) +func (f EncodedSubjectField) Tag() quickfix.Tag { return tag.EncodedSubject } + +//NewEncodedSubject returns a new EncodedSubjectField initialized with val +func NewEncodedSubject(val string) EncodedSubjectField { + return EncodedSubjectField{quickfix.FIXString(val)} +} + +//EncodedSubjectLenField is a LENGTH field +type EncodedSubjectLenField struct{ quickfix.FIXInt } + +//Tag returns tag.EncodedSubjectLen (356) +func (f EncodedSubjectLenField) Tag() quickfix.Tag { return tag.EncodedSubjectLen } + +//NewEncodedSubjectLen returns a new EncodedSubjectLenField initialized with val +func NewEncodedSubjectLen(val int) EncodedSubjectLenField { + return EncodedSubjectLenField{quickfix.FIXInt(val)} +} + +//EncodedSymbolField is a DATA field +type EncodedSymbolField struct{ quickfix.FIXString } + +//Tag returns tag.EncodedSymbol (1360) +func (f EncodedSymbolField) Tag() quickfix.Tag { return tag.EncodedSymbol } + +//NewEncodedSymbol returns a new EncodedSymbolField initialized with val +func NewEncodedSymbol(val string) EncodedSymbolField { + return EncodedSymbolField{quickfix.FIXString(val)} +} + +//EncodedSymbolLenField is a LENGTH field +type EncodedSymbolLenField struct{ quickfix.FIXInt } + +//Tag returns tag.EncodedSymbolLen (1359) +func (f EncodedSymbolLenField) Tag() quickfix.Tag { return tag.EncodedSymbolLen } + +//NewEncodedSymbolLen returns a new EncodedSymbolLenField initialized with val +func NewEncodedSymbolLen(val int) EncodedSymbolLenField { + return EncodedSymbolLenField{quickfix.FIXInt(val)} +} + +//EncodedTextField is a DATA field +type EncodedTextField struct{ quickfix.FIXString } + +//Tag returns tag.EncodedText (355) +func (f EncodedTextField) Tag() quickfix.Tag { return tag.EncodedText } + +//NewEncodedText returns a new EncodedTextField initialized with val +func NewEncodedText(val string) EncodedTextField { + return EncodedTextField{quickfix.FIXString(val)} +} + +//EncodedTextLenField is a LENGTH field +type EncodedTextLenField struct{ quickfix.FIXInt } + +//Tag returns tag.EncodedTextLen (354) +func (f EncodedTextLenField) Tag() quickfix.Tag { return tag.EncodedTextLen } + +//NewEncodedTextLen returns a new EncodedTextLenField initialized with val +func NewEncodedTextLen(val int) EncodedTextLenField { + return EncodedTextLenField{quickfix.FIXInt(val)} +} + +//EncodedUnderlyingIssuerField is a DATA field +type EncodedUnderlyingIssuerField struct{ quickfix.FIXString } + +//Tag returns tag.EncodedUnderlyingIssuer (363) +func (f EncodedUnderlyingIssuerField) Tag() quickfix.Tag { return tag.EncodedUnderlyingIssuer } + +//NewEncodedUnderlyingIssuer returns a new EncodedUnderlyingIssuerField initialized with val +func NewEncodedUnderlyingIssuer(val string) EncodedUnderlyingIssuerField { + return EncodedUnderlyingIssuerField{quickfix.FIXString(val)} +} + +//EncodedUnderlyingIssuerLenField is a LENGTH field +type EncodedUnderlyingIssuerLenField struct{ quickfix.FIXInt } + +//Tag returns tag.EncodedUnderlyingIssuerLen (362) +func (f EncodedUnderlyingIssuerLenField) Tag() quickfix.Tag { return tag.EncodedUnderlyingIssuerLen } + +//NewEncodedUnderlyingIssuerLen returns a new EncodedUnderlyingIssuerLenField initialized with val +func NewEncodedUnderlyingIssuerLen(val int) EncodedUnderlyingIssuerLenField { + return EncodedUnderlyingIssuerLenField{quickfix.FIXInt(val)} +} + +//EncodedUnderlyingSecurityDescField is a DATA field +type EncodedUnderlyingSecurityDescField struct{ quickfix.FIXString } + +//Tag returns tag.EncodedUnderlyingSecurityDesc (365) +func (f EncodedUnderlyingSecurityDescField) Tag() quickfix.Tag { + return tag.EncodedUnderlyingSecurityDesc +} + +//NewEncodedUnderlyingSecurityDesc returns a new EncodedUnderlyingSecurityDescField initialized with val +func NewEncodedUnderlyingSecurityDesc(val string) EncodedUnderlyingSecurityDescField { + return EncodedUnderlyingSecurityDescField{quickfix.FIXString(val)} +} + +//EncodedUnderlyingSecurityDescLenField is a LENGTH field +type EncodedUnderlyingSecurityDescLenField struct{ quickfix.FIXInt } + +//Tag returns tag.EncodedUnderlyingSecurityDescLen (364) +func (f EncodedUnderlyingSecurityDescLenField) Tag() quickfix.Tag { + return tag.EncodedUnderlyingSecurityDescLen +} + +//NewEncodedUnderlyingSecurityDescLen returns a new EncodedUnderlyingSecurityDescLenField initialized with val +func NewEncodedUnderlyingSecurityDescLen(val int) EncodedUnderlyingSecurityDescLenField { + return EncodedUnderlyingSecurityDescLenField{quickfix.FIXInt(val)} +} + +//EncryptMethodField is a INT field +type EncryptMethodField struct{ quickfix.FIXInt } + +//Tag returns tag.EncryptMethod (98) +func (f EncryptMethodField) Tag() quickfix.Tag { return tag.EncryptMethod } + +//NewEncryptMethod returns a new EncryptMethodField initialized with val +func NewEncryptMethod(val int) EncryptMethodField { + return EncryptMethodField{quickfix.FIXInt(val)} +} + +//EncryptedNewPasswordField is a DATA field +type EncryptedNewPasswordField struct{ quickfix.FIXString } + +//Tag returns tag.EncryptedNewPassword (1404) +func (f EncryptedNewPasswordField) Tag() quickfix.Tag { return tag.EncryptedNewPassword } + +//NewEncryptedNewPassword returns a new EncryptedNewPasswordField initialized with val +func NewEncryptedNewPassword(val string) EncryptedNewPasswordField { + return EncryptedNewPasswordField{quickfix.FIXString(val)} +} + +//EncryptedNewPasswordLenField is a LENGTH field +type EncryptedNewPasswordLenField struct{ quickfix.FIXInt } + +//Tag returns tag.EncryptedNewPasswordLen (1403) +func (f EncryptedNewPasswordLenField) Tag() quickfix.Tag { return tag.EncryptedNewPasswordLen } + +//NewEncryptedNewPasswordLen returns a new EncryptedNewPasswordLenField initialized with val +func NewEncryptedNewPasswordLen(val int) EncryptedNewPasswordLenField { + return EncryptedNewPasswordLenField{quickfix.FIXInt(val)} +} + +//EncryptedPasswordField is a DATA field +type EncryptedPasswordField struct{ quickfix.FIXString } + +//Tag returns tag.EncryptedPassword (1402) +func (f EncryptedPasswordField) Tag() quickfix.Tag { return tag.EncryptedPassword } + +//NewEncryptedPassword returns a new EncryptedPasswordField initialized with val +func NewEncryptedPassword(val string) EncryptedPasswordField { + return EncryptedPasswordField{quickfix.FIXString(val)} +} + +//EncryptedPasswordLenField is a LENGTH field +type EncryptedPasswordLenField struct{ quickfix.FIXInt } + +//Tag returns tag.EncryptedPasswordLen (1401) +func (f EncryptedPasswordLenField) Tag() quickfix.Tag { return tag.EncryptedPasswordLen } + +//NewEncryptedPasswordLen returns a new EncryptedPasswordLenField initialized with val +func NewEncryptedPasswordLen(val int) EncryptedPasswordLenField { + return EncryptedPasswordLenField{quickfix.FIXInt(val)} +} + +//EncryptedPasswordMethodField is a INT field +type EncryptedPasswordMethodField struct{ quickfix.FIXInt } + +//Tag returns tag.EncryptedPasswordMethod (1400) +func (f EncryptedPasswordMethodField) Tag() quickfix.Tag { return tag.EncryptedPasswordMethod } + +//NewEncryptedPasswordMethod returns a new EncryptedPasswordMethodField initialized with val +func NewEncryptedPasswordMethod(val int) EncryptedPasswordMethodField { + return EncryptedPasswordMethodField{quickfix.FIXInt(val)} +} + +//EndAccruedInterestAmtField is a AMT field +type EndAccruedInterestAmtField struct{ quickfix.FIXFloat } + +//Tag returns tag.EndAccruedInterestAmt (920) +func (f EndAccruedInterestAmtField) Tag() quickfix.Tag { return tag.EndAccruedInterestAmt } + +//NewEndAccruedInterestAmt returns a new EndAccruedInterestAmtField initialized with val +func NewEndAccruedInterestAmt(val float64) EndAccruedInterestAmtField { + return EndAccruedInterestAmtField{quickfix.FIXFloat(val)} +} + +//EndCashField is a AMT field +type EndCashField struct{ quickfix.FIXFloat } + +//Tag returns tag.EndCash (922) +func (f EndCashField) Tag() quickfix.Tag { return tag.EndCash } + +//NewEndCash returns a new EndCashField initialized with val +func NewEndCash(val float64) EndCashField { + return EndCashField{quickfix.FIXFloat(val)} +} + +//EndDateField is a LOCALMKTDATE field +type EndDateField struct{ quickfix.FIXString } + +//Tag returns tag.EndDate (917) +func (f EndDateField) Tag() quickfix.Tag { return tag.EndDate } + +//NewEndDate returns a new EndDateField initialized with val +func NewEndDate(val string) EndDateField { + return EndDateField{quickfix.FIXString(val)} +} + +//EndMaturityMonthYearField is a MONTHYEAR field +type EndMaturityMonthYearField struct{ quickfix.FIXString } + +//Tag returns tag.EndMaturityMonthYear (1226) +func (f EndMaturityMonthYearField) Tag() quickfix.Tag { return tag.EndMaturityMonthYear } + +//NewEndMaturityMonthYear returns a new EndMaturityMonthYearField initialized with val +func NewEndMaturityMonthYear(val string) EndMaturityMonthYearField { + return EndMaturityMonthYearField{quickfix.FIXString(val)} +} + +//EndSeqNoField is a SEQNUM field +type EndSeqNoField struct{ quickfix.FIXInt } + +//Tag returns tag.EndSeqNo (16) +func (f EndSeqNoField) Tag() quickfix.Tag { return tag.EndSeqNo } + +//NewEndSeqNo returns a new EndSeqNoField initialized with val +func NewEndSeqNo(val int) EndSeqNoField { + return EndSeqNoField{quickfix.FIXInt(val)} +} + +//EndStrikePxRangeField is a PRICE field +type EndStrikePxRangeField struct{ quickfix.FIXFloat } + +//Tag returns tag.EndStrikePxRange (1203) +func (f EndStrikePxRangeField) Tag() quickfix.Tag { return tag.EndStrikePxRange } + +//NewEndStrikePxRange returns a new EndStrikePxRangeField initialized with val +func NewEndStrikePxRange(val float64) EndStrikePxRangeField { + return EndStrikePxRangeField{quickfix.FIXFloat(val)} +} + +//EndTickPriceRangeField is a PRICE field +type EndTickPriceRangeField struct{ quickfix.FIXFloat } + +//Tag returns tag.EndTickPriceRange (1207) +func (f EndTickPriceRangeField) Tag() quickfix.Tag { return tag.EndTickPriceRange } + +//NewEndTickPriceRange returns a new EndTickPriceRangeField initialized with val +func NewEndTickPriceRange(val float64) EndTickPriceRangeField { + return EndTickPriceRangeField{quickfix.FIXFloat(val)} +} + +//EventDateField is a LOCALMKTDATE field +type EventDateField struct{ quickfix.FIXString } + +//Tag returns tag.EventDate (866) +func (f EventDateField) Tag() quickfix.Tag { return tag.EventDate } + +//NewEventDate returns a new EventDateField initialized with val +func NewEventDate(val string) EventDateField { + return EventDateField{quickfix.FIXString(val)} +} + +//EventPxField is a PRICE field +type EventPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.EventPx (867) +func (f EventPxField) Tag() quickfix.Tag { return tag.EventPx } + +//NewEventPx returns a new EventPxField initialized with val +func NewEventPx(val float64) EventPxField { + return EventPxField{quickfix.FIXFloat(val)} +} + +//EventTextField is a STRING field +type EventTextField struct{ quickfix.FIXString } + +//Tag returns tag.EventText (868) +func (f EventTextField) Tag() quickfix.Tag { return tag.EventText } + +//NewEventText returns a new EventTextField initialized with val +func NewEventText(val string) EventTextField { + return EventTextField{quickfix.FIXString(val)} +} + +//EventTimeField is a UTCTIMESTAMP field +type EventTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.EventTime (1145) +func (f EventTimeField) Tag() quickfix.Tag { return tag.EventTime } + +//NewEventTime returns a new EventTimeField initialized with val +func NewEventTime(val time.Time) EventTimeField { + return EventTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewEventTimeNoMillis returns a new EventTimeField initialized with val without millisecs +func NewEventTimeNoMillis(val time.Time) EventTimeField { + return EventTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//EventTypeField is a INT field +type EventTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.EventType (865) +func (f EventTypeField) Tag() quickfix.Tag { return tag.EventType } + +//NewEventType returns a new EventTypeField initialized with val +func NewEventType(val int) EventTypeField { + return EventTypeField{quickfix.FIXInt(val)} +} + +//ExDateField is a LOCALMKTDATE field +type ExDateField struct{ quickfix.FIXString } + +//Tag returns tag.ExDate (230) +func (f ExDateField) Tag() quickfix.Tag { return tag.ExDate } + +//NewExDate returns a new ExDateField initialized with val +func NewExDate(val string) ExDateField { + return ExDateField{quickfix.FIXString(val)} +} + +//ExDestinationField is a EXCHANGE field +type ExDestinationField struct{ quickfix.FIXString } + +//Tag returns tag.ExDestination (100) +func (f ExDestinationField) Tag() quickfix.Tag { return tag.ExDestination } + +//NewExDestination returns a new ExDestinationField initialized with val +func NewExDestination(val string) ExDestinationField { + return ExDestinationField{quickfix.FIXString(val)} +} + +//ExDestinationIDSourceField is a CHAR field +type ExDestinationIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.ExDestinationIDSource (1133) +func (f ExDestinationIDSourceField) Tag() quickfix.Tag { return tag.ExDestinationIDSource } + +//NewExDestinationIDSource returns a new ExDestinationIDSourceField initialized with val +func NewExDestinationIDSource(val string) ExDestinationIDSourceField { + return ExDestinationIDSourceField{quickfix.FIXString(val)} +} + +//ExchangeForPhysicalField is a BOOLEAN field +type ExchangeForPhysicalField struct{ quickfix.FIXBoolean } + +//Tag returns tag.ExchangeForPhysical (411) +func (f ExchangeForPhysicalField) Tag() quickfix.Tag { return tag.ExchangeForPhysical } + +//NewExchangeForPhysical returns a new ExchangeForPhysicalField initialized with val +func NewExchangeForPhysical(val bool) ExchangeForPhysicalField { + return ExchangeForPhysicalField{quickfix.FIXBoolean(val)} +} + +//ExchangeRuleField is a STRING field +type ExchangeRuleField struct{ quickfix.FIXString } + +//Tag returns tag.ExchangeRule (825) +func (f ExchangeRuleField) Tag() quickfix.Tag { return tag.ExchangeRule } + +//NewExchangeRule returns a new ExchangeRuleField initialized with val +func NewExchangeRule(val string) ExchangeRuleField { + return ExchangeRuleField{quickfix.FIXString(val)} +} + +//ExchangeSpecialInstructionsField is a STRING field +type ExchangeSpecialInstructionsField struct{ quickfix.FIXString } + +//Tag returns tag.ExchangeSpecialInstructions (1139) +func (f ExchangeSpecialInstructionsField) Tag() quickfix.Tag { return tag.ExchangeSpecialInstructions } + +//NewExchangeSpecialInstructions returns a new ExchangeSpecialInstructionsField initialized with val +func NewExchangeSpecialInstructions(val string) ExchangeSpecialInstructionsField { + return ExchangeSpecialInstructionsField{quickfix.FIXString(val)} +} + +//ExecAckStatusField is a CHAR field +type ExecAckStatusField struct{ quickfix.FIXString } + +//Tag returns tag.ExecAckStatus (1036) +func (f ExecAckStatusField) Tag() quickfix.Tag { return tag.ExecAckStatus } + +//NewExecAckStatus returns a new ExecAckStatusField initialized with val +func NewExecAckStatus(val string) ExecAckStatusField { + return ExecAckStatusField{quickfix.FIXString(val)} +} + +//ExecBrokerField is a STRING field +type ExecBrokerField struct{ quickfix.FIXString } + +//Tag returns tag.ExecBroker (76) +func (f ExecBrokerField) Tag() quickfix.Tag { return tag.ExecBroker } + +//NewExecBroker returns a new ExecBrokerField initialized with val +func NewExecBroker(val string) ExecBrokerField { + return ExecBrokerField{quickfix.FIXString(val)} +} + +//ExecIDField is a STRING field +type ExecIDField struct{ quickfix.FIXString } + +//Tag returns tag.ExecID (17) +func (f ExecIDField) Tag() quickfix.Tag { return tag.ExecID } + +//NewExecID returns a new ExecIDField initialized with val +func NewExecID(val string) ExecIDField { + return ExecIDField{quickfix.FIXString(val)} +} + +//ExecInstField is a MULTIPLECHARVALUE field +type ExecInstField struct{ quickfix.FIXString } + +//Tag returns tag.ExecInst (18) +func (f ExecInstField) Tag() quickfix.Tag { return tag.ExecInst } + +//NewExecInst returns a new ExecInstField initialized with val +func NewExecInst(val string) ExecInstField { + return ExecInstField{quickfix.FIXString(val)} +} + +//ExecInstValueField is a CHAR field +type ExecInstValueField struct{ quickfix.FIXString } + +//Tag returns tag.ExecInstValue (1308) +func (f ExecInstValueField) Tag() quickfix.Tag { return tag.ExecInstValue } + +//NewExecInstValue returns a new ExecInstValueField initialized with val +func NewExecInstValue(val string) ExecInstValueField { + return ExecInstValueField{quickfix.FIXString(val)} +} + +//ExecPriceAdjustmentField is a FLOAT field +type ExecPriceAdjustmentField struct{ quickfix.FIXFloat } + +//Tag returns tag.ExecPriceAdjustment (485) +func (f ExecPriceAdjustmentField) Tag() quickfix.Tag { return tag.ExecPriceAdjustment } + +//NewExecPriceAdjustment returns a new ExecPriceAdjustmentField initialized with val +func NewExecPriceAdjustment(val float64) ExecPriceAdjustmentField { + return ExecPriceAdjustmentField{quickfix.FIXFloat(val)} +} + +//ExecPriceTypeField is a CHAR field +type ExecPriceTypeField struct{ quickfix.FIXString } + +//Tag returns tag.ExecPriceType (484) +func (f ExecPriceTypeField) Tag() quickfix.Tag { return tag.ExecPriceType } + +//NewExecPriceType returns a new ExecPriceTypeField initialized with val +func NewExecPriceType(val string) ExecPriceTypeField { + return ExecPriceTypeField{quickfix.FIXString(val)} +} + +//ExecRefIDField is a STRING field +type ExecRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.ExecRefID (19) +func (f ExecRefIDField) Tag() quickfix.Tag { return tag.ExecRefID } + +//NewExecRefID returns a new ExecRefIDField initialized with val +func NewExecRefID(val string) ExecRefIDField { + return ExecRefIDField{quickfix.FIXString(val)} +} + +//ExecRestatementReasonField is a INT field +type ExecRestatementReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.ExecRestatementReason (378) +func (f ExecRestatementReasonField) Tag() quickfix.Tag { return tag.ExecRestatementReason } + +//NewExecRestatementReason returns a new ExecRestatementReasonField initialized with val +func NewExecRestatementReason(val int) ExecRestatementReasonField { + return ExecRestatementReasonField{quickfix.FIXInt(val)} +} + +//ExecTransTypeField is a CHAR field +type ExecTransTypeField struct{ quickfix.FIXString } + +//Tag returns tag.ExecTransType (20) +func (f ExecTransTypeField) Tag() quickfix.Tag { return tag.ExecTransType } + +//NewExecTransType returns a new ExecTransTypeField initialized with val +func NewExecTransType(val string) ExecTransTypeField { + return ExecTransTypeField{quickfix.FIXString(val)} +} + +//ExecTypeField is a CHAR field +type ExecTypeField struct{ quickfix.FIXString } + +//Tag returns tag.ExecType (150) +func (f ExecTypeField) Tag() quickfix.Tag { return tag.ExecType } + +//NewExecType returns a new ExecTypeField initialized with val +func NewExecType(val string) ExecTypeField { + return ExecTypeField{quickfix.FIXString(val)} +} + +//ExecValuationPointField is a UTCTIMESTAMP field +type ExecValuationPointField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.ExecValuationPoint (515) +func (f ExecValuationPointField) Tag() quickfix.Tag { return tag.ExecValuationPoint } + +//NewExecValuationPoint returns a new ExecValuationPointField initialized with val +func NewExecValuationPoint(val time.Time) ExecValuationPointField { + return ExecValuationPointField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewExecValuationPointNoMillis returns a new ExecValuationPointField initialized with val without millisecs +func NewExecValuationPointNoMillis(val time.Time) ExecValuationPointField { + return ExecValuationPointField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//ExerciseMethodField is a CHAR field +type ExerciseMethodField struct{ quickfix.FIXString } + +//Tag returns tag.ExerciseMethod (747) +func (f ExerciseMethodField) Tag() quickfix.Tag { return tag.ExerciseMethod } + +//NewExerciseMethod returns a new ExerciseMethodField initialized with val +func NewExerciseMethod(val string) ExerciseMethodField { + return ExerciseMethodField{quickfix.FIXString(val)} +} + +//ExerciseStyleField is a INT field +type ExerciseStyleField struct{ quickfix.FIXInt } + +//Tag returns tag.ExerciseStyle (1194) +func (f ExerciseStyleField) Tag() quickfix.Tag { return tag.ExerciseStyle } + +//NewExerciseStyle returns a new ExerciseStyleField initialized with val +func NewExerciseStyle(val int) ExerciseStyleField { + return ExerciseStyleField{quickfix.FIXInt(val)} +} + +//ExpQtyField is a QTY field +type ExpQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.ExpQty (983) +func (f ExpQtyField) Tag() quickfix.Tag { return tag.ExpQty } + +//NewExpQty returns a new ExpQtyField initialized with val +func NewExpQty(val float64) ExpQtyField { + return ExpQtyField{quickfix.FIXFloat(val)} +} + +//ExpTypeField is a INT field +type ExpTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.ExpType (982) +func (f ExpTypeField) Tag() quickfix.Tag { return tag.ExpType } + +//NewExpType returns a new ExpTypeField initialized with val +func NewExpType(val int) ExpTypeField { + return ExpTypeField{quickfix.FIXInt(val)} +} + +//ExpirationCycleField is a INT field +type ExpirationCycleField struct{ quickfix.FIXInt } + +//Tag returns tag.ExpirationCycle (827) +func (f ExpirationCycleField) Tag() quickfix.Tag { return tag.ExpirationCycle } + +//NewExpirationCycle returns a new ExpirationCycleField initialized with val +func NewExpirationCycle(val int) ExpirationCycleField { + return ExpirationCycleField{quickfix.FIXInt(val)} +} + +//ExpirationQtyTypeField is a INT field +type ExpirationQtyTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.ExpirationQtyType (982) +func (f ExpirationQtyTypeField) Tag() quickfix.Tag { return tag.ExpirationQtyType } + +//NewExpirationQtyType returns a new ExpirationQtyTypeField initialized with val +func NewExpirationQtyType(val int) ExpirationQtyTypeField { + return ExpirationQtyTypeField{quickfix.FIXInt(val)} +} + +//ExpireDateField is a LOCALMKTDATE field +type ExpireDateField struct{ quickfix.FIXString } + +//Tag returns tag.ExpireDate (432) +func (f ExpireDateField) Tag() quickfix.Tag { return tag.ExpireDate } + +//NewExpireDate returns a new ExpireDateField initialized with val +func NewExpireDate(val string) ExpireDateField { + return ExpireDateField{quickfix.FIXString(val)} +} + +//ExpireTimeField is a UTCTIMESTAMP field +type ExpireTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.ExpireTime (126) +func (f ExpireTimeField) Tag() quickfix.Tag { return tag.ExpireTime } + +//NewExpireTime returns a new ExpireTimeField initialized with val +func NewExpireTime(val time.Time) ExpireTimeField { + return ExpireTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewExpireTimeNoMillis returns a new ExpireTimeField initialized with val without millisecs +func NewExpireTimeNoMillis(val time.Time) ExpireTimeField { + return ExpireTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//FactorField is a FLOAT field +type FactorField struct{ quickfix.FIXFloat } + +//Tag returns tag.Factor (228) +func (f FactorField) Tag() quickfix.Tag { return tag.Factor } + +//NewFactor returns a new FactorField initialized with val +func NewFactor(val float64) FactorField { + return FactorField{quickfix.FIXFloat(val)} +} + +//FairValueField is a AMT field +type FairValueField struct{ quickfix.FIXFloat } + +//Tag returns tag.FairValue (406) +func (f FairValueField) Tag() quickfix.Tag { return tag.FairValue } + +//NewFairValue returns a new FairValueField initialized with val +func NewFairValue(val float64) FairValueField { + return FairValueField{quickfix.FIXFloat(val)} +} + +//FeeMultiplierField is a FLOAT field +type FeeMultiplierField struct{ quickfix.FIXFloat } + +//Tag returns tag.FeeMultiplier (1329) +func (f FeeMultiplierField) Tag() quickfix.Tag { return tag.FeeMultiplier } + +//NewFeeMultiplier returns a new FeeMultiplierField initialized with val +func NewFeeMultiplier(val float64) FeeMultiplierField { + return FeeMultiplierField{quickfix.FIXFloat(val)} +} + +//FillExecIDField is a STRING field +type FillExecIDField struct{ quickfix.FIXString } + +//Tag returns tag.FillExecID (1363) +func (f FillExecIDField) Tag() quickfix.Tag { return tag.FillExecID } + +//NewFillExecID returns a new FillExecIDField initialized with val +func NewFillExecID(val string) FillExecIDField { + return FillExecIDField{quickfix.FIXString(val)} +} + +//FillLiquidityIndField is a INT field +type FillLiquidityIndField struct{ quickfix.FIXInt } + +//Tag returns tag.FillLiquidityInd (1443) +func (f FillLiquidityIndField) Tag() quickfix.Tag { return tag.FillLiquidityInd } + +//NewFillLiquidityInd returns a new FillLiquidityIndField initialized with val +func NewFillLiquidityInd(val int) FillLiquidityIndField { + return FillLiquidityIndField{quickfix.FIXInt(val)} +} + +//FillPxField is a PRICE field +type FillPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.FillPx (1364) +func (f FillPxField) Tag() quickfix.Tag { return tag.FillPx } + +//NewFillPx returns a new FillPxField initialized with val +func NewFillPx(val float64) FillPxField { + return FillPxField{quickfix.FIXFloat(val)} +} + +//FillQtyField is a QTY field +type FillQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.FillQty (1365) +func (f FillQtyField) Tag() quickfix.Tag { return tag.FillQty } + +//NewFillQty returns a new FillQtyField initialized with val +func NewFillQty(val float64) FillQtyField { + return FillQtyField{quickfix.FIXFloat(val)} +} + +//FinancialStatusField is a MULTIPLECHARVALUE field +type FinancialStatusField struct{ quickfix.FIXString } + +//Tag returns tag.FinancialStatus (291) +func (f FinancialStatusField) Tag() quickfix.Tag { return tag.FinancialStatus } + +//NewFinancialStatus returns a new FinancialStatusField initialized with val +func NewFinancialStatus(val string) FinancialStatusField { + return FinancialStatusField{quickfix.FIXString(val)} +} + +//FirmTradeIDField is a STRING field +type FirmTradeIDField struct{ quickfix.FIXString } + +//Tag returns tag.FirmTradeID (1041) +func (f FirmTradeIDField) Tag() quickfix.Tag { return tag.FirmTradeID } + +//NewFirmTradeID returns a new FirmTradeIDField initialized with val +func NewFirmTradeID(val string) FirmTradeIDField { + return FirmTradeIDField{quickfix.FIXString(val)} +} + +//FirstPxField is a PRICE field +type FirstPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.FirstPx (1025) +func (f FirstPxField) Tag() quickfix.Tag { return tag.FirstPx } + +//NewFirstPx returns a new FirstPxField initialized with val +func NewFirstPx(val float64) FirstPxField { + return FirstPxField{quickfix.FIXFloat(val)} +} + +//FlexProductEligibilityIndicatorField is a BOOLEAN field +type FlexProductEligibilityIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.FlexProductEligibilityIndicator (1242) +func (f FlexProductEligibilityIndicatorField) Tag() quickfix.Tag { + return tag.FlexProductEligibilityIndicator +} + +//NewFlexProductEligibilityIndicator returns a new FlexProductEligibilityIndicatorField initialized with val +func NewFlexProductEligibilityIndicator(val bool) FlexProductEligibilityIndicatorField { + return FlexProductEligibilityIndicatorField{quickfix.FIXBoolean(val)} +} + +//FlexibleIndicatorField is a BOOLEAN field +type FlexibleIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.FlexibleIndicator (1244) +func (f FlexibleIndicatorField) Tag() quickfix.Tag { return tag.FlexibleIndicator } + +//NewFlexibleIndicator returns a new FlexibleIndicatorField initialized with val +func NewFlexibleIndicator(val bool) FlexibleIndicatorField { + return FlexibleIndicatorField{quickfix.FIXBoolean(val)} +} + +//FloorPriceField is a PRICE field +type FloorPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.FloorPrice (1200) +func (f FloorPriceField) Tag() quickfix.Tag { return tag.FloorPrice } + +//NewFloorPrice returns a new FloorPriceField initialized with val +func NewFloorPrice(val float64) FloorPriceField { + return FloorPriceField{quickfix.FIXFloat(val)} +} + +//FlowScheduleTypeField is a INT field +type FlowScheduleTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.FlowScheduleType (1439) +func (f FlowScheduleTypeField) Tag() quickfix.Tag { return tag.FlowScheduleType } + +//NewFlowScheduleType returns a new FlowScheduleTypeField initialized with val +func NewFlowScheduleType(val int) FlowScheduleTypeField { + return FlowScheduleTypeField{quickfix.FIXInt(val)} +} + +//ForexReqField is a BOOLEAN field +type ForexReqField struct{ quickfix.FIXBoolean } + +//Tag returns tag.ForexReq (121) +func (f ForexReqField) Tag() quickfix.Tag { return tag.ForexReq } + +//NewForexReq returns a new ForexReqField initialized with val +func NewForexReq(val bool) ForexReqField { + return ForexReqField{quickfix.FIXBoolean(val)} +} + +//FundRenewWaivField is a CHAR field +type FundRenewWaivField struct{ quickfix.FIXString } + +//Tag returns tag.FundRenewWaiv (497) +func (f FundRenewWaivField) Tag() quickfix.Tag { return tag.FundRenewWaiv } + +//NewFundRenewWaiv returns a new FundRenewWaivField initialized with val +func NewFundRenewWaiv(val string) FundRenewWaivField { + return FundRenewWaivField{quickfix.FIXString(val)} +} + +//FutSettDateField is a LOCALMKTDATE field +type FutSettDateField struct{ quickfix.FIXString } + +//Tag returns tag.FutSettDate (64) +func (f FutSettDateField) Tag() quickfix.Tag { return tag.FutSettDate } + +//NewFutSettDate returns a new FutSettDateField initialized with val +func NewFutSettDate(val string) FutSettDateField { + return FutSettDateField{quickfix.FIXString(val)} +} + +//FutSettDate2Field is a LOCALMKTDATE field +type FutSettDate2Field struct{ quickfix.FIXString } + +//Tag returns tag.FutSettDate2 (193) +func (f FutSettDate2Field) Tag() quickfix.Tag { return tag.FutSettDate2 } + +//NewFutSettDate2 returns a new FutSettDate2Field initialized with val +func NewFutSettDate2(val string) FutSettDate2Field { + return FutSettDate2Field{quickfix.FIXString(val)} +} + +//FuturesValuationMethodField is a STRING field +type FuturesValuationMethodField struct{ quickfix.FIXString } + +//Tag returns tag.FuturesValuationMethod (1197) +func (f FuturesValuationMethodField) Tag() quickfix.Tag { return tag.FuturesValuationMethod } + +//NewFuturesValuationMethod returns a new FuturesValuationMethodField initialized with val +func NewFuturesValuationMethod(val string) FuturesValuationMethodField { + return FuturesValuationMethodField{quickfix.FIXString(val)} +} + +//GTBookingInstField is a INT field +type GTBookingInstField struct{ quickfix.FIXInt } + +//Tag returns tag.GTBookingInst (427) +func (f GTBookingInstField) Tag() quickfix.Tag { return tag.GTBookingInst } + +//NewGTBookingInst returns a new GTBookingInstField initialized with val +func NewGTBookingInst(val int) GTBookingInstField { + return GTBookingInstField{quickfix.FIXInt(val)} +} + +//GapFillFlagField is a BOOLEAN field +type GapFillFlagField struct{ quickfix.FIXBoolean } + +//Tag returns tag.GapFillFlag (123) +func (f GapFillFlagField) Tag() quickfix.Tag { return tag.GapFillFlag } + +//NewGapFillFlag returns a new GapFillFlagField initialized with val +func NewGapFillFlag(val bool) GapFillFlagField { + return GapFillFlagField{quickfix.FIXBoolean(val)} +} + +//GrossTradeAmtField is a AMT field +type GrossTradeAmtField struct{ quickfix.FIXFloat } + +//Tag returns tag.GrossTradeAmt (381) +func (f GrossTradeAmtField) Tag() quickfix.Tag { return tag.GrossTradeAmt } + +//NewGrossTradeAmt returns a new GrossTradeAmtField initialized with val +func NewGrossTradeAmt(val float64) GrossTradeAmtField { + return GrossTradeAmtField{quickfix.FIXFloat(val)} +} + +//HaltReasonCharField is a CHAR field +type HaltReasonCharField struct{ quickfix.FIXString } + +//Tag returns tag.HaltReasonChar (327) +func (f HaltReasonCharField) Tag() quickfix.Tag { return tag.HaltReasonChar } + +//NewHaltReasonChar returns a new HaltReasonCharField initialized with val +func NewHaltReasonChar(val string) HaltReasonCharField { + return HaltReasonCharField{quickfix.FIXString(val)} +} + +//HaltReasonIntField is a INT field +type HaltReasonIntField struct{ quickfix.FIXInt } + +//Tag returns tag.HaltReasonInt (327) +func (f HaltReasonIntField) Tag() quickfix.Tag { return tag.HaltReasonInt } + +//NewHaltReasonInt returns a new HaltReasonIntField initialized with val +func NewHaltReasonInt(val int) HaltReasonIntField { + return HaltReasonIntField{quickfix.FIXInt(val)} +} + +//HandlInstField is a CHAR field +type HandlInstField struct{ quickfix.FIXString } + +//Tag returns tag.HandlInst (21) +func (f HandlInstField) Tag() quickfix.Tag { return tag.HandlInst } + +//NewHandlInst returns a new HandlInstField initialized with val +func NewHandlInst(val string) HandlInstField { + return HandlInstField{quickfix.FIXString(val)} +} + +//HeadlineField is a STRING field +type HeadlineField struct{ quickfix.FIXString } + +//Tag returns tag.Headline (148) +func (f HeadlineField) Tag() quickfix.Tag { return tag.Headline } + +//NewHeadline returns a new HeadlineField initialized with val +func NewHeadline(val string) HeadlineField { + return HeadlineField{quickfix.FIXString(val)} +} + +//HeartBtIntField is a INT field +type HeartBtIntField struct{ quickfix.FIXInt } + +//Tag returns tag.HeartBtInt (108) +func (f HeartBtIntField) Tag() quickfix.Tag { return tag.HeartBtInt } + +//NewHeartBtInt returns a new HeartBtIntField initialized with val +func NewHeartBtInt(val int) HeartBtIntField { + return HeartBtIntField{quickfix.FIXInt(val)} +} + +//HighLimitPriceField is a PRICE field +type HighLimitPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.HighLimitPrice (1149) +func (f HighLimitPriceField) Tag() quickfix.Tag { return tag.HighLimitPrice } + +//NewHighLimitPrice returns a new HighLimitPriceField initialized with val +func NewHighLimitPrice(val float64) HighLimitPriceField { + return HighLimitPriceField{quickfix.FIXFloat(val)} +} + +//HighPxField is a PRICE field +type HighPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.HighPx (332) +func (f HighPxField) Tag() quickfix.Tag { return tag.HighPx } + +//NewHighPx returns a new HighPxField initialized with val +func NewHighPx(val float64) HighPxField { + return HighPxField{quickfix.FIXFloat(val)} +} + +//HopCompIDField is a STRING field +type HopCompIDField struct{ quickfix.FIXString } + +//Tag returns tag.HopCompID (628) +func (f HopCompIDField) Tag() quickfix.Tag { return tag.HopCompID } + +//NewHopCompID returns a new HopCompIDField initialized with val +func NewHopCompID(val string) HopCompIDField { + return HopCompIDField{quickfix.FIXString(val)} +} + +//HopRefIDField is a SEQNUM field +type HopRefIDField struct{ quickfix.FIXInt } + +//Tag returns tag.HopRefID (630) +func (f HopRefIDField) Tag() quickfix.Tag { return tag.HopRefID } + +//NewHopRefID returns a new HopRefIDField initialized with val +func NewHopRefID(val int) HopRefIDField { + return HopRefIDField{quickfix.FIXInt(val)} +} + +//HopSendingTimeField is a UTCTIMESTAMP field +type HopSendingTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.HopSendingTime (629) +func (f HopSendingTimeField) Tag() quickfix.Tag { return tag.HopSendingTime } + +//NewHopSendingTime returns a new HopSendingTimeField initialized with val +func NewHopSendingTime(val time.Time) HopSendingTimeField { + return HopSendingTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewHopSendingTimeNoMillis returns a new HopSendingTimeField initialized with val without millisecs +func NewHopSendingTimeNoMillis(val time.Time) HopSendingTimeField { + return HopSendingTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//HostCrossIDField is a STRING field +type HostCrossIDField struct{ quickfix.FIXString } + +//Tag returns tag.HostCrossID (961) +func (f HostCrossIDField) Tag() quickfix.Tag { return tag.HostCrossID } + +//NewHostCrossID returns a new HostCrossIDField initialized with val +func NewHostCrossID(val string) HostCrossIDField { + return HostCrossIDField{quickfix.FIXString(val)} +} + +//IDSourceField is a STRING field +type IDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.IDSource (22) +func (f IDSourceField) Tag() quickfix.Tag { return tag.IDSource } + +//NewIDSource returns a new IDSourceField initialized with val +func NewIDSource(val string) IDSourceField { + return IDSourceField{quickfix.FIXString(val)} +} + +//IOIIDField is a STRING field +type IOIIDField struct{ quickfix.FIXString } + +//Tag returns tag.IOIID (23) +func (f IOIIDField) Tag() quickfix.Tag { return tag.IOIID } + +//NewIOIID returns a new IOIIDField initialized with val +func NewIOIID(val string) IOIIDField { + return IOIIDField{quickfix.FIXString(val)} +} + +//IOINaturalFlagField is a BOOLEAN field +type IOINaturalFlagField struct{ quickfix.FIXBoolean } + +//Tag returns tag.IOINaturalFlag (130) +func (f IOINaturalFlagField) Tag() quickfix.Tag { return tag.IOINaturalFlag } + +//NewIOINaturalFlag returns a new IOINaturalFlagField initialized with val +func NewIOINaturalFlag(val bool) IOINaturalFlagField { + return IOINaturalFlagField{quickfix.FIXBoolean(val)} +} + +//IOIOthSvcField is a CHAR field +type IOIOthSvcField struct{ quickfix.FIXString } + +//Tag returns tag.IOIOthSvc (24) +func (f IOIOthSvcField) Tag() quickfix.Tag { return tag.IOIOthSvc } + +//NewIOIOthSvc returns a new IOIOthSvcField initialized with val +func NewIOIOthSvc(val string) IOIOthSvcField { + return IOIOthSvcField{quickfix.FIXString(val)} +} + +//IOIQltyIndField is a CHAR field +type IOIQltyIndField struct{ quickfix.FIXString } + +//Tag returns tag.IOIQltyInd (25) +func (f IOIQltyIndField) Tag() quickfix.Tag { return tag.IOIQltyInd } + +//NewIOIQltyInd returns a new IOIQltyIndField initialized with val +func NewIOIQltyInd(val string) IOIQltyIndField { + return IOIQltyIndField{quickfix.FIXString(val)} +} + +//IOIQtyField is a STRING field +type IOIQtyField struct{ quickfix.FIXString } + +//Tag returns tag.IOIQty (27) +func (f IOIQtyField) Tag() quickfix.Tag { return tag.IOIQty } + +//NewIOIQty returns a new IOIQtyField initialized with val +func NewIOIQty(val string) IOIQtyField { + return IOIQtyField{quickfix.FIXString(val)} +} + +//IOIQualifierField is a CHAR field +type IOIQualifierField struct{ quickfix.FIXString } + +//Tag returns tag.IOIQualifier (104) +func (f IOIQualifierField) Tag() quickfix.Tag { return tag.IOIQualifier } + +//NewIOIQualifier returns a new IOIQualifierField initialized with val +func NewIOIQualifier(val string) IOIQualifierField { + return IOIQualifierField{quickfix.FIXString(val)} +} + +//IOIRefIDField is a STRING field +type IOIRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.IOIRefID (26) +func (f IOIRefIDField) Tag() quickfix.Tag { return tag.IOIRefID } + +//NewIOIRefID returns a new IOIRefIDField initialized with val +func NewIOIRefID(val string) IOIRefIDField { + return IOIRefIDField{quickfix.FIXString(val)} +} + +//IOISharesField is a STRING field +type IOISharesField struct{ quickfix.FIXString } + +//Tag returns tag.IOIShares (27) +func (f IOISharesField) Tag() quickfix.Tag { return tag.IOIShares } + +//NewIOIShares returns a new IOISharesField initialized with val +func NewIOIShares(val string) IOISharesField { + return IOISharesField{quickfix.FIXString(val)} +} + +//IOITransTypeField is a CHAR field +type IOITransTypeField struct{ quickfix.FIXString } + +//Tag returns tag.IOITransType (28) +func (f IOITransTypeField) Tag() quickfix.Tag { return tag.IOITransType } + +//NewIOITransType returns a new IOITransTypeField initialized with val +func NewIOITransType(val string) IOITransTypeField { + return IOITransTypeField{quickfix.FIXString(val)} +} + +//IOIidField is a STRING field +type IOIidField struct{ quickfix.FIXString } + +//Tag returns tag.IOIid (23) +func (f IOIidField) Tag() quickfix.Tag { return tag.IOIid } + +//NewIOIid returns a new IOIidField initialized with val +func NewIOIid(val string) IOIidField { + return IOIidField{quickfix.FIXString(val)} +} + +//ImpliedMarketIndicatorField is a INT field +type ImpliedMarketIndicatorField struct{ quickfix.FIXInt } + +//Tag returns tag.ImpliedMarketIndicator (1144) +func (f ImpliedMarketIndicatorField) Tag() quickfix.Tag { return tag.ImpliedMarketIndicator } + +//NewImpliedMarketIndicator returns a new ImpliedMarketIndicatorField initialized with val +func NewImpliedMarketIndicator(val int) ImpliedMarketIndicatorField { + return ImpliedMarketIndicatorField{quickfix.FIXInt(val)} +} + +//InViewOfCommonField is a BOOLEAN field +type InViewOfCommonField struct{ quickfix.FIXBoolean } + +//Tag returns tag.InViewOfCommon (328) +func (f InViewOfCommonField) Tag() quickfix.Tag { return tag.InViewOfCommon } + +//NewInViewOfCommon returns a new InViewOfCommonField initialized with val +func NewInViewOfCommon(val bool) InViewOfCommonField { + return InViewOfCommonField{quickfix.FIXBoolean(val)} +} + +//IncTaxIndField is a INT field +type IncTaxIndField struct{ quickfix.FIXInt } + +//Tag returns tag.IncTaxInd (416) +func (f IncTaxIndField) Tag() quickfix.Tag { return tag.IncTaxInd } + +//NewIncTaxInd returns a new IncTaxIndField initialized with val +func NewIncTaxInd(val int) IncTaxIndField { + return IncTaxIndField{quickfix.FIXInt(val)} +} + +//IndividualAllocIDField is a STRING field +type IndividualAllocIDField struct{ quickfix.FIXString } + +//Tag returns tag.IndividualAllocID (467) +func (f IndividualAllocIDField) Tag() quickfix.Tag { return tag.IndividualAllocID } + +//NewIndividualAllocID returns a new IndividualAllocIDField initialized with val +func NewIndividualAllocID(val string) IndividualAllocIDField { + return IndividualAllocIDField{quickfix.FIXString(val)} +} + +//IndividualAllocRejCodeField is a INT field +type IndividualAllocRejCodeField struct{ quickfix.FIXInt } + +//Tag returns tag.IndividualAllocRejCode (776) +func (f IndividualAllocRejCodeField) Tag() quickfix.Tag { return tag.IndividualAllocRejCode } + +//NewIndividualAllocRejCode returns a new IndividualAllocRejCodeField initialized with val +func NewIndividualAllocRejCode(val int) IndividualAllocRejCodeField { + return IndividualAllocRejCodeField{quickfix.FIXInt(val)} +} + +//IndividualAllocTypeField is a INT field +type IndividualAllocTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.IndividualAllocType (992) +func (f IndividualAllocTypeField) Tag() quickfix.Tag { return tag.IndividualAllocType } + +//NewIndividualAllocType returns a new IndividualAllocTypeField initialized with val +func NewIndividualAllocType(val int) IndividualAllocTypeField { + return IndividualAllocTypeField{quickfix.FIXInt(val)} +} + +//InputSourceField is a STRING field +type InputSourceField struct{ quickfix.FIXString } + +//Tag returns tag.InputSource (979) +func (f InputSourceField) Tag() quickfix.Tag { return tag.InputSource } + +//NewInputSource returns a new InputSourceField initialized with val +func NewInputSource(val string) InputSourceField { + return InputSourceField{quickfix.FIXString(val)} +} + +//InstrAttribTypeField is a INT field +type InstrAttribTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.InstrAttribType (871) +func (f InstrAttribTypeField) Tag() quickfix.Tag { return tag.InstrAttribType } + +//NewInstrAttribType returns a new InstrAttribTypeField initialized with val +func NewInstrAttribType(val int) InstrAttribTypeField { + return InstrAttribTypeField{quickfix.FIXInt(val)} +} + +//InstrAttribValueField is a STRING field +type InstrAttribValueField struct{ quickfix.FIXString } + +//Tag returns tag.InstrAttribValue (872) +func (f InstrAttribValueField) Tag() quickfix.Tag { return tag.InstrAttribValue } + +//NewInstrAttribValue returns a new InstrAttribValueField initialized with val +func NewInstrAttribValue(val string) InstrAttribValueField { + return InstrAttribValueField{quickfix.FIXString(val)} +} + +//InstrRegistryField is a STRING field +type InstrRegistryField struct{ quickfix.FIXString } + +//Tag returns tag.InstrRegistry (543) +func (f InstrRegistryField) Tag() quickfix.Tag { return tag.InstrRegistry } + +//NewInstrRegistry returns a new InstrRegistryField initialized with val +func NewInstrRegistry(val string) InstrRegistryField { + return InstrRegistryField{quickfix.FIXString(val)} +} + +//InstrmtAssignmentMethodField is a CHAR field +type InstrmtAssignmentMethodField struct{ quickfix.FIXString } + +//Tag returns tag.InstrmtAssignmentMethod (1049) +func (f InstrmtAssignmentMethodField) Tag() quickfix.Tag { return tag.InstrmtAssignmentMethod } + +//NewInstrmtAssignmentMethod returns a new InstrmtAssignmentMethodField initialized with val +func NewInstrmtAssignmentMethod(val string) InstrmtAssignmentMethodField { + return InstrmtAssignmentMethodField{quickfix.FIXString(val)} +} + +//InstrumentPartyIDField is a STRING field +type InstrumentPartyIDField struct{ quickfix.FIXString } + +//Tag returns tag.InstrumentPartyID (1019) +func (f InstrumentPartyIDField) Tag() quickfix.Tag { return tag.InstrumentPartyID } + +//NewInstrumentPartyID returns a new InstrumentPartyIDField initialized with val +func NewInstrumentPartyID(val string) InstrumentPartyIDField { + return InstrumentPartyIDField{quickfix.FIXString(val)} +} + +//InstrumentPartyIDSourceField is a CHAR field +type InstrumentPartyIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.InstrumentPartyIDSource (1050) +func (f InstrumentPartyIDSourceField) Tag() quickfix.Tag { return tag.InstrumentPartyIDSource } + +//NewInstrumentPartyIDSource returns a new InstrumentPartyIDSourceField initialized with val +func NewInstrumentPartyIDSource(val string) InstrumentPartyIDSourceField { + return InstrumentPartyIDSourceField{quickfix.FIXString(val)} +} + +//InstrumentPartyRoleField is a INT field +type InstrumentPartyRoleField struct{ quickfix.FIXInt } + +//Tag returns tag.InstrumentPartyRole (1051) +func (f InstrumentPartyRoleField) Tag() quickfix.Tag { return tag.InstrumentPartyRole } + +//NewInstrumentPartyRole returns a new InstrumentPartyRoleField initialized with val +func NewInstrumentPartyRole(val int) InstrumentPartyRoleField { + return InstrumentPartyRoleField{quickfix.FIXInt(val)} +} + +//InstrumentPartySubIDField is a STRING field +type InstrumentPartySubIDField struct{ quickfix.FIXString } + +//Tag returns tag.InstrumentPartySubID (1053) +func (f InstrumentPartySubIDField) Tag() quickfix.Tag { return tag.InstrumentPartySubID } + +//NewInstrumentPartySubID returns a new InstrumentPartySubIDField initialized with val +func NewInstrumentPartySubID(val string) InstrumentPartySubIDField { + return InstrumentPartySubIDField{quickfix.FIXString(val)} +} + +//InstrumentPartySubIDTypeField is a INT field +type InstrumentPartySubIDTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.InstrumentPartySubIDType (1054) +func (f InstrumentPartySubIDTypeField) Tag() quickfix.Tag { return tag.InstrumentPartySubIDType } + +//NewInstrumentPartySubIDType returns a new InstrumentPartySubIDTypeField initialized with val +func NewInstrumentPartySubIDType(val int) InstrumentPartySubIDTypeField { + return InstrumentPartySubIDTypeField{quickfix.FIXInt(val)} +} + +//InterestAccrualDateField is a LOCALMKTDATE field +type InterestAccrualDateField struct{ quickfix.FIXString } + +//Tag returns tag.InterestAccrualDate (874) +func (f InterestAccrualDateField) Tag() quickfix.Tag { return tag.InterestAccrualDate } + +//NewInterestAccrualDate returns a new InterestAccrualDateField initialized with val +func NewInterestAccrualDate(val string) InterestAccrualDateField { + return InterestAccrualDateField{quickfix.FIXString(val)} +} + +//InterestAtMaturityField is a AMT field +type InterestAtMaturityField struct{ quickfix.FIXFloat } + +//Tag returns tag.InterestAtMaturity (738) +func (f InterestAtMaturityField) Tag() quickfix.Tag { return tag.InterestAtMaturity } + +//NewInterestAtMaturity returns a new InterestAtMaturityField initialized with val +func NewInterestAtMaturity(val float64) InterestAtMaturityField { + return InterestAtMaturityField{quickfix.FIXFloat(val)} +} + +//InvestorCountryOfResidenceField is a COUNTRY field +type InvestorCountryOfResidenceField struct{ quickfix.FIXString } + +//Tag returns tag.InvestorCountryOfResidence (475) +func (f InvestorCountryOfResidenceField) Tag() quickfix.Tag { return tag.InvestorCountryOfResidence } + +//NewInvestorCountryOfResidence returns a new InvestorCountryOfResidenceField initialized with val +func NewInvestorCountryOfResidence(val string) InvestorCountryOfResidenceField { + return InvestorCountryOfResidenceField{quickfix.FIXString(val)} +} + +//IssueDateField is a LOCALMKTDATE field +type IssueDateField struct{ quickfix.FIXString } + +//Tag returns tag.IssueDate (225) +func (f IssueDateField) Tag() quickfix.Tag { return tag.IssueDate } + +//NewIssueDate returns a new IssueDateField initialized with val +func NewIssueDate(val string) IssueDateField { + return IssueDateField{quickfix.FIXString(val)} +} + +//IssuerField is a STRING field +type IssuerField struct{ quickfix.FIXString } + +//Tag returns tag.Issuer (106) +func (f IssuerField) Tag() quickfix.Tag { return tag.Issuer } + +//NewIssuer returns a new IssuerField initialized with val +func NewIssuer(val string) IssuerField { + return IssuerField{quickfix.FIXString(val)} +} + +//LanguageCodeField is a LANGUAGE field +type LanguageCodeField struct{ quickfix.FIXString } + +//Tag returns tag.LanguageCode (1474) +func (f LanguageCodeField) Tag() quickfix.Tag { return tag.LanguageCode } + +//NewLanguageCode returns a new LanguageCodeField initialized with val +func NewLanguageCode(val string) LanguageCodeField { + return LanguageCodeField{quickfix.FIXString(val)} +} + +//LastCapacityField is a CHAR field +type LastCapacityField struct{ quickfix.FIXString } + +//Tag returns tag.LastCapacity (29) +func (f LastCapacityField) Tag() quickfix.Tag { return tag.LastCapacity } + +//NewLastCapacity returns a new LastCapacityField initialized with val +func NewLastCapacity(val string) LastCapacityField { + return LastCapacityField{quickfix.FIXString(val)} +} + +//LastForwardPointsField is a PRICEOFFSET field +type LastForwardPointsField struct{ quickfix.FIXFloat } + +//Tag returns tag.LastForwardPoints (195) +func (f LastForwardPointsField) Tag() quickfix.Tag { return tag.LastForwardPoints } + +//NewLastForwardPoints returns a new LastForwardPointsField initialized with val +func NewLastForwardPoints(val float64) LastForwardPointsField { + return LastForwardPointsField{quickfix.FIXFloat(val)} +} + +//LastForwardPoints2Field is a PRICEOFFSET field +type LastForwardPoints2Field struct{ quickfix.FIXFloat } + +//Tag returns tag.LastForwardPoints2 (641) +func (f LastForwardPoints2Field) Tag() quickfix.Tag { return tag.LastForwardPoints2 } + +//NewLastForwardPoints2 returns a new LastForwardPoints2Field initialized with val +func NewLastForwardPoints2(val float64) LastForwardPoints2Field { + return LastForwardPoints2Field{quickfix.FIXFloat(val)} +} + +//LastFragmentField is a BOOLEAN field +type LastFragmentField struct{ quickfix.FIXBoolean } + +//Tag returns tag.LastFragment (893) +func (f LastFragmentField) Tag() quickfix.Tag { return tag.LastFragment } + +//NewLastFragment returns a new LastFragmentField initialized with val +func NewLastFragment(val bool) LastFragmentField { + return LastFragmentField{quickfix.FIXBoolean(val)} +} + +//LastLiquidityIndField is a INT field +type LastLiquidityIndField struct{ quickfix.FIXInt } + +//Tag returns tag.LastLiquidityInd (851) +func (f LastLiquidityIndField) Tag() quickfix.Tag { return tag.LastLiquidityInd } + +//NewLastLiquidityInd returns a new LastLiquidityIndField initialized with val +func NewLastLiquidityInd(val int) LastLiquidityIndField { + return LastLiquidityIndField{quickfix.FIXInt(val)} +} + +//LastMktField is a EXCHANGE field +type LastMktField struct{ quickfix.FIXString } + +//Tag returns tag.LastMkt (30) +func (f LastMktField) Tag() quickfix.Tag { return tag.LastMkt } + +//NewLastMkt returns a new LastMktField initialized with val +func NewLastMkt(val string) LastMktField { + return LastMktField{quickfix.FIXString(val)} +} + +//LastMsgSeqNumProcessedField is a SEQNUM field +type LastMsgSeqNumProcessedField struct{ quickfix.FIXInt } + +//Tag returns tag.LastMsgSeqNumProcessed (369) +func (f LastMsgSeqNumProcessedField) Tag() quickfix.Tag { return tag.LastMsgSeqNumProcessed } + +//NewLastMsgSeqNumProcessed returns a new LastMsgSeqNumProcessedField initialized with val +func NewLastMsgSeqNumProcessed(val int) LastMsgSeqNumProcessedField { + return LastMsgSeqNumProcessedField{quickfix.FIXInt(val)} +} + +//LastNetworkResponseIDField is a STRING field +type LastNetworkResponseIDField struct{ quickfix.FIXString } + +//Tag returns tag.LastNetworkResponseID (934) +func (f LastNetworkResponseIDField) Tag() quickfix.Tag { return tag.LastNetworkResponseID } + +//NewLastNetworkResponseID returns a new LastNetworkResponseIDField initialized with val +func NewLastNetworkResponseID(val string) LastNetworkResponseIDField { + return LastNetworkResponseIDField{quickfix.FIXString(val)} +} + +//LastParPxField is a PRICE field +type LastParPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.LastParPx (669) +func (f LastParPxField) Tag() quickfix.Tag { return tag.LastParPx } + +//NewLastParPx returns a new LastParPxField initialized with val +func NewLastParPx(val float64) LastParPxField { + return LastParPxField{quickfix.FIXFloat(val)} +} + +//LastPxField is a PRICE field +type LastPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.LastPx (31) +func (f LastPxField) Tag() quickfix.Tag { return tag.LastPx } + +//NewLastPx returns a new LastPxField initialized with val +func NewLastPx(val float64) LastPxField { + return LastPxField{quickfix.FIXFloat(val)} +} + +//LastQtyField is a QTY field +type LastQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.LastQty (32) +func (f LastQtyField) Tag() quickfix.Tag { return tag.LastQty } + +//NewLastQty returns a new LastQtyField initialized with val +func NewLastQty(val float64) LastQtyField { + return LastQtyField{quickfix.FIXFloat(val)} +} + +//LastRptRequestedField is a BOOLEAN field +type LastRptRequestedField struct{ quickfix.FIXBoolean } + +//Tag returns tag.LastRptRequested (912) +func (f LastRptRequestedField) Tag() quickfix.Tag { return tag.LastRptRequested } + +//NewLastRptRequested returns a new LastRptRequestedField initialized with val +func NewLastRptRequested(val bool) LastRptRequestedField { + return LastRptRequestedField{quickfix.FIXBoolean(val)} +} + +//LastSharesField is a QTY field +type LastSharesField struct{ quickfix.FIXFloat } + +//Tag returns tag.LastShares (32) +func (f LastSharesField) Tag() quickfix.Tag { return tag.LastShares } + +//NewLastShares returns a new LastSharesField initialized with val +func NewLastShares(val float64) LastSharesField { + return LastSharesField{quickfix.FIXFloat(val)} +} + +//LastSpotRateField is a PRICE field +type LastSpotRateField struct{ quickfix.FIXFloat } + +//Tag returns tag.LastSpotRate (194) +func (f LastSpotRateField) Tag() quickfix.Tag { return tag.LastSpotRate } + +//NewLastSpotRate returns a new LastSpotRateField initialized with val +func NewLastSpotRate(val float64) LastSpotRateField { + return LastSpotRateField{quickfix.FIXFloat(val)} +} + +//LastSwapPointsField is a PRICEOFFSET field +type LastSwapPointsField struct{ quickfix.FIXFloat } + +//Tag returns tag.LastSwapPoints (1071) +func (f LastSwapPointsField) Tag() quickfix.Tag { return tag.LastSwapPoints } + +//NewLastSwapPoints returns a new LastSwapPointsField initialized with val +func NewLastSwapPoints(val float64) LastSwapPointsField { + return LastSwapPointsField{quickfix.FIXFloat(val)} +} + +//LastUpdateTimeField is a UTCTIMESTAMP field +type LastUpdateTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.LastUpdateTime (779) +func (f LastUpdateTimeField) Tag() quickfix.Tag { return tag.LastUpdateTime } + +//NewLastUpdateTime returns a new LastUpdateTimeField initialized with val +func NewLastUpdateTime(val time.Time) LastUpdateTimeField { + return LastUpdateTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewLastUpdateTimeNoMillis returns a new LastUpdateTimeField initialized with val without millisecs +func NewLastUpdateTimeNoMillis(val time.Time) LastUpdateTimeField { + return LastUpdateTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//LateIndicatorField is a BOOLEAN field +type LateIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.LateIndicator (978) +func (f LateIndicatorField) Tag() quickfix.Tag { return tag.LateIndicator } + +//NewLateIndicator returns a new LateIndicatorField initialized with val +func NewLateIndicator(val bool) LateIndicatorField { + return LateIndicatorField{quickfix.FIXBoolean(val)} +} + +//LeavesQtyField is a QTY field +type LeavesQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.LeavesQty (151) +func (f LeavesQtyField) Tag() quickfix.Tag { return tag.LeavesQty } + +//NewLeavesQty returns a new LeavesQtyField initialized with val +func NewLeavesQty(val float64) LeavesQtyField { + return LeavesQtyField{quickfix.FIXFloat(val)} +} + +//LegAllocAccountField is a STRING field +type LegAllocAccountField struct{ quickfix.FIXString } + +//Tag returns tag.LegAllocAccount (671) +func (f LegAllocAccountField) Tag() quickfix.Tag { return tag.LegAllocAccount } + +//NewLegAllocAccount returns a new LegAllocAccountField initialized with val +func NewLegAllocAccount(val string) LegAllocAccountField { + return LegAllocAccountField{quickfix.FIXString(val)} +} + +//LegAllocAcctIDSourceField is a STRING field +type LegAllocAcctIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.LegAllocAcctIDSource (674) +func (f LegAllocAcctIDSourceField) Tag() quickfix.Tag { return tag.LegAllocAcctIDSource } + +//NewLegAllocAcctIDSource returns a new LegAllocAcctIDSourceField initialized with val +func NewLegAllocAcctIDSource(val string) LegAllocAcctIDSourceField { + return LegAllocAcctIDSourceField{quickfix.FIXString(val)} +} + +//LegAllocIDField is a STRING field +type LegAllocIDField struct{ quickfix.FIXString } + +//Tag returns tag.LegAllocID (1366) +func (f LegAllocIDField) Tag() quickfix.Tag { return tag.LegAllocID } + +//NewLegAllocID returns a new LegAllocIDField initialized with val +func NewLegAllocID(val string) LegAllocIDField { + return LegAllocIDField{quickfix.FIXString(val)} +} + +//LegAllocQtyField is a QTY field +type LegAllocQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegAllocQty (673) +func (f LegAllocQtyField) Tag() quickfix.Tag { return tag.LegAllocQty } + +//NewLegAllocQty returns a new LegAllocQtyField initialized with val +func NewLegAllocQty(val float64) LegAllocQtyField { + return LegAllocQtyField{quickfix.FIXFloat(val)} +} + +//LegAllocSettlCurrencyField is a CURRENCY field +type LegAllocSettlCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.LegAllocSettlCurrency (1367) +func (f LegAllocSettlCurrencyField) Tag() quickfix.Tag { return tag.LegAllocSettlCurrency } + +//NewLegAllocSettlCurrency returns a new LegAllocSettlCurrencyField initialized with val +func NewLegAllocSettlCurrency(val string) LegAllocSettlCurrencyField { + return LegAllocSettlCurrencyField{quickfix.FIXString(val)} +} + +//LegBenchmarkCurveCurrencyField is a CURRENCY field +type LegBenchmarkCurveCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.LegBenchmarkCurveCurrency (676) +func (f LegBenchmarkCurveCurrencyField) Tag() quickfix.Tag { return tag.LegBenchmarkCurveCurrency } + +//NewLegBenchmarkCurveCurrency returns a new LegBenchmarkCurveCurrencyField initialized with val +func NewLegBenchmarkCurveCurrency(val string) LegBenchmarkCurveCurrencyField { + return LegBenchmarkCurveCurrencyField{quickfix.FIXString(val)} +} + +//LegBenchmarkCurveNameField is a STRING field +type LegBenchmarkCurveNameField struct{ quickfix.FIXString } + +//Tag returns tag.LegBenchmarkCurveName (677) +func (f LegBenchmarkCurveNameField) Tag() quickfix.Tag { return tag.LegBenchmarkCurveName } + +//NewLegBenchmarkCurveName returns a new LegBenchmarkCurveNameField initialized with val +func NewLegBenchmarkCurveName(val string) LegBenchmarkCurveNameField { + return LegBenchmarkCurveNameField{quickfix.FIXString(val)} +} + +//LegBenchmarkCurvePointField is a STRING field +type LegBenchmarkCurvePointField struct{ quickfix.FIXString } + +//Tag returns tag.LegBenchmarkCurvePoint (678) +func (f LegBenchmarkCurvePointField) Tag() quickfix.Tag { return tag.LegBenchmarkCurvePoint } + +//NewLegBenchmarkCurvePoint returns a new LegBenchmarkCurvePointField initialized with val +func NewLegBenchmarkCurvePoint(val string) LegBenchmarkCurvePointField { + return LegBenchmarkCurvePointField{quickfix.FIXString(val)} +} + +//LegBenchmarkPriceField is a PRICE field +type LegBenchmarkPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegBenchmarkPrice (679) +func (f LegBenchmarkPriceField) Tag() quickfix.Tag { return tag.LegBenchmarkPrice } + +//NewLegBenchmarkPrice returns a new LegBenchmarkPriceField initialized with val +func NewLegBenchmarkPrice(val float64) LegBenchmarkPriceField { + return LegBenchmarkPriceField{quickfix.FIXFloat(val)} +} + +//LegBenchmarkPriceTypeField is a INT field +type LegBenchmarkPriceTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.LegBenchmarkPriceType (680) +func (f LegBenchmarkPriceTypeField) Tag() quickfix.Tag { return tag.LegBenchmarkPriceType } + +//NewLegBenchmarkPriceType returns a new LegBenchmarkPriceTypeField initialized with val +func NewLegBenchmarkPriceType(val int) LegBenchmarkPriceTypeField { + return LegBenchmarkPriceTypeField{quickfix.FIXInt(val)} +} + +//LegBidForwardPointsField is a PRICEOFFSET field +type LegBidForwardPointsField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegBidForwardPoints (1067) +func (f LegBidForwardPointsField) Tag() quickfix.Tag { return tag.LegBidForwardPoints } + +//NewLegBidForwardPoints returns a new LegBidForwardPointsField initialized with val +func NewLegBidForwardPoints(val float64) LegBidForwardPointsField { + return LegBidForwardPointsField{quickfix.FIXFloat(val)} +} + +//LegBidPxField is a PRICE field +type LegBidPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegBidPx (681) +func (f LegBidPxField) Tag() quickfix.Tag { return tag.LegBidPx } + +//NewLegBidPx returns a new LegBidPxField initialized with val +func NewLegBidPx(val float64) LegBidPxField { + return LegBidPxField{quickfix.FIXFloat(val)} +} + +//LegCFICodeField is a STRING field +type LegCFICodeField struct{ quickfix.FIXString } + +//Tag returns tag.LegCFICode (608) +func (f LegCFICodeField) Tag() quickfix.Tag { return tag.LegCFICode } + +//NewLegCFICode returns a new LegCFICodeField initialized with val +func NewLegCFICode(val string) LegCFICodeField { + return LegCFICodeField{quickfix.FIXString(val)} +} + +//LegCalculatedCcyLastQtyField is a QTY field +type LegCalculatedCcyLastQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegCalculatedCcyLastQty (1074) +func (f LegCalculatedCcyLastQtyField) Tag() quickfix.Tag { return tag.LegCalculatedCcyLastQty } + +//NewLegCalculatedCcyLastQty returns a new LegCalculatedCcyLastQtyField initialized with val +func NewLegCalculatedCcyLastQty(val float64) LegCalculatedCcyLastQtyField { + return LegCalculatedCcyLastQtyField{quickfix.FIXFloat(val)} +} + +//LegContractMultiplierField is a FLOAT field +type LegContractMultiplierField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegContractMultiplier (614) +func (f LegContractMultiplierField) Tag() quickfix.Tag { return tag.LegContractMultiplier } + +//NewLegContractMultiplier returns a new LegContractMultiplierField initialized with val +func NewLegContractMultiplier(val float64) LegContractMultiplierField { + return LegContractMultiplierField{quickfix.FIXFloat(val)} +} + +//LegContractMultiplierUnitField is a INT field +type LegContractMultiplierUnitField struct{ quickfix.FIXInt } + +//Tag returns tag.LegContractMultiplierUnit (1436) +func (f LegContractMultiplierUnitField) Tag() quickfix.Tag { return tag.LegContractMultiplierUnit } + +//NewLegContractMultiplierUnit returns a new LegContractMultiplierUnitField initialized with val +func NewLegContractMultiplierUnit(val int) LegContractMultiplierUnitField { + return LegContractMultiplierUnitField{quickfix.FIXInt(val)} +} + +//LegContractSettlMonthField is a MONTHYEAR field +type LegContractSettlMonthField struct{ quickfix.FIXString } + +//Tag returns tag.LegContractSettlMonth (955) +func (f LegContractSettlMonthField) Tag() quickfix.Tag { return tag.LegContractSettlMonth } + +//NewLegContractSettlMonth returns a new LegContractSettlMonthField initialized with val +func NewLegContractSettlMonth(val string) LegContractSettlMonthField { + return LegContractSettlMonthField{quickfix.FIXString(val)} +} + +//LegCountryOfIssueField is a COUNTRY field +type LegCountryOfIssueField struct{ quickfix.FIXString } + +//Tag returns tag.LegCountryOfIssue (596) +func (f LegCountryOfIssueField) Tag() quickfix.Tag { return tag.LegCountryOfIssue } + +//NewLegCountryOfIssue returns a new LegCountryOfIssueField initialized with val +func NewLegCountryOfIssue(val string) LegCountryOfIssueField { + return LegCountryOfIssueField{quickfix.FIXString(val)} +} + +//LegCouponPaymentDateField is a LOCALMKTDATE field +type LegCouponPaymentDateField struct{ quickfix.FIXString } + +//Tag returns tag.LegCouponPaymentDate (248) +func (f LegCouponPaymentDateField) Tag() quickfix.Tag { return tag.LegCouponPaymentDate } + +//NewLegCouponPaymentDate returns a new LegCouponPaymentDateField initialized with val +func NewLegCouponPaymentDate(val string) LegCouponPaymentDateField { + return LegCouponPaymentDateField{quickfix.FIXString(val)} +} + +//LegCouponRateField is a PERCENTAGE field +type LegCouponRateField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegCouponRate (615) +func (f LegCouponRateField) Tag() quickfix.Tag { return tag.LegCouponRate } + +//NewLegCouponRate returns a new LegCouponRateField initialized with val +func NewLegCouponRate(val float64) LegCouponRateField { + return LegCouponRateField{quickfix.FIXFloat(val)} +} + +//LegCoveredOrUncoveredField is a INT field +type LegCoveredOrUncoveredField struct{ quickfix.FIXInt } + +//Tag returns tag.LegCoveredOrUncovered (565) +func (f LegCoveredOrUncoveredField) Tag() quickfix.Tag { return tag.LegCoveredOrUncovered } + +//NewLegCoveredOrUncovered returns a new LegCoveredOrUncoveredField initialized with val +func NewLegCoveredOrUncovered(val int) LegCoveredOrUncoveredField { + return LegCoveredOrUncoveredField{quickfix.FIXInt(val)} +} + +//LegCreditRatingField is a STRING field +type LegCreditRatingField struct{ quickfix.FIXString } + +//Tag returns tag.LegCreditRating (257) +func (f LegCreditRatingField) Tag() quickfix.Tag { return tag.LegCreditRating } + +//NewLegCreditRating returns a new LegCreditRatingField initialized with val +func NewLegCreditRating(val string) LegCreditRatingField { + return LegCreditRatingField{quickfix.FIXString(val)} +} + +//LegCurrencyField is a CURRENCY field +type LegCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.LegCurrency (556) +func (f LegCurrencyField) Tag() quickfix.Tag { return tag.LegCurrency } + +//NewLegCurrency returns a new LegCurrencyField initialized with val +func NewLegCurrency(val string) LegCurrencyField { + return LegCurrencyField{quickfix.FIXString(val)} +} + +//LegCurrencyRatioField is a FLOAT field +type LegCurrencyRatioField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegCurrencyRatio (1383) +func (f LegCurrencyRatioField) Tag() quickfix.Tag { return tag.LegCurrencyRatio } + +//NewLegCurrencyRatio returns a new LegCurrencyRatioField initialized with val +func NewLegCurrencyRatio(val float64) LegCurrencyRatioField { + return LegCurrencyRatioField{quickfix.FIXFloat(val)} +} + +//LegDatedDateField is a LOCALMKTDATE field +type LegDatedDateField struct{ quickfix.FIXString } + +//Tag returns tag.LegDatedDate (739) +func (f LegDatedDateField) Tag() quickfix.Tag { return tag.LegDatedDate } + +//NewLegDatedDate returns a new LegDatedDateField initialized with val +func NewLegDatedDate(val string) LegDatedDateField { + return LegDatedDateField{quickfix.FIXString(val)} +} + +//LegDividendYieldField is a PERCENTAGE field +type LegDividendYieldField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegDividendYield (1381) +func (f LegDividendYieldField) Tag() quickfix.Tag { return tag.LegDividendYield } + +//NewLegDividendYield returns a new LegDividendYieldField initialized with val +func NewLegDividendYield(val float64) LegDividendYieldField { + return LegDividendYieldField{quickfix.FIXFloat(val)} +} + +//LegExecInstField is a MULTIPLECHARVALUE field +type LegExecInstField struct{ quickfix.FIXString } + +//Tag returns tag.LegExecInst (1384) +func (f LegExecInstField) Tag() quickfix.Tag { return tag.LegExecInst } + +//NewLegExecInst returns a new LegExecInstField initialized with val +func NewLegExecInst(val string) LegExecInstField { + return LegExecInstField{quickfix.FIXString(val)} +} + +//LegExerciseStyleField is a INT field +type LegExerciseStyleField struct{ quickfix.FIXInt } + +//Tag returns tag.LegExerciseStyle (1420) +func (f LegExerciseStyleField) Tag() quickfix.Tag { return tag.LegExerciseStyle } + +//NewLegExerciseStyle returns a new LegExerciseStyleField initialized with val +func NewLegExerciseStyle(val int) LegExerciseStyleField { + return LegExerciseStyleField{quickfix.FIXInt(val)} +} + +//LegFactorField is a FLOAT field +type LegFactorField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegFactor (253) +func (f LegFactorField) Tag() quickfix.Tag { return tag.LegFactor } + +//NewLegFactor returns a new LegFactorField initialized with val +func NewLegFactor(val float64) LegFactorField { + return LegFactorField{quickfix.FIXFloat(val)} +} + +//LegFlowScheduleTypeField is a INT field +type LegFlowScheduleTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.LegFlowScheduleType (1440) +func (f LegFlowScheduleTypeField) Tag() quickfix.Tag { return tag.LegFlowScheduleType } + +//NewLegFlowScheduleType returns a new LegFlowScheduleTypeField initialized with val +func NewLegFlowScheduleType(val int) LegFlowScheduleTypeField { + return LegFlowScheduleTypeField{quickfix.FIXInt(val)} +} + +//LegFutSettDateField is a LOCALMKTDATE field +type LegFutSettDateField struct{ quickfix.FIXString } + +//Tag returns tag.LegFutSettDate (588) +func (f LegFutSettDateField) Tag() quickfix.Tag { return tag.LegFutSettDate } + +//NewLegFutSettDate returns a new LegFutSettDateField initialized with val +func NewLegFutSettDate(val string) LegFutSettDateField { + return LegFutSettDateField{quickfix.FIXString(val)} +} + +//LegGrossTradeAmtField is a AMT field +type LegGrossTradeAmtField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegGrossTradeAmt (1075) +func (f LegGrossTradeAmtField) Tag() quickfix.Tag { return tag.LegGrossTradeAmt } + +//NewLegGrossTradeAmt returns a new LegGrossTradeAmtField initialized with val +func NewLegGrossTradeAmt(val float64) LegGrossTradeAmtField { + return LegGrossTradeAmtField{quickfix.FIXFloat(val)} +} + +//LegIOIQtyField is a STRING field +type LegIOIQtyField struct{ quickfix.FIXString } + +//Tag returns tag.LegIOIQty (682) +func (f LegIOIQtyField) Tag() quickfix.Tag { return tag.LegIOIQty } + +//NewLegIOIQty returns a new LegIOIQtyField initialized with val +func NewLegIOIQty(val string) LegIOIQtyField { + return LegIOIQtyField{quickfix.FIXString(val)} +} + +//LegIndividualAllocIDField is a STRING field +type LegIndividualAllocIDField struct{ quickfix.FIXString } + +//Tag returns tag.LegIndividualAllocID (672) +func (f LegIndividualAllocIDField) Tag() quickfix.Tag { return tag.LegIndividualAllocID } + +//NewLegIndividualAllocID returns a new LegIndividualAllocIDField initialized with val +func NewLegIndividualAllocID(val string) LegIndividualAllocIDField { + return LegIndividualAllocIDField{quickfix.FIXString(val)} +} + +//LegInstrRegistryField is a STRING field +type LegInstrRegistryField struct{ quickfix.FIXString } + +//Tag returns tag.LegInstrRegistry (599) +func (f LegInstrRegistryField) Tag() quickfix.Tag { return tag.LegInstrRegistry } + +//NewLegInstrRegistry returns a new LegInstrRegistryField initialized with val +func NewLegInstrRegistry(val string) LegInstrRegistryField { + return LegInstrRegistryField{quickfix.FIXString(val)} +} + +//LegInterestAccrualDateField is a LOCALMKTDATE field +type LegInterestAccrualDateField struct{ quickfix.FIXString } + +//Tag returns tag.LegInterestAccrualDate (956) +func (f LegInterestAccrualDateField) Tag() quickfix.Tag { return tag.LegInterestAccrualDate } + +//NewLegInterestAccrualDate returns a new LegInterestAccrualDateField initialized with val +func NewLegInterestAccrualDate(val string) LegInterestAccrualDateField { + return LegInterestAccrualDateField{quickfix.FIXString(val)} +} + +//LegIssueDateField is a LOCALMKTDATE field +type LegIssueDateField struct{ quickfix.FIXString } + +//Tag returns tag.LegIssueDate (249) +func (f LegIssueDateField) Tag() quickfix.Tag { return tag.LegIssueDate } + +//NewLegIssueDate returns a new LegIssueDateField initialized with val +func NewLegIssueDate(val string) LegIssueDateField { + return LegIssueDateField{quickfix.FIXString(val)} +} + +//LegIssuerField is a STRING field +type LegIssuerField struct{ quickfix.FIXString } + +//Tag returns tag.LegIssuer (617) +func (f LegIssuerField) Tag() quickfix.Tag { return tag.LegIssuer } + +//NewLegIssuer returns a new LegIssuerField initialized with val +func NewLegIssuer(val string) LegIssuerField { + return LegIssuerField{quickfix.FIXString(val)} +} + +//LegLastForwardPointsField is a PRICEOFFSET field +type LegLastForwardPointsField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegLastForwardPoints (1073) +func (f LegLastForwardPointsField) Tag() quickfix.Tag { return tag.LegLastForwardPoints } + +//NewLegLastForwardPoints returns a new LegLastForwardPointsField initialized with val +func NewLegLastForwardPoints(val float64) LegLastForwardPointsField { + return LegLastForwardPointsField{quickfix.FIXFloat(val)} +} + +//LegLastPxField is a PRICE field +type LegLastPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegLastPx (637) +func (f LegLastPxField) Tag() quickfix.Tag { return tag.LegLastPx } + +//NewLegLastPx returns a new LegLastPxField initialized with val +func NewLegLastPx(val float64) LegLastPxField { + return LegLastPxField{quickfix.FIXFloat(val)} +} + +//LegLastQtyField is a QTY field +type LegLastQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegLastQty (1418) +func (f LegLastQtyField) Tag() quickfix.Tag { return tag.LegLastQty } + +//NewLegLastQty returns a new LegLastQtyField initialized with val +func NewLegLastQty(val float64) LegLastQtyField { + return LegLastQtyField{quickfix.FIXFloat(val)} +} + +//LegLocaleOfIssueField is a STRING field +type LegLocaleOfIssueField struct{ quickfix.FIXString } + +//Tag returns tag.LegLocaleOfIssue (598) +func (f LegLocaleOfIssueField) Tag() quickfix.Tag { return tag.LegLocaleOfIssue } + +//NewLegLocaleOfIssue returns a new LegLocaleOfIssueField initialized with val +func NewLegLocaleOfIssue(val string) LegLocaleOfIssueField { + return LegLocaleOfIssueField{quickfix.FIXString(val)} +} + +//LegMaturityDateField is a LOCALMKTDATE field +type LegMaturityDateField struct{ quickfix.FIXString } + +//Tag returns tag.LegMaturityDate (611) +func (f LegMaturityDateField) Tag() quickfix.Tag { return tag.LegMaturityDate } + +//NewLegMaturityDate returns a new LegMaturityDateField initialized with val +func NewLegMaturityDate(val string) LegMaturityDateField { + return LegMaturityDateField{quickfix.FIXString(val)} +} + +//LegMaturityMonthYearField is a MONTHYEAR field +type LegMaturityMonthYearField struct{ quickfix.FIXString } + +//Tag returns tag.LegMaturityMonthYear (610) +func (f LegMaturityMonthYearField) Tag() quickfix.Tag { return tag.LegMaturityMonthYear } + +//NewLegMaturityMonthYear returns a new LegMaturityMonthYearField initialized with val +func NewLegMaturityMonthYear(val string) LegMaturityMonthYearField { + return LegMaturityMonthYearField{quickfix.FIXString(val)} +} + +//LegMaturityTimeField is a TZTIMEONLY field +type LegMaturityTimeField struct{ quickfix.FIXString } + +//Tag returns tag.LegMaturityTime (1212) +func (f LegMaturityTimeField) Tag() quickfix.Tag { return tag.LegMaturityTime } + +//NewLegMaturityTime returns a new LegMaturityTimeField initialized with val +func NewLegMaturityTime(val string) LegMaturityTimeField { + return LegMaturityTimeField{quickfix.FIXString(val)} +} + +//LegNumberField is a INT field +type LegNumberField struct{ quickfix.FIXInt } + +//Tag returns tag.LegNumber (1152) +func (f LegNumberField) Tag() quickfix.Tag { return tag.LegNumber } + +//NewLegNumber returns a new LegNumberField initialized with val +func NewLegNumber(val int) LegNumberField { + return LegNumberField{quickfix.FIXInt(val)} +} + +//LegOfferForwardPointsField is a PRICEOFFSET field +type LegOfferForwardPointsField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegOfferForwardPoints (1068) +func (f LegOfferForwardPointsField) Tag() quickfix.Tag { return tag.LegOfferForwardPoints } + +//NewLegOfferForwardPoints returns a new LegOfferForwardPointsField initialized with val +func NewLegOfferForwardPoints(val float64) LegOfferForwardPointsField { + return LegOfferForwardPointsField{quickfix.FIXFloat(val)} +} + +//LegOfferPxField is a PRICE field +type LegOfferPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegOfferPx (684) +func (f LegOfferPxField) Tag() quickfix.Tag { return tag.LegOfferPx } + +//NewLegOfferPx returns a new LegOfferPxField initialized with val +func NewLegOfferPx(val float64) LegOfferPxField { + return LegOfferPxField{quickfix.FIXFloat(val)} +} + +//LegOptAttributeField is a CHAR field +type LegOptAttributeField struct{ quickfix.FIXString } + +//Tag returns tag.LegOptAttribute (613) +func (f LegOptAttributeField) Tag() quickfix.Tag { return tag.LegOptAttribute } + +//NewLegOptAttribute returns a new LegOptAttributeField initialized with val +func NewLegOptAttribute(val string) LegOptAttributeField { + return LegOptAttributeField{quickfix.FIXString(val)} +} + +//LegOptionRatioField is a FLOAT field +type LegOptionRatioField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegOptionRatio (1017) +func (f LegOptionRatioField) Tag() quickfix.Tag { return tag.LegOptionRatio } + +//NewLegOptionRatio returns a new LegOptionRatioField initialized with val +func NewLegOptionRatio(val float64) LegOptionRatioField { + return LegOptionRatioField{quickfix.FIXFloat(val)} +} + +//LegOrderQtyField is a QTY field +type LegOrderQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegOrderQty (685) +func (f LegOrderQtyField) Tag() quickfix.Tag { return tag.LegOrderQty } + +//NewLegOrderQty returns a new LegOrderQtyField initialized with val +func NewLegOrderQty(val float64) LegOrderQtyField { + return LegOrderQtyField{quickfix.FIXFloat(val)} +} + +//LegPoolField is a STRING field +type LegPoolField struct{ quickfix.FIXString } + +//Tag returns tag.LegPool (740) +func (f LegPoolField) Tag() quickfix.Tag { return tag.LegPool } + +//NewLegPool returns a new LegPoolField initialized with val +func NewLegPool(val string) LegPoolField { + return LegPoolField{quickfix.FIXString(val)} +} + +//LegPositionEffectField is a CHAR field +type LegPositionEffectField struct{ quickfix.FIXString } + +//Tag returns tag.LegPositionEffect (564) +func (f LegPositionEffectField) Tag() quickfix.Tag { return tag.LegPositionEffect } + +//NewLegPositionEffect returns a new LegPositionEffectField initialized with val +func NewLegPositionEffect(val string) LegPositionEffectField { + return LegPositionEffectField{quickfix.FIXString(val)} +} + +//LegPriceField is a PRICE field +type LegPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegPrice (566) +func (f LegPriceField) Tag() quickfix.Tag { return tag.LegPrice } + +//NewLegPrice returns a new LegPriceField initialized with val +func NewLegPrice(val float64) LegPriceField { + return LegPriceField{quickfix.FIXFloat(val)} +} + +//LegPriceTypeField is a INT field +type LegPriceTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.LegPriceType (686) +func (f LegPriceTypeField) Tag() quickfix.Tag { return tag.LegPriceType } + +//NewLegPriceType returns a new LegPriceTypeField initialized with val +func NewLegPriceType(val int) LegPriceTypeField { + return LegPriceTypeField{quickfix.FIXInt(val)} +} + +//LegPriceUnitOfMeasureField is a STRING field +type LegPriceUnitOfMeasureField struct{ quickfix.FIXString } + +//Tag returns tag.LegPriceUnitOfMeasure (1421) +func (f LegPriceUnitOfMeasureField) Tag() quickfix.Tag { return tag.LegPriceUnitOfMeasure } + +//NewLegPriceUnitOfMeasure returns a new LegPriceUnitOfMeasureField initialized with val +func NewLegPriceUnitOfMeasure(val string) LegPriceUnitOfMeasureField { + return LegPriceUnitOfMeasureField{quickfix.FIXString(val)} +} + +//LegPriceUnitOfMeasureQtyField is a QTY field +type LegPriceUnitOfMeasureQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegPriceUnitOfMeasureQty (1422) +func (f LegPriceUnitOfMeasureQtyField) Tag() quickfix.Tag { return tag.LegPriceUnitOfMeasureQty } + +//NewLegPriceUnitOfMeasureQty returns a new LegPriceUnitOfMeasureQtyField initialized with val +func NewLegPriceUnitOfMeasureQty(val float64) LegPriceUnitOfMeasureQtyField { + return LegPriceUnitOfMeasureQtyField{quickfix.FIXFloat(val)} +} + +//LegProductField is a INT field +type LegProductField struct{ quickfix.FIXInt } + +//Tag returns tag.LegProduct (607) +func (f LegProductField) Tag() quickfix.Tag { return tag.LegProduct } + +//NewLegProduct returns a new LegProductField initialized with val +func NewLegProduct(val int) LegProductField { + return LegProductField{quickfix.FIXInt(val)} +} + +//LegPutOrCallField is a INT field +type LegPutOrCallField struct{ quickfix.FIXInt } + +//Tag returns tag.LegPutOrCall (1358) +func (f LegPutOrCallField) Tag() quickfix.Tag { return tag.LegPutOrCall } + +//NewLegPutOrCall returns a new LegPutOrCallField initialized with val +func NewLegPutOrCall(val int) LegPutOrCallField { + return LegPutOrCallField{quickfix.FIXInt(val)} +} + +//LegQtyField is a QTY field +type LegQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegQty (687) +func (f LegQtyField) Tag() quickfix.Tag { return tag.LegQty } + +//NewLegQty returns a new LegQtyField initialized with val +func NewLegQty(val float64) LegQtyField { + return LegQtyField{quickfix.FIXFloat(val)} +} + +//LegRatioQtyField is a FLOAT field +type LegRatioQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegRatioQty (623) +func (f LegRatioQtyField) Tag() quickfix.Tag { return tag.LegRatioQty } + +//NewLegRatioQty returns a new LegRatioQtyField initialized with val +func NewLegRatioQty(val float64) LegRatioQtyField { + return LegRatioQtyField{quickfix.FIXFloat(val)} +} + +//LegRedemptionDateField is a LOCALMKTDATE field +type LegRedemptionDateField struct{ quickfix.FIXString } + +//Tag returns tag.LegRedemptionDate (254) +func (f LegRedemptionDateField) Tag() quickfix.Tag { return tag.LegRedemptionDate } + +//NewLegRedemptionDate returns a new LegRedemptionDateField initialized with val +func NewLegRedemptionDate(val string) LegRedemptionDateField { + return LegRedemptionDateField{quickfix.FIXString(val)} +} + +//LegRefIDField is a STRING field +type LegRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.LegRefID (654) +func (f LegRefIDField) Tag() quickfix.Tag { return tag.LegRefID } + +//NewLegRefID returns a new LegRefIDField initialized with val +func NewLegRefID(val string) LegRefIDField { + return LegRefIDField{quickfix.FIXString(val)} +} + +//LegRepoCollateralSecurityTypeField is a INT field +type LegRepoCollateralSecurityTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.LegRepoCollateralSecurityType (250) +func (f LegRepoCollateralSecurityTypeField) Tag() quickfix.Tag { + return tag.LegRepoCollateralSecurityType +} + +//NewLegRepoCollateralSecurityType returns a new LegRepoCollateralSecurityTypeField initialized with val +func NewLegRepoCollateralSecurityType(val int) LegRepoCollateralSecurityTypeField { + return LegRepoCollateralSecurityTypeField{quickfix.FIXInt(val)} +} + +//LegReportIDField is a STRING field +type LegReportIDField struct{ quickfix.FIXString } + +//Tag returns tag.LegReportID (990) +func (f LegReportIDField) Tag() quickfix.Tag { return tag.LegReportID } + +//NewLegReportID returns a new LegReportIDField initialized with val +func NewLegReportID(val string) LegReportIDField { + return LegReportIDField{quickfix.FIXString(val)} +} + +//LegRepurchaseRateField is a PERCENTAGE field +type LegRepurchaseRateField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegRepurchaseRate (252) +func (f LegRepurchaseRateField) Tag() quickfix.Tag { return tag.LegRepurchaseRate } + +//NewLegRepurchaseRate returns a new LegRepurchaseRateField initialized with val +func NewLegRepurchaseRate(val float64) LegRepurchaseRateField { + return LegRepurchaseRateField{quickfix.FIXFloat(val)} +} + +//LegRepurchaseTermField is a INT field +type LegRepurchaseTermField struct{ quickfix.FIXInt } + +//Tag returns tag.LegRepurchaseTerm (251) +func (f LegRepurchaseTermField) Tag() quickfix.Tag { return tag.LegRepurchaseTerm } + +//NewLegRepurchaseTerm returns a new LegRepurchaseTermField initialized with val +func NewLegRepurchaseTerm(val int) LegRepurchaseTermField { + return LegRepurchaseTermField{quickfix.FIXInt(val)} +} + +//LegSecurityAltIDField is a STRING field +type LegSecurityAltIDField struct{ quickfix.FIXString } + +//Tag returns tag.LegSecurityAltID (605) +func (f LegSecurityAltIDField) Tag() quickfix.Tag { return tag.LegSecurityAltID } + +//NewLegSecurityAltID returns a new LegSecurityAltIDField initialized with val +func NewLegSecurityAltID(val string) LegSecurityAltIDField { + return LegSecurityAltIDField{quickfix.FIXString(val)} +} + +//LegSecurityAltIDSourceField is a STRING field +type LegSecurityAltIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.LegSecurityAltIDSource (606) +func (f LegSecurityAltIDSourceField) Tag() quickfix.Tag { return tag.LegSecurityAltIDSource } + +//NewLegSecurityAltIDSource returns a new LegSecurityAltIDSourceField initialized with val +func NewLegSecurityAltIDSource(val string) LegSecurityAltIDSourceField { + return LegSecurityAltIDSourceField{quickfix.FIXString(val)} +} + +//LegSecurityDescField is a STRING field +type LegSecurityDescField struct{ quickfix.FIXString } + +//Tag returns tag.LegSecurityDesc (620) +func (f LegSecurityDescField) Tag() quickfix.Tag { return tag.LegSecurityDesc } + +//NewLegSecurityDesc returns a new LegSecurityDescField initialized with val +func NewLegSecurityDesc(val string) LegSecurityDescField { + return LegSecurityDescField{quickfix.FIXString(val)} +} + +//LegSecurityExchangeField is a EXCHANGE field +type LegSecurityExchangeField struct{ quickfix.FIXString } + +//Tag returns tag.LegSecurityExchange (616) +func (f LegSecurityExchangeField) Tag() quickfix.Tag { return tag.LegSecurityExchange } + +//NewLegSecurityExchange returns a new LegSecurityExchangeField initialized with val +func NewLegSecurityExchange(val string) LegSecurityExchangeField { + return LegSecurityExchangeField{quickfix.FIXString(val)} +} + +//LegSecurityIDField is a STRING field +type LegSecurityIDField struct{ quickfix.FIXString } + +//Tag returns tag.LegSecurityID (602) +func (f LegSecurityIDField) Tag() quickfix.Tag { return tag.LegSecurityID } + +//NewLegSecurityID returns a new LegSecurityIDField initialized with val +func NewLegSecurityID(val string) LegSecurityIDField { + return LegSecurityIDField{quickfix.FIXString(val)} +} + +//LegSecurityIDSourceField is a STRING field +type LegSecurityIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.LegSecurityIDSource (603) +func (f LegSecurityIDSourceField) Tag() quickfix.Tag { return tag.LegSecurityIDSource } + +//NewLegSecurityIDSource returns a new LegSecurityIDSourceField initialized with val +func NewLegSecurityIDSource(val string) LegSecurityIDSourceField { + return LegSecurityIDSourceField{quickfix.FIXString(val)} +} + +//LegSecuritySubTypeField is a STRING field +type LegSecuritySubTypeField struct{ quickfix.FIXString } + +//Tag returns tag.LegSecuritySubType (764) +func (f LegSecuritySubTypeField) Tag() quickfix.Tag { return tag.LegSecuritySubType } + +//NewLegSecuritySubType returns a new LegSecuritySubTypeField initialized with val +func NewLegSecuritySubType(val string) LegSecuritySubTypeField { + return LegSecuritySubTypeField{quickfix.FIXString(val)} +} + +//LegSecurityTypeField is a STRING field +type LegSecurityTypeField struct{ quickfix.FIXString } + +//Tag returns tag.LegSecurityType (609) +func (f LegSecurityTypeField) Tag() quickfix.Tag { return tag.LegSecurityType } + +//NewLegSecurityType returns a new LegSecurityTypeField initialized with val +func NewLegSecurityType(val string) LegSecurityTypeField { + return LegSecurityTypeField{quickfix.FIXString(val)} +} + +//LegSettlCurrencyField is a CURRENCY field +type LegSettlCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.LegSettlCurrency (675) +func (f LegSettlCurrencyField) Tag() quickfix.Tag { return tag.LegSettlCurrency } + +//NewLegSettlCurrency returns a new LegSettlCurrencyField initialized with val +func NewLegSettlCurrency(val string) LegSettlCurrencyField { + return LegSettlCurrencyField{quickfix.FIXString(val)} +} + +//LegSettlDateField is a LOCALMKTDATE field +type LegSettlDateField struct{ quickfix.FIXString } + +//Tag returns tag.LegSettlDate (588) +func (f LegSettlDateField) Tag() quickfix.Tag { return tag.LegSettlDate } + +//NewLegSettlDate returns a new LegSettlDateField initialized with val +func NewLegSettlDate(val string) LegSettlDateField { + return LegSettlDateField{quickfix.FIXString(val)} +} + +//LegSettlTypeField is a CHAR field +type LegSettlTypeField struct{ quickfix.FIXString } + +//Tag returns tag.LegSettlType (587) +func (f LegSettlTypeField) Tag() quickfix.Tag { return tag.LegSettlType } + +//NewLegSettlType returns a new LegSettlTypeField initialized with val +func NewLegSettlType(val string) LegSettlTypeField { + return LegSettlTypeField{quickfix.FIXString(val)} +} + +//LegSettlmntTypField is a CHAR field +type LegSettlmntTypField struct{ quickfix.FIXString } + +//Tag returns tag.LegSettlmntTyp (587) +func (f LegSettlmntTypField) Tag() quickfix.Tag { return tag.LegSettlmntTyp } + +//NewLegSettlmntTyp returns a new LegSettlmntTypField initialized with val +func NewLegSettlmntTyp(val string) LegSettlmntTypField { + return LegSettlmntTypField{quickfix.FIXString(val)} +} + +//LegSideField is a CHAR field +type LegSideField struct{ quickfix.FIXString } + +//Tag returns tag.LegSide (624) +func (f LegSideField) Tag() quickfix.Tag { return tag.LegSide } + +//NewLegSide returns a new LegSideField initialized with val +func NewLegSide(val string) LegSideField { + return LegSideField{quickfix.FIXString(val)} +} + +//LegStateOrProvinceOfIssueField is a STRING field +type LegStateOrProvinceOfIssueField struct{ quickfix.FIXString } + +//Tag returns tag.LegStateOrProvinceOfIssue (597) +func (f LegStateOrProvinceOfIssueField) Tag() quickfix.Tag { return tag.LegStateOrProvinceOfIssue } + +//NewLegStateOrProvinceOfIssue returns a new LegStateOrProvinceOfIssueField initialized with val +func NewLegStateOrProvinceOfIssue(val string) LegStateOrProvinceOfIssueField { + return LegStateOrProvinceOfIssueField{quickfix.FIXString(val)} +} + +//LegStipulationTypeField is a STRING field +type LegStipulationTypeField struct{ quickfix.FIXString } + +//Tag returns tag.LegStipulationType (688) +func (f LegStipulationTypeField) Tag() quickfix.Tag { return tag.LegStipulationType } + +//NewLegStipulationType returns a new LegStipulationTypeField initialized with val +func NewLegStipulationType(val string) LegStipulationTypeField { + return LegStipulationTypeField{quickfix.FIXString(val)} +} + +//LegStipulationValueField is a STRING field +type LegStipulationValueField struct{ quickfix.FIXString } + +//Tag returns tag.LegStipulationValue (689) +func (f LegStipulationValueField) Tag() quickfix.Tag { return tag.LegStipulationValue } + +//NewLegStipulationValue returns a new LegStipulationValueField initialized with val +func NewLegStipulationValue(val string) LegStipulationValueField { + return LegStipulationValueField{quickfix.FIXString(val)} +} + +//LegStrikeCurrencyField is a CURRENCY field +type LegStrikeCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.LegStrikeCurrency (942) +func (f LegStrikeCurrencyField) Tag() quickfix.Tag { return tag.LegStrikeCurrency } + +//NewLegStrikeCurrency returns a new LegStrikeCurrencyField initialized with val +func NewLegStrikeCurrency(val string) LegStrikeCurrencyField { + return LegStrikeCurrencyField{quickfix.FIXString(val)} +} + +//LegStrikePriceField is a PRICE field +type LegStrikePriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegStrikePrice (612) +func (f LegStrikePriceField) Tag() quickfix.Tag { return tag.LegStrikePrice } + +//NewLegStrikePrice returns a new LegStrikePriceField initialized with val +func NewLegStrikePrice(val float64) LegStrikePriceField { + return LegStrikePriceField{quickfix.FIXFloat(val)} +} + +//LegSwapTypeField is a INT field +type LegSwapTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.LegSwapType (690) +func (f LegSwapTypeField) Tag() quickfix.Tag { return tag.LegSwapType } + +//NewLegSwapType returns a new LegSwapTypeField initialized with val +func NewLegSwapType(val int) LegSwapTypeField { + return LegSwapTypeField{quickfix.FIXInt(val)} +} + +//LegSymbolField is a STRING field +type LegSymbolField struct{ quickfix.FIXString } + +//Tag returns tag.LegSymbol (600) +func (f LegSymbolField) Tag() quickfix.Tag { return tag.LegSymbol } + +//NewLegSymbol returns a new LegSymbolField initialized with val +func NewLegSymbol(val string) LegSymbolField { + return LegSymbolField{quickfix.FIXString(val)} +} + +//LegSymbolSfxField is a STRING field +type LegSymbolSfxField struct{ quickfix.FIXString } + +//Tag returns tag.LegSymbolSfx (601) +func (f LegSymbolSfxField) Tag() quickfix.Tag { return tag.LegSymbolSfx } + +//NewLegSymbolSfx returns a new LegSymbolSfxField initialized with val +func NewLegSymbolSfx(val string) LegSymbolSfxField { + return LegSymbolSfxField{quickfix.FIXString(val)} +} + +//LegTimeUnitField is a STRING field +type LegTimeUnitField struct{ quickfix.FIXString } + +//Tag returns tag.LegTimeUnit (1001) +func (f LegTimeUnitField) Tag() quickfix.Tag { return tag.LegTimeUnit } + +//NewLegTimeUnit returns a new LegTimeUnitField initialized with val +func NewLegTimeUnit(val string) LegTimeUnitField { + return LegTimeUnitField{quickfix.FIXString(val)} +} + +//LegUnitOfMeasureField is a STRING field +type LegUnitOfMeasureField struct{ quickfix.FIXString } + +//Tag returns tag.LegUnitOfMeasure (999) +func (f LegUnitOfMeasureField) Tag() quickfix.Tag { return tag.LegUnitOfMeasure } + +//NewLegUnitOfMeasure returns a new LegUnitOfMeasureField initialized with val +func NewLegUnitOfMeasure(val string) LegUnitOfMeasureField { + return LegUnitOfMeasureField{quickfix.FIXString(val)} +} + +//LegUnitOfMeasureQtyField is a QTY field +type LegUnitOfMeasureQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegUnitOfMeasureQty (1224) +func (f LegUnitOfMeasureQtyField) Tag() quickfix.Tag { return tag.LegUnitOfMeasureQty } + +//NewLegUnitOfMeasureQty returns a new LegUnitOfMeasureQtyField initialized with val +func NewLegUnitOfMeasureQty(val float64) LegUnitOfMeasureQtyField { + return LegUnitOfMeasureQtyField{quickfix.FIXFloat(val)} +} + +//LegVolatilityField is a FLOAT field +type LegVolatilityField struct{ quickfix.FIXFloat } + +//Tag returns tag.LegVolatility (1379) +func (f LegVolatilityField) Tag() quickfix.Tag { return tag.LegVolatility } + +//NewLegVolatility returns a new LegVolatilityField initialized with val +func NewLegVolatility(val float64) LegVolatilityField { + return LegVolatilityField{quickfix.FIXFloat(val)} +} + +//LegalConfirmField is a BOOLEAN field +type LegalConfirmField struct{ quickfix.FIXBoolean } + +//Tag returns tag.LegalConfirm (650) +func (f LegalConfirmField) Tag() quickfix.Tag { return tag.LegalConfirm } + +//NewLegalConfirm returns a new LegalConfirmField initialized with val +func NewLegalConfirm(val bool) LegalConfirmField { + return LegalConfirmField{quickfix.FIXBoolean(val)} +} + +//LinesOfTextField is a NUMINGROUP field +type LinesOfTextField struct{ quickfix.FIXInt } + +//Tag returns tag.LinesOfText (33) +func (f LinesOfTextField) Tag() quickfix.Tag { return tag.LinesOfText } + +//NewLinesOfText returns a new LinesOfTextField initialized with val +func NewLinesOfText(val int) LinesOfTextField { + return LinesOfTextField{quickfix.FIXInt(val)} +} + +//LiquidityIndTypeField is a INT field +type LiquidityIndTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.LiquidityIndType (409) +func (f LiquidityIndTypeField) Tag() quickfix.Tag { return tag.LiquidityIndType } + +//NewLiquidityIndType returns a new LiquidityIndTypeField initialized with val +func NewLiquidityIndType(val int) LiquidityIndTypeField { + return LiquidityIndTypeField{quickfix.FIXInt(val)} +} + +//LiquidityNumSecuritiesField is a INT field +type LiquidityNumSecuritiesField struct{ quickfix.FIXInt } + +//Tag returns tag.LiquidityNumSecurities (441) +func (f LiquidityNumSecuritiesField) Tag() quickfix.Tag { return tag.LiquidityNumSecurities } + +//NewLiquidityNumSecurities returns a new LiquidityNumSecuritiesField initialized with val +func NewLiquidityNumSecurities(val int) LiquidityNumSecuritiesField { + return LiquidityNumSecuritiesField{quickfix.FIXInt(val)} +} + +//LiquidityPctHighField is a PERCENTAGE field +type LiquidityPctHighField struct{ quickfix.FIXFloat } + +//Tag returns tag.LiquidityPctHigh (403) +func (f LiquidityPctHighField) Tag() quickfix.Tag { return tag.LiquidityPctHigh } + +//NewLiquidityPctHigh returns a new LiquidityPctHighField initialized with val +func NewLiquidityPctHigh(val float64) LiquidityPctHighField { + return LiquidityPctHighField{quickfix.FIXFloat(val)} +} + +//LiquidityPctLowField is a PERCENTAGE field +type LiquidityPctLowField struct{ quickfix.FIXFloat } + +//Tag returns tag.LiquidityPctLow (402) +func (f LiquidityPctLowField) Tag() quickfix.Tag { return tag.LiquidityPctLow } + +//NewLiquidityPctLow returns a new LiquidityPctLowField initialized with val +func NewLiquidityPctLow(val float64) LiquidityPctLowField { + return LiquidityPctLowField{quickfix.FIXFloat(val)} +} + +//LiquidityValueField is a AMT field +type LiquidityValueField struct{ quickfix.FIXFloat } + +//Tag returns tag.LiquidityValue (404) +func (f LiquidityValueField) Tag() quickfix.Tag { return tag.LiquidityValue } + +//NewLiquidityValue returns a new LiquidityValueField initialized with val +func NewLiquidityValue(val float64) LiquidityValueField { + return LiquidityValueField{quickfix.FIXFloat(val)} +} + +//ListExecInstField is a STRING field +type ListExecInstField struct{ quickfix.FIXString } + +//Tag returns tag.ListExecInst (69) +func (f ListExecInstField) Tag() quickfix.Tag { return tag.ListExecInst } + +//NewListExecInst returns a new ListExecInstField initialized with val +func NewListExecInst(val string) ListExecInstField { + return ListExecInstField{quickfix.FIXString(val)} +} + +//ListExecInstTypeField is a CHAR field +type ListExecInstTypeField struct{ quickfix.FIXString } + +//Tag returns tag.ListExecInstType (433) +func (f ListExecInstTypeField) Tag() quickfix.Tag { return tag.ListExecInstType } + +//NewListExecInstType returns a new ListExecInstTypeField initialized with val +func NewListExecInstType(val string) ListExecInstTypeField { + return ListExecInstTypeField{quickfix.FIXString(val)} +} + +//ListIDField is a STRING field +type ListIDField struct{ quickfix.FIXString } + +//Tag returns tag.ListID (66) +func (f ListIDField) Tag() quickfix.Tag { return tag.ListID } + +//NewListID returns a new ListIDField initialized with val +func NewListID(val string) ListIDField { + return ListIDField{quickfix.FIXString(val)} +} + +//ListMethodField is a INT field +type ListMethodField struct{ quickfix.FIXInt } + +//Tag returns tag.ListMethod (1198) +func (f ListMethodField) Tag() quickfix.Tag { return tag.ListMethod } + +//NewListMethod returns a new ListMethodField initialized with val +func NewListMethod(val int) ListMethodField { + return ListMethodField{quickfix.FIXInt(val)} +} + +//ListNameField is a STRING field +type ListNameField struct{ quickfix.FIXString } + +//Tag returns tag.ListName (392) +func (f ListNameField) Tag() quickfix.Tag { return tag.ListName } + +//NewListName returns a new ListNameField initialized with val +func NewListName(val string) ListNameField { + return ListNameField{quickfix.FIXString(val)} +} + +//ListNoOrdsField is a INT field +type ListNoOrdsField struct{ quickfix.FIXInt } + +//Tag returns tag.ListNoOrds (68) +func (f ListNoOrdsField) Tag() quickfix.Tag { return tag.ListNoOrds } + +//NewListNoOrds returns a new ListNoOrdsField initialized with val +func NewListNoOrds(val int) ListNoOrdsField { + return ListNoOrdsField{quickfix.FIXInt(val)} +} + +//ListOrderStatusField is a INT field +type ListOrderStatusField struct{ quickfix.FIXInt } + +//Tag returns tag.ListOrderStatus (431) +func (f ListOrderStatusField) Tag() quickfix.Tag { return tag.ListOrderStatus } + +//NewListOrderStatus returns a new ListOrderStatusField initialized with val +func NewListOrderStatus(val int) ListOrderStatusField { + return ListOrderStatusField{quickfix.FIXInt(val)} +} + +//ListRejectReasonField is a INT field +type ListRejectReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.ListRejectReason (1386) +func (f ListRejectReasonField) Tag() quickfix.Tag { return tag.ListRejectReason } + +//NewListRejectReason returns a new ListRejectReasonField initialized with val +func NewListRejectReason(val int) ListRejectReasonField { + return ListRejectReasonField{quickfix.FIXInt(val)} +} + +//ListSeqNoField is a INT field +type ListSeqNoField struct{ quickfix.FIXInt } + +//Tag returns tag.ListSeqNo (67) +func (f ListSeqNoField) Tag() quickfix.Tag { return tag.ListSeqNo } + +//NewListSeqNo returns a new ListSeqNoField initialized with val +func NewListSeqNo(val int) ListSeqNoField { + return ListSeqNoField{quickfix.FIXInt(val)} +} + +//ListStatusTextField is a STRING field +type ListStatusTextField struct{ quickfix.FIXString } + +//Tag returns tag.ListStatusText (444) +func (f ListStatusTextField) Tag() quickfix.Tag { return tag.ListStatusText } + +//NewListStatusText returns a new ListStatusTextField initialized with val +func NewListStatusText(val string) ListStatusTextField { + return ListStatusTextField{quickfix.FIXString(val)} +} + +//ListStatusTypeField is a INT field +type ListStatusTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.ListStatusType (429) +func (f ListStatusTypeField) Tag() quickfix.Tag { return tag.ListStatusType } + +//NewListStatusType returns a new ListStatusTypeField initialized with val +func NewListStatusType(val int) ListStatusTypeField { + return ListStatusTypeField{quickfix.FIXInt(val)} +} + +//ListUpdateActionField is a CHAR field +type ListUpdateActionField struct{ quickfix.FIXString } + +//Tag returns tag.ListUpdateAction (1324) +func (f ListUpdateActionField) Tag() quickfix.Tag { return tag.ListUpdateAction } + +//NewListUpdateAction returns a new ListUpdateActionField initialized with val +func NewListUpdateAction(val string) ListUpdateActionField { + return ListUpdateActionField{quickfix.FIXString(val)} +} + +//LocaleOfIssueField is a STRING field +type LocaleOfIssueField struct{ quickfix.FIXString } + +//Tag returns tag.LocaleOfIssue (472) +func (f LocaleOfIssueField) Tag() quickfix.Tag { return tag.LocaleOfIssue } + +//NewLocaleOfIssue returns a new LocaleOfIssueField initialized with val +func NewLocaleOfIssue(val string) LocaleOfIssueField { + return LocaleOfIssueField{quickfix.FIXString(val)} +} + +//LocateReqdField is a BOOLEAN field +type LocateReqdField struct{ quickfix.FIXBoolean } + +//Tag returns tag.LocateReqd (114) +func (f LocateReqdField) Tag() quickfix.Tag { return tag.LocateReqd } + +//NewLocateReqd returns a new LocateReqdField initialized with val +func NewLocateReqd(val bool) LocateReqdField { + return LocateReqdField{quickfix.FIXBoolean(val)} +} + +//LocationIDField is a STRING field +type LocationIDField struct{ quickfix.FIXString } + +//Tag returns tag.LocationID (283) +func (f LocationIDField) Tag() quickfix.Tag { return tag.LocationID } + +//NewLocationID returns a new LocationIDField initialized with val +func NewLocationID(val string) LocationIDField { + return LocationIDField{quickfix.FIXString(val)} +} + +//LongQtyField is a QTY field +type LongQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.LongQty (704) +func (f LongQtyField) Tag() quickfix.Tag { return tag.LongQty } + +//NewLongQty returns a new LongQtyField initialized with val +func NewLongQty(val float64) LongQtyField { + return LongQtyField{quickfix.FIXFloat(val)} +} + +//LotTypeField is a CHAR field +type LotTypeField struct{ quickfix.FIXString } + +//Tag returns tag.LotType (1093) +func (f LotTypeField) Tag() quickfix.Tag { return tag.LotType } + +//NewLotType returns a new LotTypeField initialized with val +func NewLotType(val string) LotTypeField { + return LotTypeField{quickfix.FIXString(val)} +} + +//LowLimitPriceField is a PRICE field +type LowLimitPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.LowLimitPrice (1148) +func (f LowLimitPriceField) Tag() quickfix.Tag { return tag.LowLimitPrice } + +//NewLowLimitPrice returns a new LowLimitPriceField initialized with val +func NewLowLimitPrice(val float64) LowLimitPriceField { + return LowLimitPriceField{quickfix.FIXFloat(val)} +} + +//LowPxField is a PRICE field +type LowPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.LowPx (333) +func (f LowPxField) Tag() quickfix.Tag { return tag.LowPx } + +//NewLowPx returns a new LowPxField initialized with val +func NewLowPx(val float64) LowPxField { + return LowPxField{quickfix.FIXFloat(val)} +} + +//MDBookTypeField is a INT field +type MDBookTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.MDBookType (1021) +func (f MDBookTypeField) Tag() quickfix.Tag { return tag.MDBookType } + +//NewMDBookType returns a new MDBookTypeField initialized with val +func NewMDBookType(val int) MDBookTypeField { + return MDBookTypeField{quickfix.FIXInt(val)} +} + +//MDEntryBuyerField is a STRING field +type MDEntryBuyerField struct{ quickfix.FIXString } + +//Tag returns tag.MDEntryBuyer (288) +func (f MDEntryBuyerField) Tag() quickfix.Tag { return tag.MDEntryBuyer } + +//NewMDEntryBuyer returns a new MDEntryBuyerField initialized with val +func NewMDEntryBuyer(val string) MDEntryBuyerField { + return MDEntryBuyerField{quickfix.FIXString(val)} +} + +//MDEntryDateField is a UTCDATEONLY field +type MDEntryDateField struct{ quickfix.FIXString } + +//Tag returns tag.MDEntryDate (272) +func (f MDEntryDateField) Tag() quickfix.Tag { return tag.MDEntryDate } + +//NewMDEntryDate returns a new MDEntryDateField initialized with val +func NewMDEntryDate(val string) MDEntryDateField { + return MDEntryDateField{quickfix.FIXString(val)} +} + +//MDEntryForwardPointsField is a PRICEOFFSET field +type MDEntryForwardPointsField struct{ quickfix.FIXFloat } + +//Tag returns tag.MDEntryForwardPoints (1027) +func (f MDEntryForwardPointsField) Tag() quickfix.Tag { return tag.MDEntryForwardPoints } + +//NewMDEntryForwardPoints returns a new MDEntryForwardPointsField initialized with val +func NewMDEntryForwardPoints(val float64) MDEntryForwardPointsField { + return MDEntryForwardPointsField{quickfix.FIXFloat(val)} +} + +//MDEntryIDField is a STRING field +type MDEntryIDField struct{ quickfix.FIXString } + +//Tag returns tag.MDEntryID (278) +func (f MDEntryIDField) Tag() quickfix.Tag { return tag.MDEntryID } + +//NewMDEntryID returns a new MDEntryIDField initialized with val +func NewMDEntryID(val string) MDEntryIDField { + return MDEntryIDField{quickfix.FIXString(val)} +} + +//MDEntryOriginatorField is a STRING field +type MDEntryOriginatorField struct{ quickfix.FIXString } + +//Tag returns tag.MDEntryOriginator (282) +func (f MDEntryOriginatorField) Tag() quickfix.Tag { return tag.MDEntryOriginator } + +//NewMDEntryOriginator returns a new MDEntryOriginatorField initialized with val +func NewMDEntryOriginator(val string) MDEntryOriginatorField { + return MDEntryOriginatorField{quickfix.FIXString(val)} +} + +//MDEntryPositionNoField is a INT field +type MDEntryPositionNoField struct{ quickfix.FIXInt } + +//Tag returns tag.MDEntryPositionNo (290) +func (f MDEntryPositionNoField) Tag() quickfix.Tag { return tag.MDEntryPositionNo } + +//NewMDEntryPositionNo returns a new MDEntryPositionNoField initialized with val +func NewMDEntryPositionNo(val int) MDEntryPositionNoField { + return MDEntryPositionNoField{quickfix.FIXInt(val)} +} + +//MDEntryPxField is a PRICE field +type MDEntryPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.MDEntryPx (270) +func (f MDEntryPxField) Tag() quickfix.Tag { return tag.MDEntryPx } + +//NewMDEntryPx returns a new MDEntryPxField initialized with val +func NewMDEntryPx(val float64) MDEntryPxField { + return MDEntryPxField{quickfix.FIXFloat(val)} +} + +//MDEntryRefIDField is a STRING field +type MDEntryRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.MDEntryRefID (280) +func (f MDEntryRefIDField) Tag() quickfix.Tag { return tag.MDEntryRefID } + +//NewMDEntryRefID returns a new MDEntryRefIDField initialized with val +func NewMDEntryRefID(val string) MDEntryRefIDField { + return MDEntryRefIDField{quickfix.FIXString(val)} +} + +//MDEntrySellerField is a STRING field +type MDEntrySellerField struct{ quickfix.FIXString } + +//Tag returns tag.MDEntrySeller (289) +func (f MDEntrySellerField) Tag() quickfix.Tag { return tag.MDEntrySeller } + +//NewMDEntrySeller returns a new MDEntrySellerField initialized with val +func NewMDEntrySeller(val string) MDEntrySellerField { + return MDEntrySellerField{quickfix.FIXString(val)} +} + +//MDEntrySizeField is a QTY field +type MDEntrySizeField struct{ quickfix.FIXFloat } + +//Tag returns tag.MDEntrySize (271) +func (f MDEntrySizeField) Tag() quickfix.Tag { return tag.MDEntrySize } + +//NewMDEntrySize returns a new MDEntrySizeField initialized with val +func NewMDEntrySize(val float64) MDEntrySizeField { + return MDEntrySizeField{quickfix.FIXFloat(val)} +} + +//MDEntrySpotRateField is a FLOAT field +type MDEntrySpotRateField struct{ quickfix.FIXFloat } + +//Tag returns tag.MDEntrySpotRate (1026) +func (f MDEntrySpotRateField) Tag() quickfix.Tag { return tag.MDEntrySpotRate } + +//NewMDEntrySpotRate returns a new MDEntrySpotRateField initialized with val +func NewMDEntrySpotRate(val float64) MDEntrySpotRateField { + return MDEntrySpotRateField{quickfix.FIXFloat(val)} +} + +//MDEntryTimeField is a UTCTIMEONLY field +type MDEntryTimeField struct{ quickfix.FIXString } + +//Tag returns tag.MDEntryTime (273) +func (f MDEntryTimeField) Tag() quickfix.Tag { return tag.MDEntryTime } + +//NewMDEntryTime returns a new MDEntryTimeField initialized with val +func NewMDEntryTime(val string) MDEntryTimeField { + return MDEntryTimeField{quickfix.FIXString(val)} +} + +//MDEntryTypeField is a CHAR field +type MDEntryTypeField struct{ quickfix.FIXString } + +//Tag returns tag.MDEntryType (269) +func (f MDEntryTypeField) Tag() quickfix.Tag { return tag.MDEntryType } + +//NewMDEntryType returns a new MDEntryTypeField initialized with val +func NewMDEntryType(val string) MDEntryTypeField { + return MDEntryTypeField{quickfix.FIXString(val)} +} + +//MDFeedTypeField is a STRING field +type MDFeedTypeField struct{ quickfix.FIXString } + +//Tag returns tag.MDFeedType (1022) +func (f MDFeedTypeField) Tag() quickfix.Tag { return tag.MDFeedType } + +//NewMDFeedType returns a new MDFeedTypeField initialized with val +func NewMDFeedType(val string) MDFeedTypeField { + return MDFeedTypeField{quickfix.FIXString(val)} +} + +//MDImplicitDeleteField is a BOOLEAN field +type MDImplicitDeleteField struct{ quickfix.FIXBoolean } + +//Tag returns tag.MDImplicitDelete (547) +func (f MDImplicitDeleteField) Tag() quickfix.Tag { return tag.MDImplicitDelete } + +//NewMDImplicitDelete returns a new MDImplicitDeleteField initialized with val +func NewMDImplicitDelete(val bool) MDImplicitDeleteField { + return MDImplicitDeleteField{quickfix.FIXBoolean(val)} +} + +//MDMktField is a EXCHANGE field +type MDMktField struct{ quickfix.FIXString } + +//Tag returns tag.MDMkt (275) +func (f MDMktField) Tag() quickfix.Tag { return tag.MDMkt } + +//NewMDMkt returns a new MDMktField initialized with val +func NewMDMkt(val string) MDMktField { + return MDMktField{quickfix.FIXString(val)} +} + +//MDOriginTypeField is a INT field +type MDOriginTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.MDOriginType (1024) +func (f MDOriginTypeField) Tag() quickfix.Tag { return tag.MDOriginType } + +//NewMDOriginType returns a new MDOriginTypeField initialized with val +func NewMDOriginType(val int) MDOriginTypeField { + return MDOriginTypeField{quickfix.FIXInt(val)} +} + +//MDPriceLevelField is a INT field +type MDPriceLevelField struct{ quickfix.FIXInt } + +//Tag returns tag.MDPriceLevel (1023) +func (f MDPriceLevelField) Tag() quickfix.Tag { return tag.MDPriceLevel } + +//NewMDPriceLevel returns a new MDPriceLevelField initialized with val +func NewMDPriceLevel(val int) MDPriceLevelField { + return MDPriceLevelField{quickfix.FIXInt(val)} +} + +//MDQuoteTypeField is a INT field +type MDQuoteTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.MDQuoteType (1070) +func (f MDQuoteTypeField) Tag() quickfix.Tag { return tag.MDQuoteType } + +//NewMDQuoteType returns a new MDQuoteTypeField initialized with val +func NewMDQuoteType(val int) MDQuoteTypeField { + return MDQuoteTypeField{quickfix.FIXInt(val)} +} + +//MDReportIDField is a INT field +type MDReportIDField struct{ quickfix.FIXInt } + +//Tag returns tag.MDReportID (963) +func (f MDReportIDField) Tag() quickfix.Tag { return tag.MDReportID } + +//NewMDReportID returns a new MDReportIDField initialized with val +func NewMDReportID(val int) MDReportIDField { + return MDReportIDField{quickfix.FIXInt(val)} +} + +//MDReqIDField is a STRING field +type MDReqIDField struct{ quickfix.FIXString } + +//Tag returns tag.MDReqID (262) +func (f MDReqIDField) Tag() quickfix.Tag { return tag.MDReqID } + +//NewMDReqID returns a new MDReqIDField initialized with val +func NewMDReqID(val string) MDReqIDField { + return MDReqIDField{quickfix.FIXString(val)} +} + +//MDReqRejReasonField is a CHAR field +type MDReqRejReasonField struct{ quickfix.FIXString } + +//Tag returns tag.MDReqRejReason (281) +func (f MDReqRejReasonField) Tag() quickfix.Tag { return tag.MDReqRejReason } + +//NewMDReqRejReason returns a new MDReqRejReasonField initialized with val +func NewMDReqRejReason(val string) MDReqRejReasonField { + return MDReqRejReasonField{quickfix.FIXString(val)} +} + +//MDSecSizeField is a QTY field +type MDSecSizeField struct{ quickfix.FIXFloat } + +//Tag returns tag.MDSecSize (1179) +func (f MDSecSizeField) Tag() quickfix.Tag { return tag.MDSecSize } + +//NewMDSecSize returns a new MDSecSizeField initialized with val +func NewMDSecSize(val float64) MDSecSizeField { + return MDSecSizeField{quickfix.FIXFloat(val)} +} + +//MDSecSizeTypeField is a INT field +type MDSecSizeTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.MDSecSizeType (1178) +func (f MDSecSizeTypeField) Tag() quickfix.Tag { return tag.MDSecSizeType } + +//NewMDSecSizeType returns a new MDSecSizeTypeField initialized with val +func NewMDSecSizeType(val int) MDSecSizeTypeField { + return MDSecSizeTypeField{quickfix.FIXInt(val)} +} + +//MDStreamIDField is a STRING field +type MDStreamIDField struct{ quickfix.FIXString } + +//Tag returns tag.MDStreamID (1500) +func (f MDStreamIDField) Tag() quickfix.Tag { return tag.MDStreamID } + +//NewMDStreamID returns a new MDStreamIDField initialized with val +func NewMDStreamID(val string) MDStreamIDField { + return MDStreamIDField{quickfix.FIXString(val)} +} + +//MDSubBookTypeField is a INT field +type MDSubBookTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.MDSubBookType (1173) +func (f MDSubBookTypeField) Tag() quickfix.Tag { return tag.MDSubBookType } + +//NewMDSubBookType returns a new MDSubBookTypeField initialized with val +func NewMDSubBookType(val int) MDSubBookTypeField { + return MDSubBookTypeField{quickfix.FIXInt(val)} +} + +//MDUpdateActionField is a CHAR field +type MDUpdateActionField struct{ quickfix.FIXString } + +//Tag returns tag.MDUpdateAction (279) +func (f MDUpdateActionField) Tag() quickfix.Tag { return tag.MDUpdateAction } + +//NewMDUpdateAction returns a new MDUpdateActionField initialized with val +func NewMDUpdateAction(val string) MDUpdateActionField { + return MDUpdateActionField{quickfix.FIXString(val)} +} + +//MDUpdateTypeField is a INT field +type MDUpdateTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.MDUpdateType (265) +func (f MDUpdateTypeField) Tag() quickfix.Tag { return tag.MDUpdateType } + +//NewMDUpdateType returns a new MDUpdateTypeField initialized with val +func NewMDUpdateType(val int) MDUpdateTypeField { + return MDUpdateTypeField{quickfix.FIXInt(val)} +} + +//MailingDtlsField is a STRING field +type MailingDtlsField struct{ quickfix.FIXString } + +//Tag returns tag.MailingDtls (474) +func (f MailingDtlsField) Tag() quickfix.Tag { return tag.MailingDtls } + +//NewMailingDtls returns a new MailingDtlsField initialized with val +func NewMailingDtls(val string) MailingDtlsField { + return MailingDtlsField{quickfix.FIXString(val)} +} + +//MailingInstField is a STRING field +type MailingInstField struct{ quickfix.FIXString } + +//Tag returns tag.MailingInst (482) +func (f MailingInstField) Tag() quickfix.Tag { return tag.MailingInst } + +//NewMailingInst returns a new MailingInstField initialized with val +func NewMailingInst(val string) MailingInstField { + return MailingInstField{quickfix.FIXString(val)} +} + +//ManualOrderIndicatorField is a BOOLEAN field +type ManualOrderIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.ManualOrderIndicator (1028) +func (f ManualOrderIndicatorField) Tag() quickfix.Tag { return tag.ManualOrderIndicator } + +//NewManualOrderIndicator returns a new ManualOrderIndicatorField initialized with val +func NewManualOrderIndicator(val bool) ManualOrderIndicatorField { + return ManualOrderIndicatorField{quickfix.FIXBoolean(val)} +} + +//MarginExcessField is a AMT field +type MarginExcessField struct{ quickfix.FIXFloat } + +//Tag returns tag.MarginExcess (899) +func (f MarginExcessField) Tag() quickfix.Tag { return tag.MarginExcess } + +//NewMarginExcess returns a new MarginExcessField initialized with val +func NewMarginExcess(val float64) MarginExcessField { + return MarginExcessField{quickfix.FIXFloat(val)} +} + +//MarginRatioField is a PERCENTAGE field +type MarginRatioField struct{ quickfix.FIXFloat } + +//Tag returns tag.MarginRatio (898) +func (f MarginRatioField) Tag() quickfix.Tag { return tag.MarginRatio } + +//NewMarginRatio returns a new MarginRatioField initialized with val +func NewMarginRatio(val float64) MarginRatioField { + return MarginRatioField{quickfix.FIXFloat(val)} +} + +//MarketDepthField is a INT field +type MarketDepthField struct{ quickfix.FIXInt } + +//Tag returns tag.MarketDepth (264) +func (f MarketDepthField) Tag() quickfix.Tag { return tag.MarketDepth } + +//NewMarketDepth returns a new MarketDepthField initialized with val +func NewMarketDepth(val int) MarketDepthField { + return MarketDepthField{quickfix.FIXInt(val)} +} + +//MarketIDField is a EXCHANGE field +type MarketIDField struct{ quickfix.FIXString } + +//Tag returns tag.MarketID (1301) +func (f MarketIDField) Tag() quickfix.Tag { return tag.MarketID } + +//NewMarketID returns a new MarketIDField initialized with val +func NewMarketID(val string) MarketIDField { + return MarketIDField{quickfix.FIXString(val)} +} + +//MarketReportIDField is a STRING field +type MarketReportIDField struct{ quickfix.FIXString } + +//Tag returns tag.MarketReportID (1394) +func (f MarketReportIDField) Tag() quickfix.Tag { return tag.MarketReportID } + +//NewMarketReportID returns a new MarketReportIDField initialized with val +func NewMarketReportID(val string) MarketReportIDField { + return MarketReportIDField{quickfix.FIXString(val)} +} + +//MarketReqIDField is a STRING field +type MarketReqIDField struct{ quickfix.FIXString } + +//Tag returns tag.MarketReqID (1393) +func (f MarketReqIDField) Tag() quickfix.Tag { return tag.MarketReqID } + +//NewMarketReqID returns a new MarketReqIDField initialized with val +func NewMarketReqID(val string) MarketReqIDField { + return MarketReqIDField{quickfix.FIXString(val)} +} + +//MarketSegmentDescField is a STRING field +type MarketSegmentDescField struct{ quickfix.FIXString } + +//Tag returns tag.MarketSegmentDesc (1396) +func (f MarketSegmentDescField) Tag() quickfix.Tag { return tag.MarketSegmentDesc } + +//NewMarketSegmentDesc returns a new MarketSegmentDescField initialized with val +func NewMarketSegmentDesc(val string) MarketSegmentDescField { + return MarketSegmentDescField{quickfix.FIXString(val)} +} + +//MarketSegmentIDField is a STRING field +type MarketSegmentIDField struct{ quickfix.FIXString } + +//Tag returns tag.MarketSegmentID (1300) +func (f MarketSegmentIDField) Tag() quickfix.Tag { return tag.MarketSegmentID } + +//NewMarketSegmentID returns a new MarketSegmentIDField initialized with val +func NewMarketSegmentID(val string) MarketSegmentIDField { + return MarketSegmentIDField{quickfix.FIXString(val)} +} + +//MarketUpdateActionField is a CHAR field +type MarketUpdateActionField struct{ quickfix.FIXString } + +//Tag returns tag.MarketUpdateAction (1395) +func (f MarketUpdateActionField) Tag() quickfix.Tag { return tag.MarketUpdateAction } + +//NewMarketUpdateAction returns a new MarketUpdateActionField initialized with val +func NewMarketUpdateAction(val string) MarketUpdateActionField { + return MarketUpdateActionField{quickfix.FIXString(val)} +} + +//MassActionRejectReasonField is a INT field +type MassActionRejectReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.MassActionRejectReason (1376) +func (f MassActionRejectReasonField) Tag() quickfix.Tag { return tag.MassActionRejectReason } + +//NewMassActionRejectReason returns a new MassActionRejectReasonField initialized with val +func NewMassActionRejectReason(val int) MassActionRejectReasonField { + return MassActionRejectReasonField{quickfix.FIXInt(val)} +} + +//MassActionReportIDField is a STRING field +type MassActionReportIDField struct{ quickfix.FIXString } + +//Tag returns tag.MassActionReportID (1369) +func (f MassActionReportIDField) Tag() quickfix.Tag { return tag.MassActionReportID } + +//NewMassActionReportID returns a new MassActionReportIDField initialized with val +func NewMassActionReportID(val string) MassActionReportIDField { + return MassActionReportIDField{quickfix.FIXString(val)} +} + +//MassActionResponseField is a INT field +type MassActionResponseField struct{ quickfix.FIXInt } + +//Tag returns tag.MassActionResponse (1375) +func (f MassActionResponseField) Tag() quickfix.Tag { return tag.MassActionResponse } + +//NewMassActionResponse returns a new MassActionResponseField initialized with val +func NewMassActionResponse(val int) MassActionResponseField { + return MassActionResponseField{quickfix.FIXInt(val)} +} + +//MassActionScopeField is a INT field +type MassActionScopeField struct{ quickfix.FIXInt } + +//Tag returns tag.MassActionScope (1374) +func (f MassActionScopeField) Tag() quickfix.Tag { return tag.MassActionScope } + +//NewMassActionScope returns a new MassActionScopeField initialized with val +func NewMassActionScope(val int) MassActionScopeField { + return MassActionScopeField{quickfix.FIXInt(val)} +} + +//MassActionTypeField is a INT field +type MassActionTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.MassActionType (1373) +func (f MassActionTypeField) Tag() quickfix.Tag { return tag.MassActionType } + +//NewMassActionType returns a new MassActionTypeField initialized with val +func NewMassActionType(val int) MassActionTypeField { + return MassActionTypeField{quickfix.FIXInt(val)} +} + +//MassCancelRejectReasonField is a INT field +type MassCancelRejectReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.MassCancelRejectReason (532) +func (f MassCancelRejectReasonField) Tag() quickfix.Tag { return tag.MassCancelRejectReason } + +//NewMassCancelRejectReason returns a new MassCancelRejectReasonField initialized with val +func NewMassCancelRejectReason(val int) MassCancelRejectReasonField { + return MassCancelRejectReasonField{quickfix.FIXInt(val)} +} + +//MassCancelRequestTypeField is a CHAR field +type MassCancelRequestTypeField struct{ quickfix.FIXString } + +//Tag returns tag.MassCancelRequestType (530) +func (f MassCancelRequestTypeField) Tag() quickfix.Tag { return tag.MassCancelRequestType } + +//NewMassCancelRequestType returns a new MassCancelRequestTypeField initialized with val +func NewMassCancelRequestType(val string) MassCancelRequestTypeField { + return MassCancelRequestTypeField{quickfix.FIXString(val)} +} + +//MassCancelResponseField is a CHAR field +type MassCancelResponseField struct{ quickfix.FIXString } + +//Tag returns tag.MassCancelResponse (531) +func (f MassCancelResponseField) Tag() quickfix.Tag { return tag.MassCancelResponse } + +//NewMassCancelResponse returns a new MassCancelResponseField initialized with val +func NewMassCancelResponse(val string) MassCancelResponseField { + return MassCancelResponseField{quickfix.FIXString(val)} +} + +//MassStatusReqIDField is a STRING field +type MassStatusReqIDField struct{ quickfix.FIXString } + +//Tag returns tag.MassStatusReqID (584) +func (f MassStatusReqIDField) Tag() quickfix.Tag { return tag.MassStatusReqID } + +//NewMassStatusReqID returns a new MassStatusReqIDField initialized with val +func NewMassStatusReqID(val string) MassStatusReqIDField { + return MassStatusReqIDField{quickfix.FIXString(val)} +} + +//MassStatusReqTypeField is a INT field +type MassStatusReqTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.MassStatusReqType (585) +func (f MassStatusReqTypeField) Tag() quickfix.Tag { return tag.MassStatusReqType } + +//NewMassStatusReqType returns a new MassStatusReqTypeField initialized with val +func NewMassStatusReqType(val int) MassStatusReqTypeField { + return MassStatusReqTypeField{quickfix.FIXInt(val)} +} + +//MatchAlgorithmField is a STRING field +type MatchAlgorithmField struct{ quickfix.FIXString } + +//Tag returns tag.MatchAlgorithm (1142) +func (f MatchAlgorithmField) Tag() quickfix.Tag { return tag.MatchAlgorithm } + +//NewMatchAlgorithm returns a new MatchAlgorithmField initialized with val +func NewMatchAlgorithm(val string) MatchAlgorithmField { + return MatchAlgorithmField{quickfix.FIXString(val)} +} + +//MatchIncrementField is a QTY field +type MatchIncrementField struct{ quickfix.FIXFloat } + +//Tag returns tag.MatchIncrement (1089) +func (f MatchIncrementField) Tag() quickfix.Tag { return tag.MatchIncrement } + +//NewMatchIncrement returns a new MatchIncrementField initialized with val +func NewMatchIncrement(val float64) MatchIncrementField { + return MatchIncrementField{quickfix.FIXFloat(val)} +} + +//MatchStatusField is a CHAR field +type MatchStatusField struct{ quickfix.FIXString } + +//Tag returns tag.MatchStatus (573) +func (f MatchStatusField) Tag() quickfix.Tag { return tag.MatchStatus } + +//NewMatchStatus returns a new MatchStatusField initialized with val +func NewMatchStatus(val string) MatchStatusField { + return MatchStatusField{quickfix.FIXString(val)} +} + +//MatchTypeField is a STRING field +type MatchTypeField struct{ quickfix.FIXString } + +//Tag returns tag.MatchType (574) +func (f MatchTypeField) Tag() quickfix.Tag { return tag.MatchType } + +//NewMatchType returns a new MatchTypeField initialized with val +func NewMatchType(val string) MatchTypeField { + return MatchTypeField{quickfix.FIXString(val)} +} + +//MaturityDateField is a LOCALMKTDATE field +type MaturityDateField struct{ quickfix.FIXString } + +//Tag returns tag.MaturityDate (541) +func (f MaturityDateField) Tag() quickfix.Tag { return tag.MaturityDate } + +//NewMaturityDate returns a new MaturityDateField initialized with val +func NewMaturityDate(val string) MaturityDateField { + return MaturityDateField{quickfix.FIXString(val)} +} + +//MaturityDayField is a DAYOFMONTH field +type MaturityDayField struct{ quickfix.FIXInt } + +//Tag returns tag.MaturityDay (205) +func (f MaturityDayField) Tag() quickfix.Tag { return tag.MaturityDay } + +//NewMaturityDay returns a new MaturityDayField initialized with val +func NewMaturityDay(val int) MaturityDayField { + return MaturityDayField{quickfix.FIXInt(val)} +} + +//MaturityMonthYearField is a MONTHYEAR field +type MaturityMonthYearField struct{ quickfix.FIXString } + +//Tag returns tag.MaturityMonthYear (200) +func (f MaturityMonthYearField) Tag() quickfix.Tag { return tag.MaturityMonthYear } + +//NewMaturityMonthYear returns a new MaturityMonthYearField initialized with val +func NewMaturityMonthYear(val string) MaturityMonthYearField { + return MaturityMonthYearField{quickfix.FIXString(val)} +} + +//MaturityMonthYearFormatField is a INT field +type MaturityMonthYearFormatField struct{ quickfix.FIXInt } + +//Tag returns tag.MaturityMonthYearFormat (1303) +func (f MaturityMonthYearFormatField) Tag() quickfix.Tag { return tag.MaturityMonthYearFormat } + +//NewMaturityMonthYearFormat returns a new MaturityMonthYearFormatField initialized with val +func NewMaturityMonthYearFormat(val int) MaturityMonthYearFormatField { + return MaturityMonthYearFormatField{quickfix.FIXInt(val)} +} + +//MaturityMonthYearIncrementField is a INT field +type MaturityMonthYearIncrementField struct{ quickfix.FIXInt } + +//Tag returns tag.MaturityMonthYearIncrement (1229) +func (f MaturityMonthYearIncrementField) Tag() quickfix.Tag { return tag.MaturityMonthYearIncrement } + +//NewMaturityMonthYearIncrement returns a new MaturityMonthYearIncrementField initialized with val +func NewMaturityMonthYearIncrement(val int) MaturityMonthYearIncrementField { + return MaturityMonthYearIncrementField{quickfix.FIXInt(val)} +} + +//MaturityMonthYearIncrementUnitsField is a INT field +type MaturityMonthYearIncrementUnitsField struct{ quickfix.FIXInt } + +//Tag returns tag.MaturityMonthYearIncrementUnits (1302) +func (f MaturityMonthYearIncrementUnitsField) Tag() quickfix.Tag { + return tag.MaturityMonthYearIncrementUnits +} + +//NewMaturityMonthYearIncrementUnits returns a new MaturityMonthYearIncrementUnitsField initialized with val +func NewMaturityMonthYearIncrementUnits(val int) MaturityMonthYearIncrementUnitsField { + return MaturityMonthYearIncrementUnitsField{quickfix.FIXInt(val)} +} + +//MaturityNetMoneyField is a AMT field +type MaturityNetMoneyField struct{ quickfix.FIXFloat } + +//Tag returns tag.MaturityNetMoney (890) +func (f MaturityNetMoneyField) Tag() quickfix.Tag { return tag.MaturityNetMoney } + +//NewMaturityNetMoney returns a new MaturityNetMoneyField initialized with val +func NewMaturityNetMoney(val float64) MaturityNetMoneyField { + return MaturityNetMoneyField{quickfix.FIXFloat(val)} +} + +//MaturityRuleIDField is a STRING field +type MaturityRuleIDField struct{ quickfix.FIXString } + +//Tag returns tag.MaturityRuleID (1222) +func (f MaturityRuleIDField) Tag() quickfix.Tag { return tag.MaturityRuleID } + +//NewMaturityRuleID returns a new MaturityRuleIDField initialized with val +func NewMaturityRuleID(val string) MaturityRuleIDField { + return MaturityRuleIDField{quickfix.FIXString(val)} +} + +//MaturityTimeField is a TZTIMEONLY field +type MaturityTimeField struct{ quickfix.FIXString } + +//Tag returns tag.MaturityTime (1079) +func (f MaturityTimeField) Tag() quickfix.Tag { return tag.MaturityTime } + +//NewMaturityTime returns a new MaturityTimeField initialized with val +func NewMaturityTime(val string) MaturityTimeField { + return MaturityTimeField{quickfix.FIXString(val)} +} + +//MaxFloorField is a QTY field +type MaxFloorField struct{ quickfix.FIXFloat } + +//Tag returns tag.MaxFloor (111) +func (f MaxFloorField) Tag() quickfix.Tag { return tag.MaxFloor } + +//NewMaxFloor returns a new MaxFloorField initialized with val +func NewMaxFloor(val float64) MaxFloorField { + return MaxFloorField{quickfix.FIXFloat(val)} +} + +//MaxMessageSizeField is a LENGTH field +type MaxMessageSizeField struct{ quickfix.FIXInt } + +//Tag returns tag.MaxMessageSize (383) +func (f MaxMessageSizeField) Tag() quickfix.Tag { return tag.MaxMessageSize } + +//NewMaxMessageSize returns a new MaxMessageSizeField initialized with val +func NewMaxMessageSize(val int) MaxMessageSizeField { + return MaxMessageSizeField{quickfix.FIXInt(val)} +} + +//MaxPriceLevelsField is a INT field +type MaxPriceLevelsField struct{ quickfix.FIXInt } + +//Tag returns tag.MaxPriceLevels (1090) +func (f MaxPriceLevelsField) Tag() quickfix.Tag { return tag.MaxPriceLevels } + +//NewMaxPriceLevels returns a new MaxPriceLevelsField initialized with val +func NewMaxPriceLevels(val int) MaxPriceLevelsField { + return MaxPriceLevelsField{quickfix.FIXInt(val)} +} + +//MaxPriceVariationField is a FLOAT field +type MaxPriceVariationField struct{ quickfix.FIXFloat } + +//Tag returns tag.MaxPriceVariation (1143) +func (f MaxPriceVariationField) Tag() quickfix.Tag { return tag.MaxPriceVariation } + +//NewMaxPriceVariation returns a new MaxPriceVariationField initialized with val +func NewMaxPriceVariation(val float64) MaxPriceVariationField { + return MaxPriceVariationField{quickfix.FIXFloat(val)} +} + +//MaxShowField is a QTY field +type MaxShowField struct{ quickfix.FIXFloat } + +//Tag returns tag.MaxShow (210) +func (f MaxShowField) Tag() quickfix.Tag { return tag.MaxShow } + +//NewMaxShow returns a new MaxShowField initialized with val +func NewMaxShow(val float64) MaxShowField { + return MaxShowField{quickfix.FIXFloat(val)} +} + +//MaxTradeVolField is a QTY field +type MaxTradeVolField struct{ quickfix.FIXFloat } + +//Tag returns tag.MaxTradeVol (1140) +func (f MaxTradeVolField) Tag() quickfix.Tag { return tag.MaxTradeVol } + +//NewMaxTradeVol returns a new MaxTradeVolField initialized with val +func NewMaxTradeVol(val float64) MaxTradeVolField { + return MaxTradeVolField{quickfix.FIXFloat(val)} +} + +//MessageEncodingField is a STRING field +type MessageEncodingField struct{ quickfix.FIXString } + +//Tag returns tag.MessageEncoding (347) +func (f MessageEncodingField) Tag() quickfix.Tag { return tag.MessageEncoding } + +//NewMessageEncoding returns a new MessageEncodingField initialized with val +func NewMessageEncoding(val string) MessageEncodingField { + return MessageEncodingField{quickfix.FIXString(val)} +} + +//MessageEventSourceField is a STRING field +type MessageEventSourceField struct{ quickfix.FIXString } + +//Tag returns tag.MessageEventSource (1011) +func (f MessageEventSourceField) Tag() quickfix.Tag { return tag.MessageEventSource } + +//NewMessageEventSource returns a new MessageEventSourceField initialized with val +func NewMessageEventSource(val string) MessageEventSourceField { + return MessageEventSourceField{quickfix.FIXString(val)} +} + +//MidPxField is a PRICE field +type MidPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.MidPx (631) +func (f MidPxField) Tag() quickfix.Tag { return tag.MidPx } + +//NewMidPx returns a new MidPxField initialized with val +func NewMidPx(val float64) MidPxField { + return MidPxField{quickfix.FIXFloat(val)} +} + +//MidYieldField is a PERCENTAGE field +type MidYieldField struct{ quickfix.FIXFloat } + +//Tag returns tag.MidYield (633) +func (f MidYieldField) Tag() quickfix.Tag { return tag.MidYield } + +//NewMidYield returns a new MidYieldField initialized with val +func NewMidYield(val float64) MidYieldField { + return MidYieldField{quickfix.FIXFloat(val)} +} + +//MinBidSizeField is a QTY field +type MinBidSizeField struct{ quickfix.FIXFloat } + +//Tag returns tag.MinBidSize (647) +func (f MinBidSizeField) Tag() quickfix.Tag { return tag.MinBidSize } + +//NewMinBidSize returns a new MinBidSizeField initialized with val +func NewMinBidSize(val float64) MinBidSizeField { + return MinBidSizeField{quickfix.FIXFloat(val)} +} + +//MinLotSizeField is a QTY field +type MinLotSizeField struct{ quickfix.FIXFloat } + +//Tag returns tag.MinLotSize (1231) +func (f MinLotSizeField) Tag() quickfix.Tag { return tag.MinLotSize } + +//NewMinLotSize returns a new MinLotSizeField initialized with val +func NewMinLotSize(val float64) MinLotSizeField { + return MinLotSizeField{quickfix.FIXFloat(val)} +} + +//MinOfferSizeField is a QTY field +type MinOfferSizeField struct{ quickfix.FIXFloat } + +//Tag returns tag.MinOfferSize (648) +func (f MinOfferSizeField) Tag() quickfix.Tag { return tag.MinOfferSize } + +//NewMinOfferSize returns a new MinOfferSizeField initialized with val +func NewMinOfferSize(val float64) MinOfferSizeField { + return MinOfferSizeField{quickfix.FIXFloat(val)} +} + +//MinPriceIncrementField is a FLOAT field +type MinPriceIncrementField struct{ quickfix.FIXFloat } + +//Tag returns tag.MinPriceIncrement (969) +func (f MinPriceIncrementField) Tag() quickfix.Tag { return tag.MinPriceIncrement } + +//NewMinPriceIncrement returns a new MinPriceIncrementField initialized with val +func NewMinPriceIncrement(val float64) MinPriceIncrementField { + return MinPriceIncrementField{quickfix.FIXFloat(val)} +} + +//MinPriceIncrementAmountField is a AMT field +type MinPriceIncrementAmountField struct{ quickfix.FIXFloat } + +//Tag returns tag.MinPriceIncrementAmount (1146) +func (f MinPriceIncrementAmountField) Tag() quickfix.Tag { return tag.MinPriceIncrementAmount } + +//NewMinPriceIncrementAmount returns a new MinPriceIncrementAmountField initialized with val +func NewMinPriceIncrementAmount(val float64) MinPriceIncrementAmountField { + return MinPriceIncrementAmountField{quickfix.FIXFloat(val)} +} + +//MinQtyField is a QTY field +type MinQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.MinQty (110) +func (f MinQtyField) Tag() quickfix.Tag { return tag.MinQty } + +//NewMinQty returns a new MinQtyField initialized with val +func NewMinQty(val float64) MinQtyField { + return MinQtyField{quickfix.FIXFloat(val)} +} + +//MinTradeVolField is a QTY field +type MinTradeVolField struct{ quickfix.FIXFloat } + +//Tag returns tag.MinTradeVol (562) +func (f MinTradeVolField) Tag() quickfix.Tag { return tag.MinTradeVol } + +//NewMinTradeVol returns a new MinTradeVolField initialized with val +func NewMinTradeVol(val float64) MinTradeVolField { + return MinTradeVolField{quickfix.FIXFloat(val)} +} + +//MiscFeeAmtField is a AMT field +type MiscFeeAmtField struct{ quickfix.FIXFloat } + +//Tag returns tag.MiscFeeAmt (137) +func (f MiscFeeAmtField) Tag() quickfix.Tag { return tag.MiscFeeAmt } + +//NewMiscFeeAmt returns a new MiscFeeAmtField initialized with val +func NewMiscFeeAmt(val float64) MiscFeeAmtField { + return MiscFeeAmtField{quickfix.FIXFloat(val)} +} + +//MiscFeeBasisField is a INT field +type MiscFeeBasisField struct{ quickfix.FIXInt } + +//Tag returns tag.MiscFeeBasis (891) +func (f MiscFeeBasisField) Tag() quickfix.Tag { return tag.MiscFeeBasis } + +//NewMiscFeeBasis returns a new MiscFeeBasisField initialized with val +func NewMiscFeeBasis(val int) MiscFeeBasisField { + return MiscFeeBasisField{quickfix.FIXInt(val)} +} + +//MiscFeeCurrField is a CURRENCY field +type MiscFeeCurrField struct{ quickfix.FIXString } + +//Tag returns tag.MiscFeeCurr (138) +func (f MiscFeeCurrField) Tag() quickfix.Tag { return tag.MiscFeeCurr } + +//NewMiscFeeCurr returns a new MiscFeeCurrField initialized with val +func NewMiscFeeCurr(val string) MiscFeeCurrField { + return MiscFeeCurrField{quickfix.FIXString(val)} +} + +//MiscFeeTypeField is a STRING field +type MiscFeeTypeField struct{ quickfix.FIXString } + +//Tag returns tag.MiscFeeType (139) +func (f MiscFeeTypeField) Tag() quickfix.Tag { return tag.MiscFeeType } + +//NewMiscFeeType returns a new MiscFeeTypeField initialized with val +func NewMiscFeeType(val string) MiscFeeTypeField { + return MiscFeeTypeField{quickfix.FIXString(val)} +} + +//MktBidPxField is a PRICE field +type MktBidPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.MktBidPx (645) +func (f MktBidPxField) Tag() quickfix.Tag { return tag.MktBidPx } + +//NewMktBidPx returns a new MktBidPxField initialized with val +func NewMktBidPx(val float64) MktBidPxField { + return MktBidPxField{quickfix.FIXFloat(val)} +} + +//MktOfferPxField is a PRICE field +type MktOfferPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.MktOfferPx (646) +func (f MktOfferPxField) Tag() quickfix.Tag { return tag.MktOfferPx } + +//NewMktOfferPx returns a new MktOfferPxField initialized with val +func NewMktOfferPx(val float64) MktOfferPxField { + return MktOfferPxField{quickfix.FIXFloat(val)} +} + +//ModelTypeField is a INT field +type ModelTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.ModelType (1434) +func (f ModelTypeField) Tag() quickfix.Tag { return tag.ModelType } + +//NewModelType returns a new ModelTypeField initialized with val +func NewModelType(val int) ModelTypeField { + return ModelTypeField{quickfix.FIXInt(val)} +} + +//MoneyLaunderingStatusField is a CHAR field +type MoneyLaunderingStatusField struct{ quickfix.FIXString } + +//Tag returns tag.MoneyLaunderingStatus (481) +func (f MoneyLaunderingStatusField) Tag() quickfix.Tag { return tag.MoneyLaunderingStatus } + +//NewMoneyLaunderingStatus returns a new MoneyLaunderingStatusField initialized with val +func NewMoneyLaunderingStatus(val string) MoneyLaunderingStatusField { + return MoneyLaunderingStatusField{quickfix.FIXString(val)} +} + +//MsgDirectionField is a CHAR field +type MsgDirectionField struct{ quickfix.FIXString } + +//Tag returns tag.MsgDirection (385) +func (f MsgDirectionField) Tag() quickfix.Tag { return tag.MsgDirection } + +//NewMsgDirection returns a new MsgDirectionField initialized with val +func NewMsgDirection(val string) MsgDirectionField { + return MsgDirectionField{quickfix.FIXString(val)} +} + +//MsgSeqNumField is a SEQNUM field +type MsgSeqNumField struct{ quickfix.FIXInt } + +//Tag returns tag.MsgSeqNum (34) +func (f MsgSeqNumField) Tag() quickfix.Tag { return tag.MsgSeqNum } + +//NewMsgSeqNum returns a new MsgSeqNumField initialized with val +func NewMsgSeqNum(val int) MsgSeqNumField { + return MsgSeqNumField{quickfix.FIXInt(val)} +} + +//MsgTypeField is a STRING field +type MsgTypeField struct{ quickfix.FIXString } + +//Tag returns tag.MsgType (35) +func (f MsgTypeField) Tag() quickfix.Tag { return tag.MsgType } + +//NewMsgType returns a new MsgTypeField initialized with val +func NewMsgType(val string) MsgTypeField { + return MsgTypeField{quickfix.FIXString(val)} +} + +//MultiLegReportingTypeField is a CHAR field +type MultiLegReportingTypeField struct{ quickfix.FIXString } + +//Tag returns tag.MultiLegReportingType (442) +func (f MultiLegReportingTypeField) Tag() quickfix.Tag { return tag.MultiLegReportingType } + +//NewMultiLegReportingType returns a new MultiLegReportingTypeField initialized with val +func NewMultiLegReportingType(val string) MultiLegReportingTypeField { + return MultiLegReportingTypeField{quickfix.FIXString(val)} +} + +//MultiLegRptTypeReqField is a INT field +type MultiLegRptTypeReqField struct{ quickfix.FIXInt } + +//Tag returns tag.MultiLegRptTypeReq (563) +func (f MultiLegRptTypeReqField) Tag() quickfix.Tag { return tag.MultiLegRptTypeReq } + +//NewMultiLegRptTypeReq returns a new MultiLegRptTypeReqField initialized with val +func NewMultiLegRptTypeReq(val int) MultiLegRptTypeReqField { + return MultiLegRptTypeReqField{quickfix.FIXInt(val)} +} + +//MultilegModelField is a INT field +type MultilegModelField struct{ quickfix.FIXInt } + +//Tag returns tag.MultilegModel (1377) +func (f MultilegModelField) Tag() quickfix.Tag { return tag.MultilegModel } + +//NewMultilegModel returns a new MultilegModelField initialized with val +func NewMultilegModel(val int) MultilegModelField { + return MultilegModelField{quickfix.FIXInt(val)} +} + +//MultilegPriceMethodField is a INT field +type MultilegPriceMethodField struct{ quickfix.FIXInt } + +//Tag returns tag.MultilegPriceMethod (1378) +func (f MultilegPriceMethodField) Tag() quickfix.Tag { return tag.MultilegPriceMethod } + +//NewMultilegPriceMethod returns a new MultilegPriceMethodField initialized with val +func NewMultilegPriceMethod(val int) MultilegPriceMethodField { + return MultilegPriceMethodField{quickfix.FIXInt(val)} +} + +//NTPositionLimitField is a INT field +type NTPositionLimitField struct{ quickfix.FIXInt } + +//Tag returns tag.NTPositionLimit (971) +func (f NTPositionLimitField) Tag() quickfix.Tag { return tag.NTPositionLimit } + +//NewNTPositionLimit returns a new NTPositionLimitField initialized with val +func NewNTPositionLimit(val int) NTPositionLimitField { + return NTPositionLimitField{quickfix.FIXInt(val)} +} + +//Nested2PartyIDField is a STRING field +type Nested2PartyIDField struct{ quickfix.FIXString } + +//Tag returns tag.Nested2PartyID (757) +func (f Nested2PartyIDField) Tag() quickfix.Tag { return tag.Nested2PartyID } + +//NewNested2PartyID returns a new Nested2PartyIDField initialized with val +func NewNested2PartyID(val string) Nested2PartyIDField { + return Nested2PartyIDField{quickfix.FIXString(val)} +} + +//Nested2PartyIDSourceField is a CHAR field +type Nested2PartyIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.Nested2PartyIDSource (758) +func (f Nested2PartyIDSourceField) Tag() quickfix.Tag { return tag.Nested2PartyIDSource } + +//NewNested2PartyIDSource returns a new Nested2PartyIDSourceField initialized with val +func NewNested2PartyIDSource(val string) Nested2PartyIDSourceField { + return Nested2PartyIDSourceField{quickfix.FIXString(val)} +} + +//Nested2PartyRoleField is a INT field +type Nested2PartyRoleField struct{ quickfix.FIXInt } + +//Tag returns tag.Nested2PartyRole (759) +func (f Nested2PartyRoleField) Tag() quickfix.Tag { return tag.Nested2PartyRole } + +//NewNested2PartyRole returns a new Nested2PartyRoleField initialized with val +func NewNested2PartyRole(val int) Nested2PartyRoleField { + return Nested2PartyRoleField{quickfix.FIXInt(val)} +} + +//Nested2PartySubIDField is a STRING field +type Nested2PartySubIDField struct{ quickfix.FIXString } + +//Tag returns tag.Nested2PartySubID (760) +func (f Nested2PartySubIDField) Tag() quickfix.Tag { return tag.Nested2PartySubID } + +//NewNested2PartySubID returns a new Nested2PartySubIDField initialized with val +func NewNested2PartySubID(val string) Nested2PartySubIDField { + return Nested2PartySubIDField{quickfix.FIXString(val)} +} + +//Nested2PartySubIDTypeField is a INT field +type Nested2PartySubIDTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.Nested2PartySubIDType (807) +func (f Nested2PartySubIDTypeField) Tag() quickfix.Tag { return tag.Nested2PartySubIDType } + +//NewNested2PartySubIDType returns a new Nested2PartySubIDTypeField initialized with val +func NewNested2PartySubIDType(val int) Nested2PartySubIDTypeField { + return Nested2PartySubIDTypeField{quickfix.FIXInt(val)} +} + +//Nested3PartyIDField is a STRING field +type Nested3PartyIDField struct{ quickfix.FIXString } + +//Tag returns tag.Nested3PartyID (949) +func (f Nested3PartyIDField) Tag() quickfix.Tag { return tag.Nested3PartyID } + +//NewNested3PartyID returns a new Nested3PartyIDField initialized with val +func NewNested3PartyID(val string) Nested3PartyIDField { + return Nested3PartyIDField{quickfix.FIXString(val)} +} + +//Nested3PartyIDSourceField is a CHAR field +type Nested3PartyIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.Nested3PartyIDSource (950) +func (f Nested3PartyIDSourceField) Tag() quickfix.Tag { return tag.Nested3PartyIDSource } + +//NewNested3PartyIDSource returns a new Nested3PartyIDSourceField initialized with val +func NewNested3PartyIDSource(val string) Nested3PartyIDSourceField { + return Nested3PartyIDSourceField{quickfix.FIXString(val)} +} + +//Nested3PartyRoleField is a INT field +type Nested3PartyRoleField struct{ quickfix.FIXInt } + +//Tag returns tag.Nested3PartyRole (951) +func (f Nested3PartyRoleField) Tag() quickfix.Tag { return tag.Nested3PartyRole } + +//NewNested3PartyRole returns a new Nested3PartyRoleField initialized with val +func NewNested3PartyRole(val int) Nested3PartyRoleField { + return Nested3PartyRoleField{quickfix.FIXInt(val)} +} + +//Nested3PartySubIDField is a STRING field +type Nested3PartySubIDField struct{ quickfix.FIXString } + +//Tag returns tag.Nested3PartySubID (953) +func (f Nested3PartySubIDField) Tag() quickfix.Tag { return tag.Nested3PartySubID } + +//NewNested3PartySubID returns a new Nested3PartySubIDField initialized with val +func NewNested3PartySubID(val string) Nested3PartySubIDField { + return Nested3PartySubIDField{quickfix.FIXString(val)} +} + +//Nested3PartySubIDTypeField is a INT field +type Nested3PartySubIDTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.Nested3PartySubIDType (954) +func (f Nested3PartySubIDTypeField) Tag() quickfix.Tag { return tag.Nested3PartySubIDType } + +//NewNested3PartySubIDType returns a new Nested3PartySubIDTypeField initialized with val +func NewNested3PartySubIDType(val int) Nested3PartySubIDTypeField { + return Nested3PartySubIDTypeField{quickfix.FIXInt(val)} +} + +//Nested4PartyIDField is a STRING field +type Nested4PartyIDField struct{ quickfix.FIXString } + +//Tag returns tag.Nested4PartyID (1415) +func (f Nested4PartyIDField) Tag() quickfix.Tag { return tag.Nested4PartyID } + +//NewNested4PartyID returns a new Nested4PartyIDField initialized with val +func NewNested4PartyID(val string) Nested4PartyIDField { + return Nested4PartyIDField{quickfix.FIXString(val)} +} + +//Nested4PartyIDSourceField is a CHAR field +type Nested4PartyIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.Nested4PartyIDSource (1416) +func (f Nested4PartyIDSourceField) Tag() quickfix.Tag { return tag.Nested4PartyIDSource } + +//NewNested4PartyIDSource returns a new Nested4PartyIDSourceField initialized with val +func NewNested4PartyIDSource(val string) Nested4PartyIDSourceField { + return Nested4PartyIDSourceField{quickfix.FIXString(val)} +} + +//Nested4PartyRoleField is a INT field +type Nested4PartyRoleField struct{ quickfix.FIXInt } + +//Tag returns tag.Nested4PartyRole (1417) +func (f Nested4PartyRoleField) Tag() quickfix.Tag { return tag.Nested4PartyRole } + +//NewNested4PartyRole returns a new Nested4PartyRoleField initialized with val +func NewNested4PartyRole(val int) Nested4PartyRoleField { + return Nested4PartyRoleField{quickfix.FIXInt(val)} +} + +//Nested4PartySubIDField is a STRING field +type Nested4PartySubIDField struct{ quickfix.FIXString } + +//Tag returns tag.Nested4PartySubID (1412) +func (f Nested4PartySubIDField) Tag() quickfix.Tag { return tag.Nested4PartySubID } + +//NewNested4PartySubID returns a new Nested4PartySubIDField initialized with val +func NewNested4PartySubID(val string) Nested4PartySubIDField { + return Nested4PartySubIDField{quickfix.FIXString(val)} +} + +//Nested4PartySubIDTypeField is a INT field +type Nested4PartySubIDTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.Nested4PartySubIDType (1411) +func (f Nested4PartySubIDTypeField) Tag() quickfix.Tag { return tag.Nested4PartySubIDType } + +//NewNested4PartySubIDType returns a new Nested4PartySubIDTypeField initialized with val +func NewNested4PartySubIDType(val int) Nested4PartySubIDTypeField { + return Nested4PartySubIDTypeField{quickfix.FIXInt(val)} +} + +//NestedInstrAttribTypeField is a INT field +type NestedInstrAttribTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.NestedInstrAttribType (1210) +func (f NestedInstrAttribTypeField) Tag() quickfix.Tag { return tag.NestedInstrAttribType } + +//NewNestedInstrAttribType returns a new NestedInstrAttribTypeField initialized with val +func NewNestedInstrAttribType(val int) NestedInstrAttribTypeField { + return NestedInstrAttribTypeField{quickfix.FIXInt(val)} +} + +//NestedInstrAttribValueField is a STRING field +type NestedInstrAttribValueField struct{ quickfix.FIXString } + +//Tag returns tag.NestedInstrAttribValue (1211) +func (f NestedInstrAttribValueField) Tag() quickfix.Tag { return tag.NestedInstrAttribValue } + +//NewNestedInstrAttribValue returns a new NestedInstrAttribValueField initialized with val +func NewNestedInstrAttribValue(val string) NestedInstrAttribValueField { + return NestedInstrAttribValueField{quickfix.FIXString(val)} +} + +//NestedPartyIDField is a STRING field +type NestedPartyIDField struct{ quickfix.FIXString } + +//Tag returns tag.NestedPartyID (524) +func (f NestedPartyIDField) Tag() quickfix.Tag { return tag.NestedPartyID } + +//NewNestedPartyID returns a new NestedPartyIDField initialized with val +func NewNestedPartyID(val string) NestedPartyIDField { + return NestedPartyIDField{quickfix.FIXString(val)} +} + +//NestedPartyIDSourceField is a CHAR field +type NestedPartyIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.NestedPartyIDSource (525) +func (f NestedPartyIDSourceField) Tag() quickfix.Tag { return tag.NestedPartyIDSource } + +//NewNestedPartyIDSource returns a new NestedPartyIDSourceField initialized with val +func NewNestedPartyIDSource(val string) NestedPartyIDSourceField { + return NestedPartyIDSourceField{quickfix.FIXString(val)} +} + +//NestedPartyRoleField is a INT field +type NestedPartyRoleField struct{ quickfix.FIXInt } + +//Tag returns tag.NestedPartyRole (538) +func (f NestedPartyRoleField) Tag() quickfix.Tag { return tag.NestedPartyRole } + +//NewNestedPartyRole returns a new NestedPartyRoleField initialized with val +func NewNestedPartyRole(val int) NestedPartyRoleField { + return NestedPartyRoleField{quickfix.FIXInt(val)} +} + +//NestedPartySubIDField is a STRING field +type NestedPartySubIDField struct{ quickfix.FIXString } + +//Tag returns tag.NestedPartySubID (545) +func (f NestedPartySubIDField) Tag() quickfix.Tag { return tag.NestedPartySubID } + +//NewNestedPartySubID returns a new NestedPartySubIDField initialized with val +func NewNestedPartySubID(val string) NestedPartySubIDField { + return NestedPartySubIDField{quickfix.FIXString(val)} +} + +//NestedPartySubIDTypeField is a INT field +type NestedPartySubIDTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.NestedPartySubIDType (805) +func (f NestedPartySubIDTypeField) Tag() quickfix.Tag { return tag.NestedPartySubIDType } + +//NewNestedPartySubIDType returns a new NestedPartySubIDTypeField initialized with val +func NewNestedPartySubIDType(val int) NestedPartySubIDTypeField { + return NestedPartySubIDTypeField{quickfix.FIXInt(val)} +} + +//NetChgPrevDayField is a PRICEOFFSET field +type NetChgPrevDayField struct{ quickfix.FIXFloat } + +//Tag returns tag.NetChgPrevDay (451) +func (f NetChgPrevDayField) Tag() quickfix.Tag { return tag.NetChgPrevDay } + +//NewNetChgPrevDay returns a new NetChgPrevDayField initialized with val +func NewNetChgPrevDay(val float64) NetChgPrevDayField { + return NetChgPrevDayField{quickfix.FIXFloat(val)} +} + +//NetGrossIndField is a INT field +type NetGrossIndField struct{ quickfix.FIXInt } + +//Tag returns tag.NetGrossInd (430) +func (f NetGrossIndField) Tag() quickfix.Tag { return tag.NetGrossInd } + +//NewNetGrossInd returns a new NetGrossIndField initialized with val +func NewNetGrossInd(val int) NetGrossIndField { + return NetGrossIndField{quickfix.FIXInt(val)} +} + +//NetMoneyField is a AMT field +type NetMoneyField struct{ quickfix.FIXFloat } + +//Tag returns tag.NetMoney (118) +func (f NetMoneyField) Tag() quickfix.Tag { return tag.NetMoney } + +//NewNetMoney returns a new NetMoneyField initialized with val +func NewNetMoney(val float64) NetMoneyField { + return NetMoneyField{quickfix.FIXFloat(val)} +} + +//NetworkRequestIDField is a STRING field +type NetworkRequestIDField struct{ quickfix.FIXString } + +//Tag returns tag.NetworkRequestID (933) +func (f NetworkRequestIDField) Tag() quickfix.Tag { return tag.NetworkRequestID } + +//NewNetworkRequestID returns a new NetworkRequestIDField initialized with val +func NewNetworkRequestID(val string) NetworkRequestIDField { + return NetworkRequestIDField{quickfix.FIXString(val)} +} + +//NetworkRequestTypeField is a INT field +type NetworkRequestTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.NetworkRequestType (935) +func (f NetworkRequestTypeField) Tag() quickfix.Tag { return tag.NetworkRequestType } + +//NewNetworkRequestType returns a new NetworkRequestTypeField initialized with val +func NewNetworkRequestType(val int) NetworkRequestTypeField { + return NetworkRequestTypeField{quickfix.FIXInt(val)} +} + +//NetworkResponseIDField is a STRING field +type NetworkResponseIDField struct{ quickfix.FIXString } + +//Tag returns tag.NetworkResponseID (932) +func (f NetworkResponseIDField) Tag() quickfix.Tag { return tag.NetworkResponseID } + +//NewNetworkResponseID returns a new NetworkResponseIDField initialized with val +func NewNetworkResponseID(val string) NetworkResponseIDField { + return NetworkResponseIDField{quickfix.FIXString(val)} +} + +//NetworkStatusResponseTypeField is a INT field +type NetworkStatusResponseTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.NetworkStatusResponseType (937) +func (f NetworkStatusResponseTypeField) Tag() quickfix.Tag { return tag.NetworkStatusResponseType } + +//NewNetworkStatusResponseType returns a new NetworkStatusResponseTypeField initialized with val +func NewNetworkStatusResponseType(val int) NetworkStatusResponseTypeField { + return NetworkStatusResponseTypeField{quickfix.FIXInt(val)} +} + +//NewPasswordField is a STRING field +type NewPasswordField struct{ quickfix.FIXString } + +//Tag returns tag.NewPassword (925) +func (f NewPasswordField) Tag() quickfix.Tag { return tag.NewPassword } + +//NewNewPassword returns a new NewPasswordField initialized with val +func NewNewPassword(val string) NewPasswordField { + return NewPasswordField{quickfix.FIXString(val)} +} + +//NewSeqNoField is a SEQNUM field +type NewSeqNoField struct{ quickfix.FIXInt } + +//Tag returns tag.NewSeqNo (36) +func (f NewSeqNoField) Tag() quickfix.Tag { return tag.NewSeqNo } + +//NewNewSeqNo returns a new NewSeqNoField initialized with val +func NewNewSeqNo(val int) NewSeqNoField { + return NewSeqNoField{quickfix.FIXInt(val)} +} + +//NewsCategoryField is a INT field +type NewsCategoryField struct{ quickfix.FIXInt } + +//Tag returns tag.NewsCategory (1473) +func (f NewsCategoryField) Tag() quickfix.Tag { return tag.NewsCategory } + +//NewNewsCategory returns a new NewsCategoryField initialized with val +func NewNewsCategory(val int) NewsCategoryField { + return NewsCategoryField{quickfix.FIXInt(val)} +} + +//NewsIDField is a STRING field +type NewsIDField struct{ quickfix.FIXString } + +//Tag returns tag.NewsID (1472) +func (f NewsIDField) Tag() quickfix.Tag { return tag.NewsID } + +//NewNewsID returns a new NewsIDField initialized with val +func NewNewsID(val string) NewsIDField { + return NewsIDField{quickfix.FIXString(val)} +} + +//NewsRefIDField is a STRING field +type NewsRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.NewsRefID (1476) +func (f NewsRefIDField) Tag() quickfix.Tag { return tag.NewsRefID } + +//NewNewsRefID returns a new NewsRefIDField initialized with val +func NewNewsRefID(val string) NewsRefIDField { + return NewsRefIDField{quickfix.FIXString(val)} +} + +//NewsRefTypeField is a INT field +type NewsRefTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.NewsRefType (1477) +func (f NewsRefTypeField) Tag() quickfix.Tag { return tag.NewsRefType } + +//NewNewsRefType returns a new NewsRefTypeField initialized with val +func NewNewsRefType(val int) NewsRefTypeField { + return NewsRefTypeField{quickfix.FIXInt(val)} +} + +//NextExpectedMsgSeqNumField is a SEQNUM field +type NextExpectedMsgSeqNumField struct{ quickfix.FIXInt } + +//Tag returns tag.NextExpectedMsgSeqNum (789) +func (f NextExpectedMsgSeqNumField) Tag() quickfix.Tag { return tag.NextExpectedMsgSeqNum } + +//NewNextExpectedMsgSeqNum returns a new NextExpectedMsgSeqNumField initialized with val +func NewNextExpectedMsgSeqNum(val int) NextExpectedMsgSeqNumField { + return NextExpectedMsgSeqNumField{quickfix.FIXInt(val)} +} + +//NoAffectedOrdersField is a NUMINGROUP field +type NoAffectedOrdersField struct{ quickfix.FIXInt } + +//Tag returns tag.NoAffectedOrders (534) +func (f NoAffectedOrdersField) Tag() quickfix.Tag { return tag.NoAffectedOrders } + +//NewNoAffectedOrders returns a new NoAffectedOrdersField initialized with val +func NewNoAffectedOrders(val int) NoAffectedOrdersField { + return NoAffectedOrdersField{quickfix.FIXInt(val)} +} + +//NoAllocsField is a NUMINGROUP field +type NoAllocsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoAllocs (78) +func (f NoAllocsField) Tag() quickfix.Tag { return tag.NoAllocs } + +//NewNoAllocs returns a new NoAllocsField initialized with val +func NewNoAllocs(val int) NoAllocsField { + return NoAllocsField{quickfix.FIXInt(val)} +} + +//NoAltMDSourceField is a NUMINGROUP field +type NoAltMDSourceField struct{ quickfix.FIXInt } + +//Tag returns tag.NoAltMDSource (816) +func (f NoAltMDSourceField) Tag() quickfix.Tag { return tag.NoAltMDSource } + +//NewNoAltMDSource returns a new NoAltMDSourceField initialized with val +func NewNoAltMDSource(val int) NoAltMDSourceField { + return NoAltMDSourceField{quickfix.FIXInt(val)} +} + +//NoApplIDsField is a NUMINGROUP field +type NoApplIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoApplIDs (1351) +func (f NoApplIDsField) Tag() quickfix.Tag { return tag.NoApplIDs } + +//NewNoApplIDs returns a new NoApplIDsField initialized with val +func NewNoApplIDs(val int) NoApplIDsField { + return NoApplIDsField{quickfix.FIXInt(val)} +} + +//NoAsgnReqsField is a NUMINGROUP field +type NoAsgnReqsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoAsgnReqs (1499) +func (f NoAsgnReqsField) Tag() quickfix.Tag { return tag.NoAsgnReqs } + +//NewNoAsgnReqs returns a new NoAsgnReqsField initialized with val +func NewNoAsgnReqs(val int) NoAsgnReqsField { + return NoAsgnReqsField{quickfix.FIXInt(val)} +} + +//NoBidComponentsField is a NUMINGROUP field +type NoBidComponentsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoBidComponents (420) +func (f NoBidComponentsField) Tag() quickfix.Tag { return tag.NoBidComponents } + +//NewNoBidComponents returns a new NoBidComponentsField initialized with val +func NewNoBidComponents(val int) NoBidComponentsField { + return NoBidComponentsField{quickfix.FIXInt(val)} +} + +//NoBidDescriptorsField is a NUMINGROUP field +type NoBidDescriptorsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoBidDescriptors (398) +func (f NoBidDescriptorsField) Tag() quickfix.Tag { return tag.NoBidDescriptors } + +//NewNoBidDescriptors returns a new NoBidDescriptorsField initialized with val +func NewNoBidDescriptors(val int) NoBidDescriptorsField { + return NoBidDescriptorsField{quickfix.FIXInt(val)} +} + +//NoCapacitiesField is a NUMINGROUP field +type NoCapacitiesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoCapacities (862) +func (f NoCapacitiesField) Tag() quickfix.Tag { return tag.NoCapacities } + +//NewNoCapacities returns a new NoCapacitiesField initialized with val +func NewNoCapacities(val int) NoCapacitiesField { + return NoCapacitiesField{quickfix.FIXInt(val)} +} + +//NoClearingInstructionsField is a NUMINGROUP field +type NoClearingInstructionsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoClearingInstructions (576) +func (f NoClearingInstructionsField) Tag() quickfix.Tag { return tag.NoClearingInstructions } + +//NewNoClearingInstructions returns a new NoClearingInstructionsField initialized with val +func NewNoClearingInstructions(val int) NoClearingInstructionsField { + return NoClearingInstructionsField{quickfix.FIXInt(val)} +} + +//NoCollInquiryQualifierField is a NUMINGROUP field +type NoCollInquiryQualifierField struct{ quickfix.FIXInt } + +//Tag returns tag.NoCollInquiryQualifier (938) +func (f NoCollInquiryQualifierField) Tag() quickfix.Tag { return tag.NoCollInquiryQualifier } + +//NewNoCollInquiryQualifier returns a new NoCollInquiryQualifierField initialized with val +func NewNoCollInquiryQualifier(val int) NoCollInquiryQualifierField { + return NoCollInquiryQualifierField{quickfix.FIXInt(val)} +} + +//NoCompIDsField is a NUMINGROUP field +type NoCompIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoCompIDs (936) +func (f NoCompIDsField) Tag() quickfix.Tag { return tag.NoCompIDs } + +//NewNoCompIDs returns a new NoCompIDsField initialized with val +func NewNoCompIDs(val int) NoCompIDsField { + return NoCompIDsField{quickfix.FIXInt(val)} +} + +//NoComplexEventDatesField is a NUMINGROUP field +type NoComplexEventDatesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoComplexEventDates (1491) +func (f NoComplexEventDatesField) Tag() quickfix.Tag { return tag.NoComplexEventDates } + +//NewNoComplexEventDates returns a new NoComplexEventDatesField initialized with val +func NewNoComplexEventDates(val int) NoComplexEventDatesField { + return NoComplexEventDatesField{quickfix.FIXInt(val)} +} + +//NoComplexEventTimesField is a NUMINGROUP field +type NoComplexEventTimesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoComplexEventTimes (1494) +func (f NoComplexEventTimesField) Tag() quickfix.Tag { return tag.NoComplexEventTimes } + +//NewNoComplexEventTimes returns a new NoComplexEventTimesField initialized with val +func NewNoComplexEventTimes(val int) NoComplexEventTimesField { + return NoComplexEventTimesField{quickfix.FIXInt(val)} +} + +//NoComplexEventsField is a NUMINGROUP field +type NoComplexEventsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoComplexEvents (1483) +func (f NoComplexEventsField) Tag() quickfix.Tag { return tag.NoComplexEvents } + +//NewNoComplexEvents returns a new NoComplexEventsField initialized with val +func NewNoComplexEvents(val int) NoComplexEventsField { + return NoComplexEventsField{quickfix.FIXInt(val)} +} + +//NoContAmtsField is a NUMINGROUP field +type NoContAmtsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoContAmts (518) +func (f NoContAmtsField) Tag() quickfix.Tag { return tag.NoContAmts } + +//NewNoContAmts returns a new NoContAmtsField initialized with val +func NewNoContAmts(val int) NoContAmtsField { + return NoContAmtsField{quickfix.FIXInt(val)} +} + +//NoContextPartyIDsField is a NUMINGROUP field +type NoContextPartyIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoContextPartyIDs (1522) +func (f NoContextPartyIDsField) Tag() quickfix.Tag { return tag.NoContextPartyIDs } + +//NewNoContextPartyIDs returns a new NoContextPartyIDsField initialized with val +func NewNoContextPartyIDs(val int) NoContextPartyIDsField { + return NoContextPartyIDsField{quickfix.FIXInt(val)} +} + +//NoContextPartySubIDsField is a NUMINGROUP field +type NoContextPartySubIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoContextPartySubIDs (1526) +func (f NoContextPartySubIDsField) Tag() quickfix.Tag { return tag.NoContextPartySubIDs } + +//NewNoContextPartySubIDs returns a new NoContextPartySubIDsField initialized with val +func NewNoContextPartySubIDs(val int) NoContextPartySubIDsField { + return NoContextPartySubIDsField{quickfix.FIXInt(val)} +} + +//NoContraBrokersField is a NUMINGROUP field +type NoContraBrokersField struct{ quickfix.FIXInt } + +//Tag returns tag.NoContraBrokers (382) +func (f NoContraBrokersField) Tag() quickfix.Tag { return tag.NoContraBrokers } + +//NewNoContraBrokers returns a new NoContraBrokersField initialized with val +func NewNoContraBrokers(val int) NoContraBrokersField { + return NoContraBrokersField{quickfix.FIXInt(val)} +} + +//NoDatesField is a INT field +type NoDatesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoDates (580) +func (f NoDatesField) Tag() quickfix.Tag { return tag.NoDates } + +//NewNoDates returns a new NoDatesField initialized with val +func NewNoDates(val int) NoDatesField { + return NoDatesField{quickfix.FIXInt(val)} +} + +//NoDerivativeEventsField is a NUMINGROUP field +type NoDerivativeEventsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoDerivativeEvents (1286) +func (f NoDerivativeEventsField) Tag() quickfix.Tag { return tag.NoDerivativeEvents } + +//NewNoDerivativeEvents returns a new NoDerivativeEventsField initialized with val +func NewNoDerivativeEvents(val int) NoDerivativeEventsField { + return NoDerivativeEventsField{quickfix.FIXInt(val)} +} + +//NoDerivativeInstrAttribField is a NUMINGROUP field +type NoDerivativeInstrAttribField struct{ quickfix.FIXInt } + +//Tag returns tag.NoDerivativeInstrAttrib (1311) +func (f NoDerivativeInstrAttribField) Tag() quickfix.Tag { return tag.NoDerivativeInstrAttrib } + +//NewNoDerivativeInstrAttrib returns a new NoDerivativeInstrAttribField initialized with val +func NewNoDerivativeInstrAttrib(val int) NoDerivativeInstrAttribField { + return NoDerivativeInstrAttribField{quickfix.FIXInt(val)} +} + +//NoDerivativeInstrumentPartiesField is a NUMINGROUP field +type NoDerivativeInstrumentPartiesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoDerivativeInstrumentParties (1292) +func (f NoDerivativeInstrumentPartiesField) Tag() quickfix.Tag { + return tag.NoDerivativeInstrumentParties +} + +//NewNoDerivativeInstrumentParties returns a new NoDerivativeInstrumentPartiesField initialized with val +func NewNoDerivativeInstrumentParties(val int) NoDerivativeInstrumentPartiesField { + return NoDerivativeInstrumentPartiesField{quickfix.FIXInt(val)} +} + +//NoDerivativeInstrumentPartySubIDsField is a NUMINGROUP field +type NoDerivativeInstrumentPartySubIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoDerivativeInstrumentPartySubIDs (1296) +func (f NoDerivativeInstrumentPartySubIDsField) Tag() quickfix.Tag { + return tag.NoDerivativeInstrumentPartySubIDs +} + +//NewNoDerivativeInstrumentPartySubIDs returns a new NoDerivativeInstrumentPartySubIDsField initialized with val +func NewNoDerivativeInstrumentPartySubIDs(val int) NoDerivativeInstrumentPartySubIDsField { + return NoDerivativeInstrumentPartySubIDsField{quickfix.FIXInt(val)} +} + +//NoDerivativeSecurityAltIDField is a NUMINGROUP field +type NoDerivativeSecurityAltIDField struct{ quickfix.FIXInt } + +//Tag returns tag.NoDerivativeSecurityAltID (1218) +func (f NoDerivativeSecurityAltIDField) Tag() quickfix.Tag { return tag.NoDerivativeSecurityAltID } + +//NewNoDerivativeSecurityAltID returns a new NoDerivativeSecurityAltIDField initialized with val +func NewNoDerivativeSecurityAltID(val int) NoDerivativeSecurityAltIDField { + return NoDerivativeSecurityAltIDField{quickfix.FIXInt(val)} +} + +//NoDistribInstsField is a NUMINGROUP field +type NoDistribInstsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoDistribInsts (510) +func (f NoDistribInstsField) Tag() quickfix.Tag { return tag.NoDistribInsts } + +//NewNoDistribInsts returns a new NoDistribInstsField initialized with val +func NewNoDistribInsts(val int) NoDistribInstsField { + return NoDistribInstsField{quickfix.FIXInt(val)} +} + +//NoDlvyInstField is a NUMINGROUP field +type NoDlvyInstField struct{ quickfix.FIXInt } + +//Tag returns tag.NoDlvyInst (85) +func (f NoDlvyInstField) Tag() quickfix.Tag { return tag.NoDlvyInst } + +//NewNoDlvyInst returns a new NoDlvyInstField initialized with val +func NewNoDlvyInst(val int) NoDlvyInstField { + return NoDlvyInstField{quickfix.FIXInt(val)} +} + +//NoEventsField is a NUMINGROUP field +type NoEventsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoEvents (864) +func (f NoEventsField) Tag() quickfix.Tag { return tag.NoEvents } + +//NewNoEvents returns a new NoEventsField initialized with val +func NewNoEvents(val int) NoEventsField { + return NoEventsField{quickfix.FIXInt(val)} +} + +//NoExecInstRulesField is a NUMINGROUP field +type NoExecInstRulesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoExecInstRules (1232) +func (f NoExecInstRulesField) Tag() quickfix.Tag { return tag.NoExecInstRules } + +//NewNoExecInstRules returns a new NoExecInstRulesField initialized with val +func NewNoExecInstRules(val int) NoExecInstRulesField { + return NoExecInstRulesField{quickfix.FIXInt(val)} +} + +//NoExecsField is a NUMINGROUP field +type NoExecsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoExecs (124) +func (f NoExecsField) Tag() quickfix.Tag { return tag.NoExecs } + +//NewNoExecs returns a new NoExecsField initialized with val +func NewNoExecs(val int) NoExecsField { + return NoExecsField{quickfix.FIXInt(val)} +} + +//NoExpirationField is a NUMINGROUP field +type NoExpirationField struct{ quickfix.FIXInt } + +//Tag returns tag.NoExpiration (981) +func (f NoExpirationField) Tag() quickfix.Tag { return tag.NoExpiration } + +//NewNoExpiration returns a new NoExpirationField initialized with val +func NewNoExpiration(val int) NoExpirationField { + return NoExpirationField{quickfix.FIXInt(val)} +} + +//NoFillsField is a NUMINGROUP field +type NoFillsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoFills (1362) +func (f NoFillsField) Tag() quickfix.Tag { return tag.NoFills } + +//NewNoFills returns a new NoFillsField initialized with val +func NewNoFills(val int) NoFillsField { + return NoFillsField{quickfix.FIXInt(val)} +} + +//NoHopsField is a NUMINGROUP field +type NoHopsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoHops (627) +func (f NoHopsField) Tag() quickfix.Tag { return tag.NoHops } + +//NewNoHops returns a new NoHopsField initialized with val +func NewNoHops(val int) NoHopsField { + return NoHopsField{quickfix.FIXInt(val)} +} + +//NoIOIQualifiersField is a NUMINGROUP field +type NoIOIQualifiersField struct{ quickfix.FIXInt } + +//Tag returns tag.NoIOIQualifiers (199) +func (f NoIOIQualifiersField) Tag() quickfix.Tag { return tag.NoIOIQualifiers } + +//NewNoIOIQualifiers returns a new NoIOIQualifiersField initialized with val +func NewNoIOIQualifiers(val int) NoIOIQualifiersField { + return NoIOIQualifiersField{quickfix.FIXInt(val)} +} + +//NoInstrAttribField is a NUMINGROUP field +type NoInstrAttribField struct{ quickfix.FIXInt } + +//Tag returns tag.NoInstrAttrib (870) +func (f NoInstrAttribField) Tag() quickfix.Tag { return tag.NoInstrAttrib } + +//NewNoInstrAttrib returns a new NoInstrAttribField initialized with val +func NewNoInstrAttrib(val int) NoInstrAttribField { + return NoInstrAttribField{quickfix.FIXInt(val)} +} + +//NoInstrumentPartiesField is a NUMINGROUP field +type NoInstrumentPartiesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoInstrumentParties (1018) +func (f NoInstrumentPartiesField) Tag() quickfix.Tag { return tag.NoInstrumentParties } + +//NewNoInstrumentParties returns a new NoInstrumentPartiesField initialized with val +func NewNoInstrumentParties(val int) NoInstrumentPartiesField { + return NoInstrumentPartiesField{quickfix.FIXInt(val)} +} + +//NoInstrumentPartySubIDsField is a NUMINGROUP field +type NoInstrumentPartySubIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoInstrumentPartySubIDs (1052) +func (f NoInstrumentPartySubIDsField) Tag() quickfix.Tag { return tag.NoInstrumentPartySubIDs } + +//NewNoInstrumentPartySubIDs returns a new NoInstrumentPartySubIDsField initialized with val +func NewNoInstrumentPartySubIDs(val int) NoInstrumentPartySubIDsField { + return NoInstrumentPartySubIDsField{quickfix.FIXInt(val)} +} + +//NoLegAllocsField is a NUMINGROUP field +type NoLegAllocsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoLegAllocs (670) +func (f NoLegAllocsField) Tag() quickfix.Tag { return tag.NoLegAllocs } + +//NewNoLegAllocs returns a new NoLegAllocsField initialized with val +func NewNoLegAllocs(val int) NoLegAllocsField { + return NoLegAllocsField{quickfix.FIXInt(val)} +} + +//NoLegSecurityAltIDField is a STRING field +type NoLegSecurityAltIDField struct{ quickfix.FIXString } + +//Tag returns tag.NoLegSecurityAltID (604) +func (f NoLegSecurityAltIDField) Tag() quickfix.Tag { return tag.NoLegSecurityAltID } + +//NewNoLegSecurityAltID returns a new NoLegSecurityAltIDField initialized with val +func NewNoLegSecurityAltID(val string) NoLegSecurityAltIDField { + return NoLegSecurityAltIDField{quickfix.FIXString(val)} +} + +//NoLegStipulationsField is a NUMINGROUP field +type NoLegStipulationsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoLegStipulations (683) +func (f NoLegStipulationsField) Tag() quickfix.Tag { return tag.NoLegStipulations } + +//NewNoLegStipulations returns a new NoLegStipulationsField initialized with val +func NewNoLegStipulations(val int) NoLegStipulationsField { + return NoLegStipulationsField{quickfix.FIXInt(val)} +} + +//NoLegsField is a NUMINGROUP field +type NoLegsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoLegs (555) +func (f NoLegsField) Tag() quickfix.Tag { return tag.NoLegs } + +//NewNoLegs returns a new NoLegsField initialized with val +func NewNoLegs(val int) NoLegsField { + return NoLegsField{quickfix.FIXInt(val)} +} + +//NoLinesOfTextField is a NUMINGROUP field +type NoLinesOfTextField struct{ quickfix.FIXInt } + +//Tag returns tag.NoLinesOfText (33) +func (f NoLinesOfTextField) Tag() quickfix.Tag { return tag.NoLinesOfText } + +//NewNoLinesOfText returns a new NoLinesOfTextField initialized with val +func NewNoLinesOfText(val int) NoLinesOfTextField { + return NoLinesOfTextField{quickfix.FIXInt(val)} +} + +//NoLotTypeRulesField is a NUMINGROUP field +type NoLotTypeRulesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoLotTypeRules (1234) +func (f NoLotTypeRulesField) Tag() quickfix.Tag { return tag.NoLotTypeRules } + +//NewNoLotTypeRules returns a new NoLotTypeRulesField initialized with val +func NewNoLotTypeRules(val int) NoLotTypeRulesField { + return NoLotTypeRulesField{quickfix.FIXInt(val)} +} + +//NoMDEntriesField is a NUMINGROUP field +type NoMDEntriesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoMDEntries (268) +func (f NoMDEntriesField) Tag() quickfix.Tag { return tag.NoMDEntries } + +//NewNoMDEntries returns a new NoMDEntriesField initialized with val +func NewNoMDEntries(val int) NoMDEntriesField { + return NoMDEntriesField{quickfix.FIXInt(val)} +} + +//NoMDEntryTypesField is a NUMINGROUP field +type NoMDEntryTypesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoMDEntryTypes (267) +func (f NoMDEntryTypesField) Tag() quickfix.Tag { return tag.NoMDEntryTypes } + +//NewNoMDEntryTypes returns a new NoMDEntryTypesField initialized with val +func NewNoMDEntryTypes(val int) NoMDEntryTypesField { + return NoMDEntryTypesField{quickfix.FIXInt(val)} +} + +//NoMDFeedTypesField is a NUMINGROUP field +type NoMDFeedTypesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoMDFeedTypes (1141) +func (f NoMDFeedTypesField) Tag() quickfix.Tag { return tag.NoMDFeedTypes } + +//NewNoMDFeedTypes returns a new NoMDFeedTypesField initialized with val +func NewNoMDFeedTypes(val int) NoMDFeedTypesField { + return NoMDFeedTypesField{quickfix.FIXInt(val)} +} + +//NoMarketSegmentsField is a NUMINGROUP field +type NoMarketSegmentsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoMarketSegments (1310) +func (f NoMarketSegmentsField) Tag() quickfix.Tag { return tag.NoMarketSegments } + +//NewNoMarketSegments returns a new NoMarketSegmentsField initialized with val +func NewNoMarketSegments(val int) NoMarketSegmentsField { + return NoMarketSegmentsField{quickfix.FIXInt(val)} +} + +//NoMatchRulesField is a NUMINGROUP field +type NoMatchRulesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoMatchRules (1235) +func (f NoMatchRulesField) Tag() quickfix.Tag { return tag.NoMatchRules } + +//NewNoMatchRules returns a new NoMatchRulesField initialized with val +func NewNoMatchRules(val int) NoMatchRulesField { + return NoMatchRulesField{quickfix.FIXInt(val)} +} + +//NoMaturityRulesField is a NUMINGROUP field +type NoMaturityRulesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoMaturityRules (1236) +func (f NoMaturityRulesField) Tag() quickfix.Tag { return tag.NoMaturityRules } + +//NewNoMaturityRules returns a new NoMaturityRulesField initialized with val +func NewNoMaturityRules(val int) NoMaturityRulesField { + return NoMaturityRulesField{quickfix.FIXInt(val)} +} + +//NoMiscFeesField is a NUMINGROUP field +type NoMiscFeesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoMiscFees (136) +func (f NoMiscFeesField) Tag() quickfix.Tag { return tag.NoMiscFees } + +//NewNoMiscFees returns a new NoMiscFeesField initialized with val +func NewNoMiscFees(val int) NoMiscFeesField { + return NoMiscFeesField{quickfix.FIXInt(val)} +} + +//NoMsgTypesField is a NUMINGROUP field +type NoMsgTypesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoMsgTypes (384) +func (f NoMsgTypesField) Tag() quickfix.Tag { return tag.NoMsgTypes } + +//NewNoMsgTypes returns a new NoMsgTypesField initialized with val +func NewNoMsgTypes(val int) NoMsgTypesField { + return NoMsgTypesField{quickfix.FIXInt(val)} +} + +//NoNested2PartyIDsField is a NUMINGROUP field +type NoNested2PartyIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoNested2PartyIDs (756) +func (f NoNested2PartyIDsField) Tag() quickfix.Tag { return tag.NoNested2PartyIDs } + +//NewNoNested2PartyIDs returns a new NoNested2PartyIDsField initialized with val +func NewNoNested2PartyIDs(val int) NoNested2PartyIDsField { + return NoNested2PartyIDsField{quickfix.FIXInt(val)} +} + +//NoNested2PartySubIDsField is a NUMINGROUP field +type NoNested2PartySubIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoNested2PartySubIDs (806) +func (f NoNested2PartySubIDsField) Tag() quickfix.Tag { return tag.NoNested2PartySubIDs } + +//NewNoNested2PartySubIDs returns a new NoNested2PartySubIDsField initialized with val +func NewNoNested2PartySubIDs(val int) NoNested2PartySubIDsField { + return NoNested2PartySubIDsField{quickfix.FIXInt(val)} +} + +//NoNested3PartyIDsField is a NUMINGROUP field +type NoNested3PartyIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoNested3PartyIDs (948) +func (f NoNested3PartyIDsField) Tag() quickfix.Tag { return tag.NoNested3PartyIDs } + +//NewNoNested3PartyIDs returns a new NoNested3PartyIDsField initialized with val +func NewNoNested3PartyIDs(val int) NoNested3PartyIDsField { + return NoNested3PartyIDsField{quickfix.FIXInt(val)} +} + +//NoNested3PartySubIDsField is a NUMINGROUP field +type NoNested3PartySubIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoNested3PartySubIDs (952) +func (f NoNested3PartySubIDsField) Tag() quickfix.Tag { return tag.NoNested3PartySubIDs } + +//NewNoNested3PartySubIDs returns a new NoNested3PartySubIDsField initialized with val +func NewNoNested3PartySubIDs(val int) NoNested3PartySubIDsField { + return NoNested3PartySubIDsField{quickfix.FIXInt(val)} +} + +//NoNested4PartyIDsField is a NUMINGROUP field +type NoNested4PartyIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoNested4PartyIDs (1414) +func (f NoNested4PartyIDsField) Tag() quickfix.Tag { return tag.NoNested4PartyIDs } + +//NewNoNested4PartyIDs returns a new NoNested4PartyIDsField initialized with val +func NewNoNested4PartyIDs(val int) NoNested4PartyIDsField { + return NoNested4PartyIDsField{quickfix.FIXInt(val)} +} + +//NoNested4PartySubIDsField is a NUMINGROUP field +type NoNested4PartySubIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoNested4PartySubIDs (1413) +func (f NoNested4PartySubIDsField) Tag() quickfix.Tag { return tag.NoNested4PartySubIDs } + +//NewNoNested4PartySubIDs returns a new NoNested4PartySubIDsField initialized with val +func NewNoNested4PartySubIDs(val int) NoNested4PartySubIDsField { + return NoNested4PartySubIDsField{quickfix.FIXInt(val)} +} + +//NoNestedInstrAttribField is a NUMINGROUP field +type NoNestedInstrAttribField struct{ quickfix.FIXInt } + +//Tag returns tag.NoNestedInstrAttrib (1312) +func (f NoNestedInstrAttribField) Tag() quickfix.Tag { return tag.NoNestedInstrAttrib } + +//NewNoNestedInstrAttrib returns a new NoNestedInstrAttribField initialized with val +func NewNoNestedInstrAttrib(val int) NoNestedInstrAttribField { + return NoNestedInstrAttribField{quickfix.FIXInt(val)} +} + +//NoNestedPartyIDsField is a NUMINGROUP field +type NoNestedPartyIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoNestedPartyIDs (539) +func (f NoNestedPartyIDsField) Tag() quickfix.Tag { return tag.NoNestedPartyIDs } + +//NewNoNestedPartyIDs returns a new NoNestedPartyIDsField initialized with val +func NewNoNestedPartyIDs(val int) NoNestedPartyIDsField { + return NoNestedPartyIDsField{quickfix.FIXInt(val)} +} + +//NoNestedPartySubIDsField is a NUMINGROUP field +type NoNestedPartySubIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoNestedPartySubIDs (804) +func (f NoNestedPartySubIDsField) Tag() quickfix.Tag { return tag.NoNestedPartySubIDs } + +//NewNoNestedPartySubIDs returns a new NoNestedPartySubIDsField initialized with val +func NewNoNestedPartySubIDs(val int) NoNestedPartySubIDsField { + return NoNestedPartySubIDsField{quickfix.FIXInt(val)} +} + +//NoNewsRefIDsField is a NUMINGROUP field +type NoNewsRefIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoNewsRefIDs (1475) +func (f NoNewsRefIDsField) Tag() quickfix.Tag { return tag.NoNewsRefIDs } + +//NewNoNewsRefIDs returns a new NoNewsRefIDsField initialized with val +func NewNoNewsRefIDs(val int) NoNewsRefIDsField { + return NoNewsRefIDsField{quickfix.FIXInt(val)} +} + +//NoNotAffectedOrdersField is a NUMINGROUP field +type NoNotAffectedOrdersField struct{ quickfix.FIXInt } + +//Tag returns tag.NoNotAffectedOrders (1370) +func (f NoNotAffectedOrdersField) Tag() quickfix.Tag { return tag.NoNotAffectedOrders } + +//NewNoNotAffectedOrders returns a new NoNotAffectedOrdersField initialized with val +func NewNoNotAffectedOrders(val int) NoNotAffectedOrdersField { + return NoNotAffectedOrdersField{quickfix.FIXInt(val)} +} + +//NoOfLegUnderlyingsField is a NUMINGROUP field +type NoOfLegUnderlyingsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoOfLegUnderlyings (1342) +func (f NoOfLegUnderlyingsField) Tag() quickfix.Tag { return tag.NoOfLegUnderlyings } + +//NewNoOfLegUnderlyings returns a new NoOfLegUnderlyingsField initialized with val +func NewNoOfLegUnderlyings(val int) NoOfLegUnderlyingsField { + return NoOfLegUnderlyingsField{quickfix.FIXInt(val)} +} + +//NoOfSecSizesField is a NUMINGROUP field +type NoOfSecSizesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoOfSecSizes (1177) +func (f NoOfSecSizesField) Tag() quickfix.Tag { return tag.NoOfSecSizes } + +//NewNoOfSecSizes returns a new NoOfSecSizesField initialized with val +func NewNoOfSecSizes(val int) NoOfSecSizesField { + return NoOfSecSizesField{quickfix.FIXInt(val)} +} + +//NoOrdTypeRulesField is a NUMINGROUP field +type NoOrdTypeRulesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoOrdTypeRules (1237) +func (f NoOrdTypeRulesField) Tag() quickfix.Tag { return tag.NoOrdTypeRules } + +//NewNoOrdTypeRules returns a new NoOrdTypeRulesField initialized with val +func NewNoOrdTypeRules(val int) NoOrdTypeRulesField { + return NoOrdTypeRulesField{quickfix.FIXInt(val)} +} + +//NoOrdersField is a NUMINGROUP field +type NoOrdersField struct{ quickfix.FIXInt } + +//Tag returns tag.NoOrders (73) +func (f NoOrdersField) Tag() quickfix.Tag { return tag.NoOrders } + +//NewNoOrders returns a new NoOrdersField initialized with val +func NewNoOrders(val int) NoOrdersField { + return NoOrdersField{quickfix.FIXInt(val)} +} + +//NoPartyAltIDsField is a NUMINGROUP field +type NoPartyAltIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoPartyAltIDs (1516) +func (f NoPartyAltIDsField) Tag() quickfix.Tag { return tag.NoPartyAltIDs } + +//NewNoPartyAltIDs returns a new NoPartyAltIDsField initialized with val +func NewNoPartyAltIDs(val int) NoPartyAltIDsField { + return NoPartyAltIDsField{quickfix.FIXInt(val)} +} + +//NoPartyAltSubIDsField is a NUMINGROUP field +type NoPartyAltSubIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoPartyAltSubIDs (1519) +func (f NoPartyAltSubIDsField) Tag() quickfix.Tag { return tag.NoPartyAltSubIDs } + +//NewNoPartyAltSubIDs returns a new NoPartyAltSubIDsField initialized with val +func NewNoPartyAltSubIDs(val int) NoPartyAltSubIDsField { + return NoPartyAltSubIDsField{quickfix.FIXInt(val)} +} + +//NoPartyIDsField is a NUMINGROUP field +type NoPartyIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoPartyIDs (453) +func (f NoPartyIDsField) Tag() quickfix.Tag { return tag.NoPartyIDs } + +//NewNoPartyIDs returns a new NoPartyIDsField initialized with val +func NewNoPartyIDs(val int) NoPartyIDsField { + return NoPartyIDsField{quickfix.FIXInt(val)} +} + +//NoPartyListField is a NUMINGROUP field +type NoPartyListField struct{ quickfix.FIXInt } + +//Tag returns tag.NoPartyList (1513) +func (f NoPartyListField) Tag() quickfix.Tag { return tag.NoPartyList } + +//NewNoPartyList returns a new NoPartyListField initialized with val +func NewNoPartyList(val int) NoPartyListField { + return NoPartyListField{quickfix.FIXInt(val)} +} + +//NoPartyListResponseTypesField is a NUMINGROUP field +type NoPartyListResponseTypesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoPartyListResponseTypes (1506) +func (f NoPartyListResponseTypesField) Tag() quickfix.Tag { return tag.NoPartyListResponseTypes } + +//NewNoPartyListResponseTypes returns a new NoPartyListResponseTypesField initialized with val +func NewNoPartyListResponseTypes(val int) NoPartyListResponseTypesField { + return NoPartyListResponseTypesField{quickfix.FIXInt(val)} +} + +//NoPartyRelationshipsField is a NUMINGROUP field +type NoPartyRelationshipsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoPartyRelationships (1514) +func (f NoPartyRelationshipsField) Tag() quickfix.Tag { return tag.NoPartyRelationships } + +//NewNoPartyRelationships returns a new NoPartyRelationshipsField initialized with val +func NewNoPartyRelationships(val int) NoPartyRelationshipsField { + return NoPartyRelationshipsField{quickfix.FIXInt(val)} +} + +//NoPartySubIDsField is a NUMINGROUP field +type NoPartySubIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoPartySubIDs (802) +func (f NoPartySubIDsField) Tag() quickfix.Tag { return tag.NoPartySubIDs } + +//NewNoPartySubIDs returns a new NoPartySubIDsField initialized with val +func NewNoPartySubIDs(val int) NoPartySubIDsField { + return NoPartySubIDsField{quickfix.FIXInt(val)} +} + +//NoPosAmtField is a NUMINGROUP field +type NoPosAmtField struct{ quickfix.FIXInt } + +//Tag returns tag.NoPosAmt (753) +func (f NoPosAmtField) Tag() quickfix.Tag { return tag.NoPosAmt } + +//NewNoPosAmt returns a new NoPosAmtField initialized with val +func NewNoPosAmt(val int) NoPosAmtField { + return NoPosAmtField{quickfix.FIXInt(val)} +} + +//NoPositionsField is a NUMINGROUP field +type NoPositionsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoPositions (702) +func (f NoPositionsField) Tag() quickfix.Tag { return tag.NoPositions } + +//NewNoPositions returns a new NoPositionsField initialized with val +func NewNoPositions(val int) NoPositionsField { + return NoPositionsField{quickfix.FIXInt(val)} +} + +//NoQuoteEntriesField is a NUMINGROUP field +type NoQuoteEntriesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoQuoteEntries (295) +func (f NoQuoteEntriesField) Tag() quickfix.Tag { return tag.NoQuoteEntries } + +//NewNoQuoteEntries returns a new NoQuoteEntriesField initialized with val +func NewNoQuoteEntries(val int) NoQuoteEntriesField { + return NoQuoteEntriesField{quickfix.FIXInt(val)} +} + +//NoQuoteQualifiersField is a NUMINGROUP field +type NoQuoteQualifiersField struct{ quickfix.FIXInt } + +//Tag returns tag.NoQuoteQualifiers (735) +func (f NoQuoteQualifiersField) Tag() quickfix.Tag { return tag.NoQuoteQualifiers } + +//NewNoQuoteQualifiers returns a new NoQuoteQualifiersField initialized with val +func NewNoQuoteQualifiers(val int) NoQuoteQualifiersField { + return NoQuoteQualifiersField{quickfix.FIXInt(val)} +} + +//NoQuoteSetsField is a NUMINGROUP field +type NoQuoteSetsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoQuoteSets (296) +func (f NoQuoteSetsField) Tag() quickfix.Tag { return tag.NoQuoteSets } + +//NewNoQuoteSets returns a new NoQuoteSetsField initialized with val +func NewNoQuoteSets(val int) NoQuoteSetsField { + return NoQuoteSetsField{quickfix.FIXInt(val)} +} + +//NoRateSourcesField is a NUMINGROUP field +type NoRateSourcesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRateSources (1445) +func (f NoRateSourcesField) Tag() quickfix.Tag { return tag.NoRateSources } + +//NewNoRateSources returns a new NoRateSourcesField initialized with val +func NewNoRateSources(val int) NoRateSourcesField { + return NoRateSourcesField{quickfix.FIXInt(val)} +} + +//NoRegistDtlsField is a NUMINGROUP field +type NoRegistDtlsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRegistDtls (473) +func (f NoRegistDtlsField) Tag() quickfix.Tag { return tag.NoRegistDtls } + +//NewNoRegistDtls returns a new NoRegistDtlsField initialized with val +func NewNoRegistDtls(val int) NoRegistDtlsField { + return NoRegistDtlsField{quickfix.FIXInt(val)} +} + +//NoRelatedContextPartyIDsField is a NUMINGROUP field +type NoRelatedContextPartyIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRelatedContextPartyIDs (1575) +func (f NoRelatedContextPartyIDsField) Tag() quickfix.Tag { return tag.NoRelatedContextPartyIDs } + +//NewNoRelatedContextPartyIDs returns a new NoRelatedContextPartyIDsField initialized with val +func NewNoRelatedContextPartyIDs(val int) NoRelatedContextPartyIDsField { + return NoRelatedContextPartyIDsField{quickfix.FIXInt(val)} +} + +//NoRelatedContextPartySubIDsField is a NUMINGROUP field +type NoRelatedContextPartySubIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRelatedContextPartySubIDs (1579) +func (f NoRelatedContextPartySubIDsField) Tag() quickfix.Tag { return tag.NoRelatedContextPartySubIDs } + +//NewNoRelatedContextPartySubIDs returns a new NoRelatedContextPartySubIDsField initialized with val +func NewNoRelatedContextPartySubIDs(val int) NoRelatedContextPartySubIDsField { + return NoRelatedContextPartySubIDsField{quickfix.FIXInt(val)} +} + +//NoRelatedPartyAltIDsField is a NUMINGROUP field +type NoRelatedPartyAltIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRelatedPartyAltIDs (1569) +func (f NoRelatedPartyAltIDsField) Tag() quickfix.Tag { return tag.NoRelatedPartyAltIDs } + +//NewNoRelatedPartyAltIDs returns a new NoRelatedPartyAltIDsField initialized with val +func NewNoRelatedPartyAltIDs(val int) NoRelatedPartyAltIDsField { + return NoRelatedPartyAltIDsField{quickfix.FIXInt(val)} +} + +//NoRelatedPartyAltSubIDsField is a NUMINGROUP field +type NoRelatedPartyAltSubIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRelatedPartyAltSubIDs (1572) +func (f NoRelatedPartyAltSubIDsField) Tag() quickfix.Tag { return tag.NoRelatedPartyAltSubIDs } + +//NewNoRelatedPartyAltSubIDs returns a new NoRelatedPartyAltSubIDsField initialized with val +func NewNoRelatedPartyAltSubIDs(val int) NoRelatedPartyAltSubIDsField { + return NoRelatedPartyAltSubIDsField{quickfix.FIXInt(val)} +} + +//NoRelatedPartyIDsField is a NUMINGROUP field +type NoRelatedPartyIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRelatedPartyIDs (1562) +func (f NoRelatedPartyIDsField) Tag() quickfix.Tag { return tag.NoRelatedPartyIDs } + +//NewNoRelatedPartyIDs returns a new NoRelatedPartyIDsField initialized with val +func NewNoRelatedPartyIDs(val int) NoRelatedPartyIDsField { + return NoRelatedPartyIDsField{quickfix.FIXInt(val)} +} + +//NoRelatedPartySubIDsField is a NUMINGROUP field +type NoRelatedPartySubIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRelatedPartySubIDs (1566) +func (f NoRelatedPartySubIDsField) Tag() quickfix.Tag { return tag.NoRelatedPartySubIDs } + +//NewNoRelatedPartySubIDs returns a new NoRelatedPartySubIDsField initialized with val +func NewNoRelatedPartySubIDs(val int) NoRelatedPartySubIDsField { + return NoRelatedPartySubIDsField{quickfix.FIXInt(val)} +} + +//NoRelatedSymField is a NUMINGROUP field +type NoRelatedSymField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRelatedSym (146) +func (f NoRelatedSymField) Tag() quickfix.Tag { return tag.NoRelatedSym } + +//NewNoRelatedSym returns a new NoRelatedSymField initialized with val +func NewNoRelatedSym(val int) NoRelatedSymField { + return NoRelatedSymField{quickfix.FIXInt(val)} +} + +//NoRelationshipRiskInstrumentsField is a NUMINGROUP field +type NoRelationshipRiskInstrumentsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRelationshipRiskInstruments (1587) +func (f NoRelationshipRiskInstrumentsField) Tag() quickfix.Tag { + return tag.NoRelationshipRiskInstruments +} + +//NewNoRelationshipRiskInstruments returns a new NoRelationshipRiskInstrumentsField initialized with val +func NewNoRelationshipRiskInstruments(val int) NoRelationshipRiskInstrumentsField { + return NoRelationshipRiskInstrumentsField{quickfix.FIXInt(val)} +} + +//NoRelationshipRiskLimitsField is a NUMINGROUP field +type NoRelationshipRiskLimitsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRelationshipRiskLimits (1582) +func (f NoRelationshipRiskLimitsField) Tag() quickfix.Tag { return tag.NoRelationshipRiskLimits } + +//NewNoRelationshipRiskLimits returns a new NoRelationshipRiskLimitsField initialized with val +func NewNoRelationshipRiskLimits(val int) NoRelationshipRiskLimitsField { + return NoRelationshipRiskLimitsField{quickfix.FIXInt(val)} +} + +//NoRelationshipRiskSecurityAltIDField is a NUMINGROUP field +type NoRelationshipRiskSecurityAltIDField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRelationshipRiskSecurityAltID (1593) +func (f NoRelationshipRiskSecurityAltIDField) Tag() quickfix.Tag { + return tag.NoRelationshipRiskSecurityAltID +} + +//NewNoRelationshipRiskSecurityAltID returns a new NoRelationshipRiskSecurityAltIDField initialized with val +func NewNoRelationshipRiskSecurityAltID(val int) NoRelationshipRiskSecurityAltIDField { + return NoRelationshipRiskSecurityAltIDField{quickfix.FIXInt(val)} +} + +//NoRelationshipRiskWarningLevelsField is a NUMINGROUP field +type NoRelationshipRiskWarningLevelsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRelationshipRiskWarningLevels (1613) +func (f NoRelationshipRiskWarningLevelsField) Tag() quickfix.Tag { + return tag.NoRelationshipRiskWarningLevels +} + +//NewNoRelationshipRiskWarningLevels returns a new NoRelationshipRiskWarningLevelsField initialized with val +func NewNoRelationshipRiskWarningLevels(val int) NoRelationshipRiskWarningLevelsField { + return NoRelationshipRiskWarningLevelsField{quickfix.FIXInt(val)} +} + +//NoRequestedPartyRolesField is a NUMINGROUP field +type NoRequestedPartyRolesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRequestedPartyRoles (1508) +func (f NoRequestedPartyRolesField) Tag() quickfix.Tag { return tag.NoRequestedPartyRoles } + +//NewNoRequestedPartyRoles returns a new NoRequestedPartyRolesField initialized with val +func NewNoRequestedPartyRoles(val int) NoRequestedPartyRolesField { + return NoRequestedPartyRolesField{quickfix.FIXInt(val)} +} + +//NoRiskInstrumentsField is a NUMINGROUP field +type NoRiskInstrumentsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRiskInstruments (1534) +func (f NoRiskInstrumentsField) Tag() quickfix.Tag { return tag.NoRiskInstruments } + +//NewNoRiskInstruments returns a new NoRiskInstrumentsField initialized with val +func NewNoRiskInstruments(val int) NoRiskInstrumentsField { + return NoRiskInstrumentsField{quickfix.FIXInt(val)} +} + +//NoRiskLimitsField is a NUMINGROUP field +type NoRiskLimitsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRiskLimits (1529) +func (f NoRiskLimitsField) Tag() quickfix.Tag { return tag.NoRiskLimits } + +//NewNoRiskLimits returns a new NoRiskLimitsField initialized with val +func NewNoRiskLimits(val int) NoRiskLimitsField { + return NoRiskLimitsField{quickfix.FIXInt(val)} +} + +//NoRiskSecurityAltIDField is a NUMINGROUP field +type NoRiskSecurityAltIDField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRiskSecurityAltID (1540) +func (f NoRiskSecurityAltIDField) Tag() quickfix.Tag { return tag.NoRiskSecurityAltID } + +//NewNoRiskSecurityAltID returns a new NoRiskSecurityAltIDField initialized with val +func NewNoRiskSecurityAltID(val int) NoRiskSecurityAltIDField { + return NoRiskSecurityAltIDField{quickfix.FIXInt(val)} +} + +//NoRiskWarningLevelsField is a NUMINGROUP field +type NoRiskWarningLevelsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRiskWarningLevels (1559) +func (f NoRiskWarningLevelsField) Tag() quickfix.Tag { return tag.NoRiskWarningLevels } + +//NewNoRiskWarningLevels returns a new NoRiskWarningLevelsField initialized with val +func NewNoRiskWarningLevels(val int) NoRiskWarningLevelsField { + return NoRiskWarningLevelsField{quickfix.FIXInt(val)} +} + +//NoRootPartyIDsField is a NUMINGROUP field +type NoRootPartyIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRootPartyIDs (1116) +func (f NoRootPartyIDsField) Tag() quickfix.Tag { return tag.NoRootPartyIDs } + +//NewNoRootPartyIDs returns a new NoRootPartyIDsField initialized with val +func NewNoRootPartyIDs(val int) NoRootPartyIDsField { + return NoRootPartyIDsField{quickfix.FIXInt(val)} +} + +//NoRootPartySubIDsField is a NUMINGROUP field +type NoRootPartySubIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRootPartySubIDs (1120) +func (f NoRootPartySubIDsField) Tag() quickfix.Tag { return tag.NoRootPartySubIDs } + +//NewNoRootPartySubIDs returns a new NoRootPartySubIDsField initialized with val +func NewNoRootPartySubIDs(val int) NoRootPartySubIDsField { + return NoRootPartySubIDsField{quickfix.FIXInt(val)} +} + +//NoRoutingIDsField is a NUMINGROUP field +type NoRoutingIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRoutingIDs (215) +func (f NoRoutingIDsField) Tag() quickfix.Tag { return tag.NoRoutingIDs } + +//NewNoRoutingIDs returns a new NoRoutingIDsField initialized with val +func NewNoRoutingIDs(val int) NoRoutingIDsField { + return NoRoutingIDsField{quickfix.FIXInt(val)} +} + +//NoRptsField is a INT field +type NoRptsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoRpts (82) +func (f NoRptsField) Tag() quickfix.Tag { return tag.NoRpts } + +//NewNoRpts returns a new NoRptsField initialized with val +func NewNoRpts(val int) NoRptsField { + return NoRptsField{quickfix.FIXInt(val)} +} + +//NoSecurityAltIDField is a NUMINGROUP field +type NoSecurityAltIDField struct{ quickfix.FIXInt } + +//Tag returns tag.NoSecurityAltID (454) +func (f NoSecurityAltIDField) Tag() quickfix.Tag { return tag.NoSecurityAltID } + +//NewNoSecurityAltID returns a new NoSecurityAltIDField initialized with val +func NewNoSecurityAltID(val int) NoSecurityAltIDField { + return NoSecurityAltIDField{quickfix.FIXInt(val)} +} + +//NoSecurityTypesField is a NUMINGROUP field +type NoSecurityTypesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoSecurityTypes (558) +func (f NoSecurityTypesField) Tag() quickfix.Tag { return tag.NoSecurityTypes } + +//NewNoSecurityTypes returns a new NoSecurityTypesField initialized with val +func NewNoSecurityTypes(val int) NoSecurityTypesField { + return NoSecurityTypesField{quickfix.FIXInt(val)} +} + +//NoSettlDetailsField is a NUMINGROUP field +type NoSettlDetailsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoSettlDetails (1158) +func (f NoSettlDetailsField) Tag() quickfix.Tag { return tag.NoSettlDetails } + +//NewNoSettlDetails returns a new NoSettlDetailsField initialized with val +func NewNoSettlDetails(val int) NoSettlDetailsField { + return NoSettlDetailsField{quickfix.FIXInt(val)} +} + +//NoSettlInstField is a NUMINGROUP field +type NoSettlInstField struct{ quickfix.FIXInt } + +//Tag returns tag.NoSettlInst (778) +func (f NoSettlInstField) Tag() quickfix.Tag { return tag.NoSettlInst } + +//NewNoSettlInst returns a new NoSettlInstField initialized with val +func NewNoSettlInst(val int) NoSettlInstField { + return NoSettlInstField{quickfix.FIXInt(val)} +} + +//NoSettlObligField is a NUMINGROUP field +type NoSettlObligField struct{ quickfix.FIXInt } + +//Tag returns tag.NoSettlOblig (1165) +func (f NoSettlObligField) Tag() quickfix.Tag { return tag.NoSettlOblig } + +//NewNoSettlOblig returns a new NoSettlObligField initialized with val +func NewNoSettlOblig(val int) NoSettlObligField { + return NoSettlObligField{quickfix.FIXInt(val)} +} + +//NoSettlPartyIDsField is a NUMINGROUP field +type NoSettlPartyIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoSettlPartyIDs (781) +func (f NoSettlPartyIDsField) Tag() quickfix.Tag { return tag.NoSettlPartyIDs } + +//NewNoSettlPartyIDs returns a new NoSettlPartyIDsField initialized with val +func NewNoSettlPartyIDs(val int) NoSettlPartyIDsField { + return NoSettlPartyIDsField{quickfix.FIXInt(val)} +} + +//NoSettlPartySubIDsField is a NUMINGROUP field +type NoSettlPartySubIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoSettlPartySubIDs (801) +func (f NoSettlPartySubIDsField) Tag() quickfix.Tag { return tag.NoSettlPartySubIDs } + +//NewNoSettlPartySubIDs returns a new NoSettlPartySubIDsField initialized with val +func NewNoSettlPartySubIDs(val int) NoSettlPartySubIDsField { + return NoSettlPartySubIDsField{quickfix.FIXInt(val)} +} + +//NoSideTrdRegTSField is a NUMINGROUP field +type NoSideTrdRegTSField struct{ quickfix.FIXInt } + +//Tag returns tag.NoSideTrdRegTS (1016) +func (f NoSideTrdRegTSField) Tag() quickfix.Tag { return tag.NoSideTrdRegTS } + +//NewNoSideTrdRegTS returns a new NoSideTrdRegTSField initialized with val +func NewNoSideTrdRegTS(val int) NoSideTrdRegTSField { + return NoSideTrdRegTSField{quickfix.FIXInt(val)} +} + +//NoSidesField is a NUMINGROUP field +type NoSidesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoSides (552) +func (f NoSidesField) Tag() quickfix.Tag { return tag.NoSides } + +//NewNoSides returns a new NoSidesField initialized with val +func NewNoSides(val int) NoSidesField { + return NoSidesField{quickfix.FIXInt(val)} +} + +//NoStatsIndicatorsField is a NUMINGROUP field +type NoStatsIndicatorsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoStatsIndicators (1175) +func (f NoStatsIndicatorsField) Tag() quickfix.Tag { return tag.NoStatsIndicators } + +//NewNoStatsIndicators returns a new NoStatsIndicatorsField initialized with val +func NewNoStatsIndicators(val int) NoStatsIndicatorsField { + return NoStatsIndicatorsField{quickfix.FIXInt(val)} +} + +//NoStipulationsField is a NUMINGROUP field +type NoStipulationsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoStipulations (232) +func (f NoStipulationsField) Tag() quickfix.Tag { return tag.NoStipulations } + +//NewNoStipulations returns a new NoStipulationsField initialized with val +func NewNoStipulations(val int) NoStipulationsField { + return NoStipulationsField{quickfix.FIXInt(val)} +} + +//NoStrategyParametersField is a NUMINGROUP field +type NoStrategyParametersField struct{ quickfix.FIXInt } + +//Tag returns tag.NoStrategyParameters (957) +func (f NoStrategyParametersField) Tag() quickfix.Tag { return tag.NoStrategyParameters } + +//NewNoStrategyParameters returns a new NoStrategyParametersField initialized with val +func NewNoStrategyParameters(val int) NoStrategyParametersField { + return NoStrategyParametersField{quickfix.FIXInt(val)} +} + +//NoStrikeRulesField is a NUMINGROUP field +type NoStrikeRulesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoStrikeRules (1201) +func (f NoStrikeRulesField) Tag() quickfix.Tag { return tag.NoStrikeRules } + +//NewNoStrikeRules returns a new NoStrikeRulesField initialized with val +func NewNoStrikeRules(val int) NoStrikeRulesField { + return NoStrikeRulesField{quickfix.FIXInt(val)} +} + +//NoStrikesField is a NUMINGROUP field +type NoStrikesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoStrikes (428) +func (f NoStrikesField) Tag() quickfix.Tag { return tag.NoStrikes } + +//NewNoStrikes returns a new NoStrikesField initialized with val +func NewNoStrikes(val int) NoStrikesField { + return NoStrikesField{quickfix.FIXInt(val)} +} + +//NoTargetPartyIDsField is a NUMINGROUP field +type NoTargetPartyIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoTargetPartyIDs (1461) +func (f NoTargetPartyIDsField) Tag() quickfix.Tag { return tag.NoTargetPartyIDs } + +//NewNoTargetPartyIDs returns a new NoTargetPartyIDsField initialized with val +func NewNoTargetPartyIDs(val int) NoTargetPartyIDsField { + return NoTargetPartyIDsField{quickfix.FIXInt(val)} +} + +//NoTickRulesField is a NUMINGROUP field +type NoTickRulesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoTickRules (1205) +func (f NoTickRulesField) Tag() quickfix.Tag { return tag.NoTickRules } + +//NewNoTickRules returns a new NoTickRulesField initialized with val +func NewNoTickRules(val int) NoTickRulesField { + return NoTickRulesField{quickfix.FIXInt(val)} +} + +//NoTimeInForceRulesField is a NUMINGROUP field +type NoTimeInForceRulesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoTimeInForceRules (1239) +func (f NoTimeInForceRulesField) Tag() quickfix.Tag { return tag.NoTimeInForceRules } + +//NewNoTimeInForceRules returns a new NoTimeInForceRulesField initialized with val +func NewNoTimeInForceRules(val int) NoTimeInForceRulesField { + return NoTimeInForceRulesField{quickfix.FIXInt(val)} +} + +//NoTradesField is a NUMINGROUP field +type NoTradesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoTrades (897) +func (f NoTradesField) Tag() quickfix.Tag { return tag.NoTrades } + +//NewNoTrades returns a new NoTradesField initialized with val +func NewNoTrades(val int) NoTradesField { + return NoTradesField{quickfix.FIXInt(val)} +} + +//NoTradingSessionRulesField is a NUMINGROUP field +type NoTradingSessionRulesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoTradingSessionRules (1309) +func (f NoTradingSessionRulesField) Tag() quickfix.Tag { return tag.NoTradingSessionRules } + +//NewNoTradingSessionRules returns a new NoTradingSessionRulesField initialized with val +func NewNoTradingSessionRules(val int) NoTradingSessionRulesField { + return NoTradingSessionRulesField{quickfix.FIXInt(val)} +} + +//NoTradingSessionsField is a NUMINGROUP field +type NoTradingSessionsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoTradingSessions (386) +func (f NoTradingSessionsField) Tag() quickfix.Tag { return tag.NoTradingSessions } + +//NewNoTradingSessions returns a new NoTradingSessionsField initialized with val +func NewNoTradingSessions(val int) NoTradingSessionsField { + return NoTradingSessionsField{quickfix.FIXInt(val)} +} + +//NoTrdRegTimestampsField is a NUMINGROUP field +type NoTrdRegTimestampsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoTrdRegTimestamps (768) +func (f NoTrdRegTimestampsField) Tag() quickfix.Tag { return tag.NoTrdRegTimestamps } + +//NewNoTrdRegTimestamps returns a new NoTrdRegTimestampsField initialized with val +func NewNoTrdRegTimestamps(val int) NoTrdRegTimestampsField { + return NoTrdRegTimestampsField{quickfix.FIXInt(val)} +} + +//NoTrdRepIndicatorsField is a NUMINGROUP field +type NoTrdRepIndicatorsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoTrdRepIndicators (1387) +func (f NoTrdRepIndicatorsField) Tag() quickfix.Tag { return tag.NoTrdRepIndicators } + +//NewNoTrdRepIndicators returns a new NoTrdRepIndicatorsField initialized with val +func NewNoTrdRepIndicators(val int) NoTrdRepIndicatorsField { + return NoTrdRepIndicatorsField{quickfix.FIXInt(val)} +} + +//NoUnderlyingAmountsField is a NUMINGROUP field +type NoUnderlyingAmountsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoUnderlyingAmounts (984) +func (f NoUnderlyingAmountsField) Tag() quickfix.Tag { return tag.NoUnderlyingAmounts } + +//NewNoUnderlyingAmounts returns a new NoUnderlyingAmountsField initialized with val +func NewNoUnderlyingAmounts(val int) NoUnderlyingAmountsField { + return NoUnderlyingAmountsField{quickfix.FIXInt(val)} +} + +//NoUnderlyingLegSecurityAltIDField is a NUMINGROUP field +type NoUnderlyingLegSecurityAltIDField struct{ quickfix.FIXInt } + +//Tag returns tag.NoUnderlyingLegSecurityAltID (1334) +func (f NoUnderlyingLegSecurityAltIDField) Tag() quickfix.Tag { return tag.NoUnderlyingLegSecurityAltID } + +//NewNoUnderlyingLegSecurityAltID returns a new NoUnderlyingLegSecurityAltIDField initialized with val +func NewNoUnderlyingLegSecurityAltID(val int) NoUnderlyingLegSecurityAltIDField { + return NoUnderlyingLegSecurityAltIDField{quickfix.FIXInt(val)} +} + +//NoUnderlyingSecurityAltIDField is a NUMINGROUP field +type NoUnderlyingSecurityAltIDField struct{ quickfix.FIXInt } + +//Tag returns tag.NoUnderlyingSecurityAltID (457) +func (f NoUnderlyingSecurityAltIDField) Tag() quickfix.Tag { return tag.NoUnderlyingSecurityAltID } + +//NewNoUnderlyingSecurityAltID returns a new NoUnderlyingSecurityAltIDField initialized with val +func NewNoUnderlyingSecurityAltID(val int) NoUnderlyingSecurityAltIDField { + return NoUnderlyingSecurityAltIDField{quickfix.FIXInt(val)} +} + +//NoUnderlyingStipsField is a NUMINGROUP field +type NoUnderlyingStipsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoUnderlyingStips (887) +func (f NoUnderlyingStipsField) Tag() quickfix.Tag { return tag.NoUnderlyingStips } + +//NewNoUnderlyingStips returns a new NoUnderlyingStipsField initialized with val +func NewNoUnderlyingStips(val int) NoUnderlyingStipsField { + return NoUnderlyingStipsField{quickfix.FIXInt(val)} +} + +//NoUnderlyingsField is a NUMINGROUP field +type NoUnderlyingsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoUnderlyings (711) +func (f NoUnderlyingsField) Tag() quickfix.Tag { return tag.NoUnderlyings } + +//NewNoUnderlyings returns a new NoUnderlyingsField initialized with val +func NewNoUnderlyings(val int) NoUnderlyingsField { + return NoUnderlyingsField{quickfix.FIXInt(val)} +} + +//NoUndlyInstrumentPartiesField is a NUMINGROUP field +type NoUndlyInstrumentPartiesField struct{ quickfix.FIXInt } + +//Tag returns tag.NoUndlyInstrumentParties (1058) +func (f NoUndlyInstrumentPartiesField) Tag() quickfix.Tag { return tag.NoUndlyInstrumentParties } + +//NewNoUndlyInstrumentParties returns a new NoUndlyInstrumentPartiesField initialized with val +func NewNoUndlyInstrumentParties(val int) NoUndlyInstrumentPartiesField { + return NoUndlyInstrumentPartiesField{quickfix.FIXInt(val)} +} + +//NoUndlyInstrumentPartySubIDsField is a NUMINGROUP field +type NoUndlyInstrumentPartySubIDsField struct{ quickfix.FIXInt } + +//Tag returns tag.NoUndlyInstrumentPartySubIDs (1062) +func (f NoUndlyInstrumentPartySubIDsField) Tag() quickfix.Tag { return tag.NoUndlyInstrumentPartySubIDs } + +//NewNoUndlyInstrumentPartySubIDs returns a new NoUndlyInstrumentPartySubIDsField initialized with val +func NewNoUndlyInstrumentPartySubIDs(val int) NoUndlyInstrumentPartySubIDsField { + return NoUndlyInstrumentPartySubIDsField{quickfix.FIXInt(val)} +} + +//NotAffOrigClOrdIDField is a STRING field +type NotAffOrigClOrdIDField struct{ quickfix.FIXString } + +//Tag returns tag.NotAffOrigClOrdID (1372) +func (f NotAffOrigClOrdIDField) Tag() quickfix.Tag { return tag.NotAffOrigClOrdID } + +//NewNotAffOrigClOrdID returns a new NotAffOrigClOrdIDField initialized with val +func NewNotAffOrigClOrdID(val string) NotAffOrigClOrdIDField { + return NotAffOrigClOrdIDField{quickfix.FIXString(val)} +} + +//NotAffectedOrderIDField is a STRING field +type NotAffectedOrderIDField struct{ quickfix.FIXString } + +//Tag returns tag.NotAffectedOrderID (1371) +func (f NotAffectedOrderIDField) Tag() quickfix.Tag { return tag.NotAffectedOrderID } + +//NewNotAffectedOrderID returns a new NotAffectedOrderIDField initialized with val +func NewNotAffectedOrderID(val string) NotAffectedOrderIDField { + return NotAffectedOrderIDField{quickfix.FIXString(val)} +} + +//NotifyBrokerOfCreditField is a BOOLEAN field +type NotifyBrokerOfCreditField struct{ quickfix.FIXBoolean } + +//Tag returns tag.NotifyBrokerOfCredit (208) +func (f NotifyBrokerOfCreditField) Tag() quickfix.Tag { return tag.NotifyBrokerOfCredit } + +//NewNotifyBrokerOfCredit returns a new NotifyBrokerOfCreditField initialized with val +func NewNotifyBrokerOfCredit(val bool) NotifyBrokerOfCreditField { + return NotifyBrokerOfCreditField{quickfix.FIXBoolean(val)} +} + +//NotionalPercentageOutstandingField is a PERCENTAGE field +type NotionalPercentageOutstandingField struct{ quickfix.FIXFloat } + +//Tag returns tag.NotionalPercentageOutstanding (1451) +func (f NotionalPercentageOutstandingField) Tag() quickfix.Tag { + return tag.NotionalPercentageOutstanding +} + +//NewNotionalPercentageOutstanding returns a new NotionalPercentageOutstandingField initialized with val +func NewNotionalPercentageOutstanding(val float64) NotionalPercentageOutstandingField { + return NotionalPercentageOutstandingField{quickfix.FIXFloat(val)} +} + +//NumBiddersField is a INT field +type NumBiddersField struct{ quickfix.FIXInt } + +//Tag returns tag.NumBidders (417) +func (f NumBiddersField) Tag() quickfix.Tag { return tag.NumBidders } + +//NewNumBidders returns a new NumBiddersField initialized with val +func NewNumBidders(val int) NumBiddersField { + return NumBiddersField{quickfix.FIXInt(val)} +} + +//NumDaysInterestField is a INT field +type NumDaysInterestField struct{ quickfix.FIXInt } + +//Tag returns tag.NumDaysInterest (157) +func (f NumDaysInterestField) Tag() quickfix.Tag { return tag.NumDaysInterest } + +//NewNumDaysInterest returns a new NumDaysInterestField initialized with val +func NewNumDaysInterest(val int) NumDaysInterestField { + return NumDaysInterestField{quickfix.FIXInt(val)} +} + +//NumTicketsField is a INT field +type NumTicketsField struct{ quickfix.FIXInt } + +//Tag returns tag.NumTickets (395) +func (f NumTicketsField) Tag() quickfix.Tag { return tag.NumTickets } + +//NewNumTickets returns a new NumTicketsField initialized with val +func NewNumTickets(val int) NumTicketsField { + return NumTicketsField{quickfix.FIXInt(val)} +} + +//NumberOfOrdersField is a INT field +type NumberOfOrdersField struct{ quickfix.FIXInt } + +//Tag returns tag.NumberOfOrders (346) +func (f NumberOfOrdersField) Tag() quickfix.Tag { return tag.NumberOfOrders } + +//NewNumberOfOrders returns a new NumberOfOrdersField initialized with val +func NewNumberOfOrders(val int) NumberOfOrdersField { + return NumberOfOrdersField{quickfix.FIXInt(val)} +} + +//OddLotField is a BOOLEAN field +type OddLotField struct{ quickfix.FIXBoolean } + +//Tag returns tag.OddLot (575) +func (f OddLotField) Tag() quickfix.Tag { return tag.OddLot } + +//NewOddLot returns a new OddLotField initialized with val +func NewOddLot(val bool) OddLotField { + return OddLotField{quickfix.FIXBoolean(val)} +} + +//OfferForwardPointsField is a PRICEOFFSET field +type OfferForwardPointsField struct{ quickfix.FIXFloat } + +//Tag returns tag.OfferForwardPoints (191) +func (f OfferForwardPointsField) Tag() quickfix.Tag { return tag.OfferForwardPoints } + +//NewOfferForwardPoints returns a new OfferForwardPointsField initialized with val +func NewOfferForwardPoints(val float64) OfferForwardPointsField { + return OfferForwardPointsField{quickfix.FIXFloat(val)} +} + +//OfferForwardPoints2Field is a PRICEOFFSET field +type OfferForwardPoints2Field struct{ quickfix.FIXFloat } + +//Tag returns tag.OfferForwardPoints2 (643) +func (f OfferForwardPoints2Field) Tag() quickfix.Tag { return tag.OfferForwardPoints2 } + +//NewOfferForwardPoints2 returns a new OfferForwardPoints2Field initialized with val +func NewOfferForwardPoints2(val float64) OfferForwardPoints2Field { + return OfferForwardPoints2Field{quickfix.FIXFloat(val)} +} + +//OfferPxField is a PRICE field +type OfferPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.OfferPx (133) +func (f OfferPxField) Tag() quickfix.Tag { return tag.OfferPx } + +//NewOfferPx returns a new OfferPxField initialized with val +func NewOfferPx(val float64) OfferPxField { + return OfferPxField{quickfix.FIXFloat(val)} +} + +//OfferSizeField is a QTY field +type OfferSizeField struct{ quickfix.FIXFloat } + +//Tag returns tag.OfferSize (135) +func (f OfferSizeField) Tag() quickfix.Tag { return tag.OfferSize } + +//NewOfferSize returns a new OfferSizeField initialized with val +func NewOfferSize(val float64) OfferSizeField { + return OfferSizeField{quickfix.FIXFloat(val)} +} + +//OfferSpotRateField is a PRICE field +type OfferSpotRateField struct{ quickfix.FIXFloat } + +//Tag returns tag.OfferSpotRate (190) +func (f OfferSpotRateField) Tag() quickfix.Tag { return tag.OfferSpotRate } + +//NewOfferSpotRate returns a new OfferSpotRateField initialized with val +func NewOfferSpotRate(val float64) OfferSpotRateField { + return OfferSpotRateField{quickfix.FIXFloat(val)} +} + +//OfferSwapPointsField is a PRICEOFFSET field +type OfferSwapPointsField struct{ quickfix.FIXFloat } + +//Tag returns tag.OfferSwapPoints (1066) +func (f OfferSwapPointsField) Tag() quickfix.Tag { return tag.OfferSwapPoints } + +//NewOfferSwapPoints returns a new OfferSwapPointsField initialized with val +func NewOfferSwapPoints(val float64) OfferSwapPointsField { + return OfferSwapPointsField{quickfix.FIXFloat(val)} +} + +//OfferYieldField is a PERCENTAGE field +type OfferYieldField struct{ quickfix.FIXFloat } + +//Tag returns tag.OfferYield (634) +func (f OfferYieldField) Tag() quickfix.Tag { return tag.OfferYield } + +//NewOfferYield returns a new OfferYieldField initialized with val +func NewOfferYield(val float64) OfferYieldField { + return OfferYieldField{quickfix.FIXFloat(val)} +} + +//OnBehalfOfCompIDField is a STRING field +type OnBehalfOfCompIDField struct{ quickfix.FIXString } + +//Tag returns tag.OnBehalfOfCompID (115) +func (f OnBehalfOfCompIDField) Tag() quickfix.Tag { return tag.OnBehalfOfCompID } + +//NewOnBehalfOfCompID returns a new OnBehalfOfCompIDField initialized with val +func NewOnBehalfOfCompID(val string) OnBehalfOfCompIDField { + return OnBehalfOfCompIDField{quickfix.FIXString(val)} +} + +//OnBehalfOfLocationIDField is a STRING field +type OnBehalfOfLocationIDField struct{ quickfix.FIXString } + +//Tag returns tag.OnBehalfOfLocationID (144) +func (f OnBehalfOfLocationIDField) Tag() quickfix.Tag { return tag.OnBehalfOfLocationID } + +//NewOnBehalfOfLocationID returns a new OnBehalfOfLocationIDField initialized with val +func NewOnBehalfOfLocationID(val string) OnBehalfOfLocationIDField { + return OnBehalfOfLocationIDField{quickfix.FIXString(val)} +} + +//OnBehalfOfSendingTimeField is a UTCTIMESTAMP field +type OnBehalfOfSendingTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.OnBehalfOfSendingTime (370) +func (f OnBehalfOfSendingTimeField) Tag() quickfix.Tag { return tag.OnBehalfOfSendingTime } + +//NewOnBehalfOfSendingTime returns a new OnBehalfOfSendingTimeField initialized with val +func NewOnBehalfOfSendingTime(val time.Time) OnBehalfOfSendingTimeField { + return OnBehalfOfSendingTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewOnBehalfOfSendingTimeNoMillis returns a new OnBehalfOfSendingTimeField initialized with val without millisecs +func NewOnBehalfOfSendingTimeNoMillis(val time.Time) OnBehalfOfSendingTimeField { + return OnBehalfOfSendingTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//OnBehalfOfSubIDField is a STRING field +type OnBehalfOfSubIDField struct{ quickfix.FIXString } + +//Tag returns tag.OnBehalfOfSubID (116) +func (f OnBehalfOfSubIDField) Tag() quickfix.Tag { return tag.OnBehalfOfSubID } + +//NewOnBehalfOfSubID returns a new OnBehalfOfSubIDField initialized with val +func NewOnBehalfOfSubID(val string) OnBehalfOfSubIDField { + return OnBehalfOfSubIDField{quickfix.FIXString(val)} +} + +//OpenCloseField is a CHAR field +type OpenCloseField struct{ quickfix.FIXString } + +//Tag returns tag.OpenClose (77) +func (f OpenCloseField) Tag() quickfix.Tag { return tag.OpenClose } + +//NewOpenClose returns a new OpenCloseField initialized with val +func NewOpenClose(val string) OpenCloseField { + return OpenCloseField{quickfix.FIXString(val)} +} + +//OpenCloseSettlFlagField is a MULTIPLECHARVALUE field +type OpenCloseSettlFlagField struct{ quickfix.FIXString } + +//Tag returns tag.OpenCloseSettlFlag (286) +func (f OpenCloseSettlFlagField) Tag() quickfix.Tag { return tag.OpenCloseSettlFlag } + +//NewOpenCloseSettlFlag returns a new OpenCloseSettlFlagField initialized with val +func NewOpenCloseSettlFlag(val string) OpenCloseSettlFlagField { + return OpenCloseSettlFlagField{quickfix.FIXString(val)} +} + +//OpenCloseSettleFlagField is a MULTIPLEVALUESTRING field +type OpenCloseSettleFlagField struct{ quickfix.FIXString } + +//Tag returns tag.OpenCloseSettleFlag (286) +func (f OpenCloseSettleFlagField) Tag() quickfix.Tag { return tag.OpenCloseSettleFlag } + +//NewOpenCloseSettleFlag returns a new OpenCloseSettleFlagField initialized with val +func NewOpenCloseSettleFlag(val string) OpenCloseSettleFlagField { + return OpenCloseSettleFlagField{quickfix.FIXString(val)} +} + +//OpenInterestField is a AMT field +type OpenInterestField struct{ quickfix.FIXFloat } + +//Tag returns tag.OpenInterest (746) +func (f OpenInterestField) Tag() quickfix.Tag { return tag.OpenInterest } + +//NewOpenInterest returns a new OpenInterestField initialized with val +func NewOpenInterest(val float64) OpenInterestField { + return OpenInterestField{quickfix.FIXFloat(val)} +} + +//OptAttributeField is a CHAR field +type OptAttributeField struct{ quickfix.FIXString } + +//Tag returns tag.OptAttribute (206) +func (f OptAttributeField) Tag() quickfix.Tag { return tag.OptAttribute } + +//NewOptAttribute returns a new OptAttributeField initialized with val +func NewOptAttribute(val string) OptAttributeField { + return OptAttributeField{quickfix.FIXString(val)} +} + +//OptPayAmountField is a AMT field +type OptPayAmountField struct{ quickfix.FIXFloat } + +//Tag returns tag.OptPayAmount (1195) +func (f OptPayAmountField) Tag() quickfix.Tag { return tag.OptPayAmount } + +//NewOptPayAmount returns a new OptPayAmountField initialized with val +func NewOptPayAmount(val float64) OptPayAmountField { + return OptPayAmountField{quickfix.FIXFloat(val)} +} + +//OptPayoutAmountField is a AMT field +type OptPayoutAmountField struct{ quickfix.FIXFloat } + +//Tag returns tag.OptPayoutAmount (1195) +func (f OptPayoutAmountField) Tag() quickfix.Tag { return tag.OptPayoutAmount } + +//NewOptPayoutAmount returns a new OptPayoutAmountField initialized with val +func NewOptPayoutAmount(val float64) OptPayoutAmountField { + return OptPayoutAmountField{quickfix.FIXFloat(val)} +} + +//OptPayoutTypeField is a INT field +type OptPayoutTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.OptPayoutType (1482) +func (f OptPayoutTypeField) Tag() quickfix.Tag { return tag.OptPayoutType } + +//NewOptPayoutType returns a new OptPayoutTypeField initialized with val +func NewOptPayoutType(val int) OptPayoutTypeField { + return OptPayoutTypeField{quickfix.FIXInt(val)} +} + +//OrdRejReasonField is a INT field +type OrdRejReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.OrdRejReason (103) +func (f OrdRejReasonField) Tag() quickfix.Tag { return tag.OrdRejReason } + +//NewOrdRejReason returns a new OrdRejReasonField initialized with val +func NewOrdRejReason(val int) OrdRejReasonField { + return OrdRejReasonField{quickfix.FIXInt(val)} +} + +//OrdStatusField is a CHAR field +type OrdStatusField struct{ quickfix.FIXString } + +//Tag returns tag.OrdStatus (39) +func (f OrdStatusField) Tag() quickfix.Tag { return tag.OrdStatus } + +//NewOrdStatus returns a new OrdStatusField initialized with val +func NewOrdStatus(val string) OrdStatusField { + return OrdStatusField{quickfix.FIXString(val)} +} + +//OrdStatusReqIDField is a STRING field +type OrdStatusReqIDField struct{ quickfix.FIXString } + +//Tag returns tag.OrdStatusReqID (790) +func (f OrdStatusReqIDField) Tag() quickfix.Tag { return tag.OrdStatusReqID } + +//NewOrdStatusReqID returns a new OrdStatusReqIDField initialized with val +func NewOrdStatusReqID(val string) OrdStatusReqIDField { + return OrdStatusReqIDField{quickfix.FIXString(val)} +} + +//OrdTypeField is a CHAR field +type OrdTypeField struct{ quickfix.FIXString } + +//Tag returns tag.OrdType (40) +func (f OrdTypeField) Tag() quickfix.Tag { return tag.OrdType } + +//NewOrdType returns a new OrdTypeField initialized with val +func NewOrdType(val string) OrdTypeField { + return OrdTypeField{quickfix.FIXString(val)} +} + +//OrderAvgPxField is a PRICE field +type OrderAvgPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.OrderAvgPx (799) +func (f OrderAvgPxField) Tag() quickfix.Tag { return tag.OrderAvgPx } + +//NewOrderAvgPx returns a new OrderAvgPxField initialized with val +func NewOrderAvgPx(val float64) OrderAvgPxField { + return OrderAvgPxField{quickfix.FIXFloat(val)} +} + +//OrderBookingQtyField is a QTY field +type OrderBookingQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.OrderBookingQty (800) +func (f OrderBookingQtyField) Tag() quickfix.Tag { return tag.OrderBookingQty } + +//NewOrderBookingQty returns a new OrderBookingQtyField initialized with val +func NewOrderBookingQty(val float64) OrderBookingQtyField { + return OrderBookingQtyField{quickfix.FIXFloat(val)} +} + +//OrderCapacityField is a CHAR field +type OrderCapacityField struct{ quickfix.FIXString } + +//Tag returns tag.OrderCapacity (528) +func (f OrderCapacityField) Tag() quickfix.Tag { return tag.OrderCapacity } + +//NewOrderCapacity returns a new OrderCapacityField initialized with val +func NewOrderCapacity(val string) OrderCapacityField { + return OrderCapacityField{quickfix.FIXString(val)} +} + +//OrderCapacityQtyField is a QTY field +type OrderCapacityQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.OrderCapacityQty (863) +func (f OrderCapacityQtyField) Tag() quickfix.Tag { return tag.OrderCapacityQty } + +//NewOrderCapacityQty returns a new OrderCapacityQtyField initialized with val +func NewOrderCapacityQty(val float64) OrderCapacityQtyField { + return OrderCapacityQtyField{quickfix.FIXFloat(val)} +} + +//OrderCategoryField is a CHAR field +type OrderCategoryField struct{ quickfix.FIXString } + +//Tag returns tag.OrderCategory (1115) +func (f OrderCategoryField) Tag() quickfix.Tag { return tag.OrderCategory } + +//NewOrderCategory returns a new OrderCategoryField initialized with val +func NewOrderCategory(val string) OrderCategoryField { + return OrderCategoryField{quickfix.FIXString(val)} +} + +//OrderDelayField is a INT field +type OrderDelayField struct{ quickfix.FIXInt } + +//Tag returns tag.OrderDelay (1428) +func (f OrderDelayField) Tag() quickfix.Tag { return tag.OrderDelay } + +//NewOrderDelay returns a new OrderDelayField initialized with val +func NewOrderDelay(val int) OrderDelayField { + return OrderDelayField{quickfix.FIXInt(val)} +} + +//OrderDelayUnitField is a INT field +type OrderDelayUnitField struct{ quickfix.FIXInt } + +//Tag returns tag.OrderDelayUnit (1429) +func (f OrderDelayUnitField) Tag() quickfix.Tag { return tag.OrderDelayUnit } + +//NewOrderDelayUnit returns a new OrderDelayUnitField initialized with val +func NewOrderDelayUnit(val int) OrderDelayUnitField { + return OrderDelayUnitField{quickfix.FIXInt(val)} +} + +//OrderHandlingInstSourceField is a INT field +type OrderHandlingInstSourceField struct{ quickfix.FIXInt } + +//Tag returns tag.OrderHandlingInstSource (1032) +func (f OrderHandlingInstSourceField) Tag() quickfix.Tag { return tag.OrderHandlingInstSource } + +//NewOrderHandlingInstSource returns a new OrderHandlingInstSourceField initialized with val +func NewOrderHandlingInstSource(val int) OrderHandlingInstSourceField { + return OrderHandlingInstSourceField{quickfix.FIXInt(val)} +} + +//OrderIDField is a STRING field +type OrderIDField struct{ quickfix.FIXString } + +//Tag returns tag.OrderID (37) +func (f OrderIDField) Tag() quickfix.Tag { return tag.OrderID } + +//NewOrderID returns a new OrderIDField initialized with val +func NewOrderID(val string) OrderIDField { + return OrderIDField{quickfix.FIXString(val)} +} + +//OrderInputDeviceField is a STRING field +type OrderInputDeviceField struct{ quickfix.FIXString } + +//Tag returns tag.OrderInputDevice (821) +func (f OrderInputDeviceField) Tag() quickfix.Tag { return tag.OrderInputDevice } + +//NewOrderInputDevice returns a new OrderInputDeviceField initialized with val +func NewOrderInputDevice(val string) OrderInputDeviceField { + return OrderInputDeviceField{quickfix.FIXString(val)} +} + +//OrderPercentField is a PERCENTAGE field +type OrderPercentField struct{ quickfix.FIXFloat } + +//Tag returns tag.OrderPercent (516) +func (f OrderPercentField) Tag() quickfix.Tag { return tag.OrderPercent } + +//NewOrderPercent returns a new OrderPercentField initialized with val +func NewOrderPercent(val float64) OrderPercentField { + return OrderPercentField{quickfix.FIXFloat(val)} +} + +//OrderQtyField is a QTY field +type OrderQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.OrderQty (38) +func (f OrderQtyField) Tag() quickfix.Tag { return tag.OrderQty } + +//NewOrderQty returns a new OrderQtyField initialized with val +func NewOrderQty(val float64) OrderQtyField { + return OrderQtyField{quickfix.FIXFloat(val)} +} + +//OrderQty2Field is a QTY field +type OrderQty2Field struct{ quickfix.FIXFloat } + +//Tag returns tag.OrderQty2 (192) +func (f OrderQty2Field) Tag() quickfix.Tag { return tag.OrderQty2 } + +//NewOrderQty2 returns a new OrderQty2Field initialized with val +func NewOrderQty2(val float64) OrderQty2Field { + return OrderQty2Field{quickfix.FIXFloat(val)} +} + +//OrderRestrictionsField is a MULTIPLECHARVALUE field +type OrderRestrictionsField struct{ quickfix.FIXString } + +//Tag returns tag.OrderRestrictions (529) +func (f OrderRestrictionsField) Tag() quickfix.Tag { return tag.OrderRestrictions } + +//NewOrderRestrictions returns a new OrderRestrictionsField initialized with val +func NewOrderRestrictions(val string) OrderRestrictionsField { + return OrderRestrictionsField{quickfix.FIXString(val)} +} + +//OrigClOrdIDField is a STRING field +type OrigClOrdIDField struct{ quickfix.FIXString } + +//Tag returns tag.OrigClOrdID (41) +func (f OrigClOrdIDField) Tag() quickfix.Tag { return tag.OrigClOrdID } + +//NewOrigClOrdID returns a new OrigClOrdIDField initialized with val +func NewOrigClOrdID(val string) OrigClOrdIDField { + return OrigClOrdIDField{quickfix.FIXString(val)} +} + +//OrigCrossIDField is a STRING field +type OrigCrossIDField struct{ quickfix.FIXString } + +//Tag returns tag.OrigCrossID (551) +func (f OrigCrossIDField) Tag() quickfix.Tag { return tag.OrigCrossID } + +//NewOrigCrossID returns a new OrigCrossIDField initialized with val +func NewOrigCrossID(val string) OrigCrossIDField { + return OrigCrossIDField{quickfix.FIXString(val)} +} + +//OrigCustOrderCapacityField is a INT field +type OrigCustOrderCapacityField struct{ quickfix.FIXInt } + +//Tag returns tag.OrigCustOrderCapacity (1432) +func (f OrigCustOrderCapacityField) Tag() quickfix.Tag { return tag.OrigCustOrderCapacity } + +//NewOrigCustOrderCapacity returns a new OrigCustOrderCapacityField initialized with val +func NewOrigCustOrderCapacity(val int) OrigCustOrderCapacityField { + return OrigCustOrderCapacityField{quickfix.FIXInt(val)} +} + +//OrigOrdModTimeField is a UTCTIMESTAMP field +type OrigOrdModTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.OrigOrdModTime (586) +func (f OrigOrdModTimeField) Tag() quickfix.Tag { return tag.OrigOrdModTime } + +//NewOrigOrdModTime returns a new OrigOrdModTimeField initialized with val +func NewOrigOrdModTime(val time.Time) OrigOrdModTimeField { + return OrigOrdModTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewOrigOrdModTimeNoMillis returns a new OrigOrdModTimeField initialized with val without millisecs +func NewOrigOrdModTimeNoMillis(val time.Time) OrigOrdModTimeField { + return OrigOrdModTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//OrigPosReqRefIDField is a STRING field +type OrigPosReqRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.OrigPosReqRefID (713) +func (f OrigPosReqRefIDField) Tag() quickfix.Tag { return tag.OrigPosReqRefID } + +//NewOrigPosReqRefID returns a new OrigPosReqRefIDField initialized with val +func NewOrigPosReqRefID(val string) OrigPosReqRefIDField { + return OrigPosReqRefIDField{quickfix.FIXString(val)} +} + +//OrigSecondaryTradeIDField is a STRING field +type OrigSecondaryTradeIDField struct{ quickfix.FIXString } + +//Tag returns tag.OrigSecondaryTradeID (1127) +func (f OrigSecondaryTradeIDField) Tag() quickfix.Tag { return tag.OrigSecondaryTradeID } + +//NewOrigSecondaryTradeID returns a new OrigSecondaryTradeIDField initialized with val +func NewOrigSecondaryTradeID(val string) OrigSecondaryTradeIDField { + return OrigSecondaryTradeIDField{quickfix.FIXString(val)} +} + +//OrigSendingTimeField is a UTCTIMESTAMP field +type OrigSendingTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.OrigSendingTime (122) +func (f OrigSendingTimeField) Tag() quickfix.Tag { return tag.OrigSendingTime } + +//NewOrigSendingTime returns a new OrigSendingTimeField initialized with val +func NewOrigSendingTime(val time.Time) OrigSendingTimeField { + return OrigSendingTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewOrigSendingTimeNoMillis returns a new OrigSendingTimeField initialized with val without millisecs +func NewOrigSendingTimeNoMillis(val time.Time) OrigSendingTimeField { + return OrigSendingTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//OrigTimeField is a UTCTIMESTAMP field +type OrigTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.OrigTime (42) +func (f OrigTimeField) Tag() quickfix.Tag { return tag.OrigTime } + +//NewOrigTime returns a new OrigTimeField initialized with val +func NewOrigTime(val time.Time) OrigTimeField { + return OrigTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewOrigTimeNoMillis returns a new OrigTimeField initialized with val without millisecs +func NewOrigTimeNoMillis(val time.Time) OrigTimeField { + return OrigTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//OrigTradeDateField is a LOCALMKTDATE field +type OrigTradeDateField struct{ quickfix.FIXString } + +//Tag returns tag.OrigTradeDate (1125) +func (f OrigTradeDateField) Tag() quickfix.Tag { return tag.OrigTradeDate } + +//NewOrigTradeDate returns a new OrigTradeDateField initialized with val +func NewOrigTradeDate(val string) OrigTradeDateField { + return OrigTradeDateField{quickfix.FIXString(val)} +} + +//OrigTradeHandlingInstrField is a CHAR field +type OrigTradeHandlingInstrField struct{ quickfix.FIXString } + +//Tag returns tag.OrigTradeHandlingInstr (1124) +func (f OrigTradeHandlingInstrField) Tag() quickfix.Tag { return tag.OrigTradeHandlingInstr } + +//NewOrigTradeHandlingInstr returns a new OrigTradeHandlingInstrField initialized with val +func NewOrigTradeHandlingInstr(val string) OrigTradeHandlingInstrField { + return OrigTradeHandlingInstrField{quickfix.FIXString(val)} +} + +//OrigTradeIDField is a STRING field +type OrigTradeIDField struct{ quickfix.FIXString } + +//Tag returns tag.OrigTradeID (1126) +func (f OrigTradeIDField) Tag() quickfix.Tag { return tag.OrigTradeID } + +//NewOrigTradeID returns a new OrigTradeIDField initialized with val +func NewOrigTradeID(val string) OrigTradeIDField { + return OrigTradeIDField{quickfix.FIXString(val)} +} + +//OriginalNotionalPercentageOutstandingField is a PERCENTAGE field +type OriginalNotionalPercentageOutstandingField struct{ quickfix.FIXFloat } + +//Tag returns tag.OriginalNotionalPercentageOutstanding (1452) +func (f OriginalNotionalPercentageOutstandingField) Tag() quickfix.Tag { + return tag.OriginalNotionalPercentageOutstanding +} + +//NewOriginalNotionalPercentageOutstanding returns a new OriginalNotionalPercentageOutstandingField initialized with val +func NewOriginalNotionalPercentageOutstanding(val float64) OriginalNotionalPercentageOutstandingField { + return OriginalNotionalPercentageOutstandingField{quickfix.FIXFloat(val)} +} + +//OutMainCntryUIndexField is a AMT field +type OutMainCntryUIndexField struct{ quickfix.FIXFloat } + +//Tag returns tag.OutMainCntryUIndex (412) +func (f OutMainCntryUIndexField) Tag() quickfix.Tag { return tag.OutMainCntryUIndex } + +//NewOutMainCntryUIndex returns a new OutMainCntryUIndexField initialized with val +func NewOutMainCntryUIndex(val float64) OutMainCntryUIndexField { + return OutMainCntryUIndexField{quickfix.FIXFloat(val)} +} + +//OutsideIndexPctField is a PERCENTAGE field +type OutsideIndexPctField struct{ quickfix.FIXFloat } + +//Tag returns tag.OutsideIndexPct (407) +func (f OutsideIndexPctField) Tag() quickfix.Tag { return tag.OutsideIndexPct } + +//NewOutsideIndexPct returns a new OutsideIndexPctField initialized with val +func NewOutsideIndexPct(val float64) OutsideIndexPctField { + return OutsideIndexPctField{quickfix.FIXFloat(val)} +} + +//OwnerTypeField is a INT field +type OwnerTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.OwnerType (522) +func (f OwnerTypeField) Tag() quickfix.Tag { return tag.OwnerType } + +//NewOwnerType returns a new OwnerTypeField initialized with val +func NewOwnerType(val int) OwnerTypeField { + return OwnerTypeField{quickfix.FIXInt(val)} +} + +//OwnershipTypeField is a CHAR field +type OwnershipTypeField struct{ quickfix.FIXString } + +//Tag returns tag.OwnershipType (517) +func (f OwnershipTypeField) Tag() quickfix.Tag { return tag.OwnershipType } + +//NewOwnershipType returns a new OwnershipTypeField initialized with val +func NewOwnershipType(val string) OwnershipTypeField { + return OwnershipTypeField{quickfix.FIXString(val)} +} + +//ParentMktSegmIDField is a STRING field +type ParentMktSegmIDField struct{ quickfix.FIXString } + +//Tag returns tag.ParentMktSegmID (1325) +func (f ParentMktSegmIDField) Tag() quickfix.Tag { return tag.ParentMktSegmID } + +//NewParentMktSegmID returns a new ParentMktSegmIDField initialized with val +func NewParentMktSegmID(val string) ParentMktSegmIDField { + return ParentMktSegmIDField{quickfix.FIXString(val)} +} + +//ParticipationRateField is a PERCENTAGE field +type ParticipationRateField struct{ quickfix.FIXFloat } + +//Tag returns tag.ParticipationRate (849) +func (f ParticipationRateField) Tag() quickfix.Tag { return tag.ParticipationRate } + +//NewParticipationRate returns a new ParticipationRateField initialized with val +func NewParticipationRate(val float64) ParticipationRateField { + return ParticipationRateField{quickfix.FIXFloat(val)} +} + +//PartyAltIDField is a STRING field +type PartyAltIDField struct{ quickfix.FIXString } + +//Tag returns tag.PartyAltID (1517) +func (f PartyAltIDField) Tag() quickfix.Tag { return tag.PartyAltID } + +//NewPartyAltID returns a new PartyAltIDField initialized with val +func NewPartyAltID(val string) PartyAltIDField { + return PartyAltIDField{quickfix.FIXString(val)} +} + +//PartyAltIDSourceField is a CHAR field +type PartyAltIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.PartyAltIDSource (1518) +func (f PartyAltIDSourceField) Tag() quickfix.Tag { return tag.PartyAltIDSource } + +//NewPartyAltIDSource returns a new PartyAltIDSourceField initialized with val +func NewPartyAltIDSource(val string) PartyAltIDSourceField { + return PartyAltIDSourceField{quickfix.FIXString(val)} +} + +//PartyAltSubIDField is a STRING field +type PartyAltSubIDField struct{ quickfix.FIXString } + +//Tag returns tag.PartyAltSubID (1520) +func (f PartyAltSubIDField) Tag() quickfix.Tag { return tag.PartyAltSubID } + +//NewPartyAltSubID returns a new PartyAltSubIDField initialized with val +func NewPartyAltSubID(val string) PartyAltSubIDField { + return PartyAltSubIDField{quickfix.FIXString(val)} +} + +//PartyAltSubIDTypeField is a INT field +type PartyAltSubIDTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.PartyAltSubIDType (1521) +func (f PartyAltSubIDTypeField) Tag() quickfix.Tag { return tag.PartyAltSubIDType } + +//NewPartyAltSubIDType returns a new PartyAltSubIDTypeField initialized with val +func NewPartyAltSubIDType(val int) PartyAltSubIDTypeField { + return PartyAltSubIDTypeField{quickfix.FIXInt(val)} +} + +//PartyDetailsListReportIDField is a STRING field +type PartyDetailsListReportIDField struct{ quickfix.FIXString } + +//Tag returns tag.PartyDetailsListReportID (1510) +func (f PartyDetailsListReportIDField) Tag() quickfix.Tag { return tag.PartyDetailsListReportID } + +//NewPartyDetailsListReportID returns a new PartyDetailsListReportIDField initialized with val +func NewPartyDetailsListReportID(val string) PartyDetailsListReportIDField { + return PartyDetailsListReportIDField{quickfix.FIXString(val)} +} + +//PartyDetailsListRequestIDField is a STRING field +type PartyDetailsListRequestIDField struct{ quickfix.FIXString } + +//Tag returns tag.PartyDetailsListRequestID (1505) +func (f PartyDetailsListRequestIDField) Tag() quickfix.Tag { return tag.PartyDetailsListRequestID } + +//NewPartyDetailsListRequestID returns a new PartyDetailsListRequestIDField initialized with val +func NewPartyDetailsListRequestID(val string) PartyDetailsListRequestIDField { + return PartyDetailsListRequestIDField{quickfix.FIXString(val)} +} + +//PartyDetailsRequestResultField is a INT field +type PartyDetailsRequestResultField struct{ quickfix.FIXInt } + +//Tag returns tag.PartyDetailsRequestResult (1511) +func (f PartyDetailsRequestResultField) Tag() quickfix.Tag { return tag.PartyDetailsRequestResult } + +//NewPartyDetailsRequestResult returns a new PartyDetailsRequestResultField initialized with val +func NewPartyDetailsRequestResult(val int) PartyDetailsRequestResultField { + return PartyDetailsRequestResultField{quickfix.FIXInt(val)} +} + +//PartyIDField is a STRING field +type PartyIDField struct{ quickfix.FIXString } + +//Tag returns tag.PartyID (448) +func (f PartyIDField) Tag() quickfix.Tag { return tag.PartyID } + +//NewPartyID returns a new PartyIDField initialized with val +func NewPartyID(val string) PartyIDField { + return PartyIDField{quickfix.FIXString(val)} +} + +//PartyIDSourceField is a CHAR field +type PartyIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.PartyIDSource (447) +func (f PartyIDSourceField) Tag() quickfix.Tag { return tag.PartyIDSource } + +//NewPartyIDSource returns a new PartyIDSourceField initialized with val +func NewPartyIDSource(val string) PartyIDSourceField { + return PartyIDSourceField{quickfix.FIXString(val)} +} + +//PartyListResponseTypeField is a INT field +type PartyListResponseTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.PartyListResponseType (1507) +func (f PartyListResponseTypeField) Tag() quickfix.Tag { return tag.PartyListResponseType } + +//NewPartyListResponseType returns a new PartyListResponseTypeField initialized with val +func NewPartyListResponseType(val int) PartyListResponseTypeField { + return PartyListResponseTypeField{quickfix.FIXInt(val)} +} + +//PartyRelationshipField is a INT field +type PartyRelationshipField struct{ quickfix.FIXInt } + +//Tag returns tag.PartyRelationship (1515) +func (f PartyRelationshipField) Tag() quickfix.Tag { return tag.PartyRelationship } + +//NewPartyRelationship returns a new PartyRelationshipField initialized with val +func NewPartyRelationship(val int) PartyRelationshipField { + return PartyRelationshipField{quickfix.FIXInt(val)} +} + +//PartyRoleField is a INT field +type PartyRoleField struct{ quickfix.FIXInt } + +//Tag returns tag.PartyRole (452) +func (f PartyRoleField) Tag() quickfix.Tag { return tag.PartyRole } + +//NewPartyRole returns a new PartyRoleField initialized with val +func NewPartyRole(val int) PartyRoleField { + return PartyRoleField{quickfix.FIXInt(val)} +} + +//PartySubIDField is a STRING field +type PartySubIDField struct{ quickfix.FIXString } + +//Tag returns tag.PartySubID (523) +func (f PartySubIDField) Tag() quickfix.Tag { return tag.PartySubID } + +//NewPartySubID returns a new PartySubIDField initialized with val +func NewPartySubID(val string) PartySubIDField { + return PartySubIDField{quickfix.FIXString(val)} +} + +//PartySubIDTypeField is a INT field +type PartySubIDTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.PartySubIDType (803) +func (f PartySubIDTypeField) Tag() quickfix.Tag { return tag.PartySubIDType } + +//NewPartySubIDType returns a new PartySubIDTypeField initialized with val +func NewPartySubIDType(val int) PartySubIDTypeField { + return PartySubIDTypeField{quickfix.FIXInt(val)} +} + +//PasswordField is a STRING field +type PasswordField struct{ quickfix.FIXString } + +//Tag returns tag.Password (554) +func (f PasswordField) Tag() quickfix.Tag { return tag.Password } + +//NewPassword returns a new PasswordField initialized with val +func NewPassword(val string) PasswordField { + return PasswordField{quickfix.FIXString(val)} +} + +//PaymentDateField is a LOCALMKTDATE field +type PaymentDateField struct{ quickfix.FIXString } + +//Tag returns tag.PaymentDate (504) +func (f PaymentDateField) Tag() quickfix.Tag { return tag.PaymentDate } + +//NewPaymentDate returns a new PaymentDateField initialized with val +func NewPaymentDate(val string) PaymentDateField { + return PaymentDateField{quickfix.FIXString(val)} +} + +//PaymentMethodField is a INT field +type PaymentMethodField struct{ quickfix.FIXInt } + +//Tag returns tag.PaymentMethod (492) +func (f PaymentMethodField) Tag() quickfix.Tag { return tag.PaymentMethod } + +//NewPaymentMethod returns a new PaymentMethodField initialized with val +func NewPaymentMethod(val int) PaymentMethodField { + return PaymentMethodField{quickfix.FIXInt(val)} +} + +//PaymentRefField is a STRING field +type PaymentRefField struct{ quickfix.FIXString } + +//Tag returns tag.PaymentRef (476) +func (f PaymentRefField) Tag() quickfix.Tag { return tag.PaymentRef } + +//NewPaymentRef returns a new PaymentRefField initialized with val +func NewPaymentRef(val string) PaymentRefField { + return PaymentRefField{quickfix.FIXString(val)} +} + +//PaymentRemitterIDField is a STRING field +type PaymentRemitterIDField struct{ quickfix.FIXString } + +//Tag returns tag.PaymentRemitterID (505) +func (f PaymentRemitterIDField) Tag() quickfix.Tag { return tag.PaymentRemitterID } + +//NewPaymentRemitterID returns a new PaymentRemitterIDField initialized with val +func NewPaymentRemitterID(val string) PaymentRemitterIDField { + return PaymentRemitterIDField{quickfix.FIXString(val)} +} + +//PctAtRiskField is a PERCENTAGE field +type PctAtRiskField struct{ quickfix.FIXFloat } + +//Tag returns tag.PctAtRisk (869) +func (f PctAtRiskField) Tag() quickfix.Tag { return tag.PctAtRisk } + +//NewPctAtRisk returns a new PctAtRiskField initialized with val +func NewPctAtRisk(val float64) PctAtRiskField { + return PctAtRiskField{quickfix.FIXFloat(val)} +} + +//PegDifferenceField is a PRICEOFFSET field +type PegDifferenceField struct{ quickfix.FIXFloat } + +//Tag returns tag.PegDifference (211) +func (f PegDifferenceField) Tag() quickfix.Tag { return tag.PegDifference } + +//NewPegDifference returns a new PegDifferenceField initialized with val +func NewPegDifference(val float64) PegDifferenceField { + return PegDifferenceField{quickfix.FIXFloat(val)} +} + +//PegLimitTypeField is a INT field +type PegLimitTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.PegLimitType (837) +func (f PegLimitTypeField) Tag() quickfix.Tag { return tag.PegLimitType } + +//NewPegLimitType returns a new PegLimitTypeField initialized with val +func NewPegLimitType(val int) PegLimitTypeField { + return PegLimitTypeField{quickfix.FIXInt(val)} +} + +//PegMoveTypeField is a INT field +type PegMoveTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.PegMoveType (835) +func (f PegMoveTypeField) Tag() quickfix.Tag { return tag.PegMoveType } + +//NewPegMoveType returns a new PegMoveTypeField initialized with val +func NewPegMoveType(val int) PegMoveTypeField { + return PegMoveTypeField{quickfix.FIXInt(val)} +} + +//PegOffsetTypeField is a INT field +type PegOffsetTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.PegOffsetType (836) +func (f PegOffsetTypeField) Tag() quickfix.Tag { return tag.PegOffsetType } + +//NewPegOffsetType returns a new PegOffsetTypeField initialized with val +func NewPegOffsetType(val int) PegOffsetTypeField { + return PegOffsetTypeField{quickfix.FIXInt(val)} +} + +//PegOffsetValueField is a FLOAT field +type PegOffsetValueField struct{ quickfix.FIXFloat } + +//Tag returns tag.PegOffsetValue (211) +func (f PegOffsetValueField) Tag() quickfix.Tag { return tag.PegOffsetValue } + +//NewPegOffsetValue returns a new PegOffsetValueField initialized with val +func NewPegOffsetValue(val float64) PegOffsetValueField { + return PegOffsetValueField{quickfix.FIXFloat(val)} +} + +//PegPriceTypeField is a INT field +type PegPriceTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.PegPriceType (1094) +func (f PegPriceTypeField) Tag() quickfix.Tag { return tag.PegPriceType } + +//NewPegPriceType returns a new PegPriceTypeField initialized with val +func NewPegPriceType(val int) PegPriceTypeField { + return PegPriceTypeField{quickfix.FIXInt(val)} +} + +//PegRoundDirectionField is a INT field +type PegRoundDirectionField struct{ quickfix.FIXInt } + +//Tag returns tag.PegRoundDirection (838) +func (f PegRoundDirectionField) Tag() quickfix.Tag { return tag.PegRoundDirection } + +//NewPegRoundDirection returns a new PegRoundDirectionField initialized with val +func NewPegRoundDirection(val int) PegRoundDirectionField { + return PegRoundDirectionField{quickfix.FIXInt(val)} +} + +//PegScopeField is a INT field +type PegScopeField struct{ quickfix.FIXInt } + +//Tag returns tag.PegScope (840) +func (f PegScopeField) Tag() quickfix.Tag { return tag.PegScope } + +//NewPegScope returns a new PegScopeField initialized with val +func NewPegScope(val int) PegScopeField { + return PegScopeField{quickfix.FIXInt(val)} +} + +//PegSecurityDescField is a STRING field +type PegSecurityDescField struct{ quickfix.FIXString } + +//Tag returns tag.PegSecurityDesc (1099) +func (f PegSecurityDescField) Tag() quickfix.Tag { return tag.PegSecurityDesc } + +//NewPegSecurityDesc returns a new PegSecurityDescField initialized with val +func NewPegSecurityDesc(val string) PegSecurityDescField { + return PegSecurityDescField{quickfix.FIXString(val)} +} + +//PegSecurityIDField is a STRING field +type PegSecurityIDField struct{ quickfix.FIXString } + +//Tag returns tag.PegSecurityID (1097) +func (f PegSecurityIDField) Tag() quickfix.Tag { return tag.PegSecurityID } + +//NewPegSecurityID returns a new PegSecurityIDField initialized with val +func NewPegSecurityID(val string) PegSecurityIDField { + return PegSecurityIDField{quickfix.FIXString(val)} +} + +//PegSecurityIDSourceField is a STRING field +type PegSecurityIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.PegSecurityIDSource (1096) +func (f PegSecurityIDSourceField) Tag() quickfix.Tag { return tag.PegSecurityIDSource } + +//NewPegSecurityIDSource returns a new PegSecurityIDSourceField initialized with val +func NewPegSecurityIDSource(val string) PegSecurityIDSourceField { + return PegSecurityIDSourceField{quickfix.FIXString(val)} +} + +//PegSymbolField is a STRING field +type PegSymbolField struct{ quickfix.FIXString } + +//Tag returns tag.PegSymbol (1098) +func (f PegSymbolField) Tag() quickfix.Tag { return tag.PegSymbol } + +//NewPegSymbol returns a new PegSymbolField initialized with val +func NewPegSymbol(val string) PegSymbolField { + return PegSymbolField{quickfix.FIXString(val)} +} + +//PeggedPriceField is a PRICE field +type PeggedPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.PeggedPrice (839) +func (f PeggedPriceField) Tag() quickfix.Tag { return tag.PeggedPrice } + +//NewPeggedPrice returns a new PeggedPriceField initialized with val +func NewPeggedPrice(val float64) PeggedPriceField { + return PeggedPriceField{quickfix.FIXFloat(val)} +} + +//PeggedRefPriceField is a PRICE field +type PeggedRefPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.PeggedRefPrice (1095) +func (f PeggedRefPriceField) Tag() quickfix.Tag { return tag.PeggedRefPrice } + +//NewPeggedRefPrice returns a new PeggedRefPriceField initialized with val +func NewPeggedRefPrice(val float64) PeggedRefPriceField { + return PeggedRefPriceField{quickfix.FIXFloat(val)} +} + +//PoolField is a STRING field +type PoolField struct{ quickfix.FIXString } + +//Tag returns tag.Pool (691) +func (f PoolField) Tag() quickfix.Tag { return tag.Pool } + +//NewPool returns a new PoolField initialized with val +func NewPool(val string) PoolField { + return PoolField{quickfix.FIXString(val)} +} + +//PosAmtField is a AMT field +type PosAmtField struct{ quickfix.FIXFloat } + +//Tag returns tag.PosAmt (708) +func (f PosAmtField) Tag() quickfix.Tag { return tag.PosAmt } + +//NewPosAmt returns a new PosAmtField initialized with val +func NewPosAmt(val float64) PosAmtField { + return PosAmtField{quickfix.FIXFloat(val)} +} + +//PosAmtTypeField is a STRING field +type PosAmtTypeField struct{ quickfix.FIXString } + +//Tag returns tag.PosAmtType (707) +func (f PosAmtTypeField) Tag() quickfix.Tag { return tag.PosAmtType } + +//NewPosAmtType returns a new PosAmtTypeField initialized with val +func NewPosAmtType(val string) PosAmtTypeField { + return PosAmtTypeField{quickfix.FIXString(val)} +} + +//PosMaintActionField is a INT field +type PosMaintActionField struct{ quickfix.FIXInt } + +//Tag returns tag.PosMaintAction (712) +func (f PosMaintActionField) Tag() quickfix.Tag { return tag.PosMaintAction } + +//NewPosMaintAction returns a new PosMaintActionField initialized with val +func NewPosMaintAction(val int) PosMaintActionField { + return PosMaintActionField{quickfix.FIXInt(val)} +} + +//PosMaintResultField is a INT field +type PosMaintResultField struct{ quickfix.FIXInt } + +//Tag returns tag.PosMaintResult (723) +func (f PosMaintResultField) Tag() quickfix.Tag { return tag.PosMaintResult } + +//NewPosMaintResult returns a new PosMaintResultField initialized with val +func NewPosMaintResult(val int) PosMaintResultField { + return PosMaintResultField{quickfix.FIXInt(val)} +} + +//PosMaintRptIDField is a STRING field +type PosMaintRptIDField struct{ quickfix.FIXString } + +//Tag returns tag.PosMaintRptID (721) +func (f PosMaintRptIDField) Tag() quickfix.Tag { return tag.PosMaintRptID } + +//NewPosMaintRptID returns a new PosMaintRptIDField initialized with val +func NewPosMaintRptID(val string) PosMaintRptIDField { + return PosMaintRptIDField{quickfix.FIXString(val)} +} + +//PosMaintRptRefIDField is a STRING field +type PosMaintRptRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.PosMaintRptRefID (714) +func (f PosMaintRptRefIDField) Tag() quickfix.Tag { return tag.PosMaintRptRefID } + +//NewPosMaintRptRefID returns a new PosMaintRptRefIDField initialized with val +func NewPosMaintRptRefID(val string) PosMaintRptRefIDField { + return PosMaintRptRefIDField{quickfix.FIXString(val)} +} + +//PosMaintStatusField is a INT field +type PosMaintStatusField struct{ quickfix.FIXInt } + +//Tag returns tag.PosMaintStatus (722) +func (f PosMaintStatusField) Tag() quickfix.Tag { return tag.PosMaintStatus } + +//NewPosMaintStatus returns a new PosMaintStatusField initialized with val +func NewPosMaintStatus(val int) PosMaintStatusField { + return PosMaintStatusField{quickfix.FIXInt(val)} +} + +//PosQtyStatusField is a INT field +type PosQtyStatusField struct{ quickfix.FIXInt } + +//Tag returns tag.PosQtyStatus (706) +func (f PosQtyStatusField) Tag() quickfix.Tag { return tag.PosQtyStatus } + +//NewPosQtyStatus returns a new PosQtyStatusField initialized with val +func NewPosQtyStatus(val int) PosQtyStatusField { + return PosQtyStatusField{quickfix.FIXInt(val)} +} + +//PosReqIDField is a STRING field +type PosReqIDField struct{ quickfix.FIXString } + +//Tag returns tag.PosReqID (710) +func (f PosReqIDField) Tag() quickfix.Tag { return tag.PosReqID } + +//NewPosReqID returns a new PosReqIDField initialized with val +func NewPosReqID(val string) PosReqIDField { + return PosReqIDField{quickfix.FIXString(val)} +} + +//PosReqResultField is a INT field +type PosReqResultField struct{ quickfix.FIXInt } + +//Tag returns tag.PosReqResult (728) +func (f PosReqResultField) Tag() quickfix.Tag { return tag.PosReqResult } + +//NewPosReqResult returns a new PosReqResultField initialized with val +func NewPosReqResult(val int) PosReqResultField { + return PosReqResultField{quickfix.FIXInt(val)} +} + +//PosReqStatusField is a INT field +type PosReqStatusField struct{ quickfix.FIXInt } + +//Tag returns tag.PosReqStatus (729) +func (f PosReqStatusField) Tag() quickfix.Tag { return tag.PosReqStatus } + +//NewPosReqStatus returns a new PosReqStatusField initialized with val +func NewPosReqStatus(val int) PosReqStatusField { + return PosReqStatusField{quickfix.FIXInt(val)} +} + +//PosReqTypeField is a INT field +type PosReqTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.PosReqType (724) +func (f PosReqTypeField) Tag() quickfix.Tag { return tag.PosReqType } + +//NewPosReqType returns a new PosReqTypeField initialized with val +func NewPosReqType(val int) PosReqTypeField { + return PosReqTypeField{quickfix.FIXInt(val)} +} + +//PosTransTypeField is a INT field +type PosTransTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.PosTransType (709) +func (f PosTransTypeField) Tag() quickfix.Tag { return tag.PosTransType } + +//NewPosTransType returns a new PosTransTypeField initialized with val +func NewPosTransType(val int) PosTransTypeField { + return PosTransTypeField{quickfix.FIXInt(val)} +} + +//PosTypeField is a STRING field +type PosTypeField struct{ quickfix.FIXString } + +//Tag returns tag.PosType (703) +func (f PosTypeField) Tag() quickfix.Tag { return tag.PosType } + +//NewPosType returns a new PosTypeField initialized with val +func NewPosType(val string) PosTypeField { + return PosTypeField{quickfix.FIXString(val)} +} + +//PositionCurrencyField is a STRING field +type PositionCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.PositionCurrency (1055) +func (f PositionCurrencyField) Tag() quickfix.Tag { return tag.PositionCurrency } + +//NewPositionCurrency returns a new PositionCurrencyField initialized with val +func NewPositionCurrency(val string) PositionCurrencyField { + return PositionCurrencyField{quickfix.FIXString(val)} +} + +//PositionEffectField is a CHAR field +type PositionEffectField struct{ quickfix.FIXString } + +//Tag returns tag.PositionEffect (77) +func (f PositionEffectField) Tag() quickfix.Tag { return tag.PositionEffect } + +//NewPositionEffect returns a new PositionEffectField initialized with val +func NewPositionEffect(val string) PositionEffectField { + return PositionEffectField{quickfix.FIXString(val)} +} + +//PositionLimitField is a INT field +type PositionLimitField struct{ quickfix.FIXInt } + +//Tag returns tag.PositionLimit (970) +func (f PositionLimitField) Tag() quickfix.Tag { return tag.PositionLimit } + +//NewPositionLimit returns a new PositionLimitField initialized with val +func NewPositionLimit(val int) PositionLimitField { + return PositionLimitField{quickfix.FIXInt(val)} +} + +//PossDupFlagField is a BOOLEAN field +type PossDupFlagField struct{ quickfix.FIXBoolean } + +//Tag returns tag.PossDupFlag (43) +func (f PossDupFlagField) Tag() quickfix.Tag { return tag.PossDupFlag } + +//NewPossDupFlag returns a new PossDupFlagField initialized with val +func NewPossDupFlag(val bool) PossDupFlagField { + return PossDupFlagField{quickfix.FIXBoolean(val)} +} + +//PossResendField is a BOOLEAN field +type PossResendField struct{ quickfix.FIXBoolean } + +//Tag returns tag.PossResend (97) +func (f PossResendField) Tag() quickfix.Tag { return tag.PossResend } + +//NewPossResend returns a new PossResendField initialized with val +func NewPossResend(val bool) PossResendField { + return PossResendField{quickfix.FIXBoolean(val)} +} + +//PreTradeAnonymityField is a BOOLEAN field +type PreTradeAnonymityField struct{ quickfix.FIXBoolean } + +//Tag returns tag.PreTradeAnonymity (1091) +func (f PreTradeAnonymityField) Tag() quickfix.Tag { return tag.PreTradeAnonymity } + +//NewPreTradeAnonymity returns a new PreTradeAnonymityField initialized with val +func NewPreTradeAnonymity(val bool) PreTradeAnonymityField { + return PreTradeAnonymityField{quickfix.FIXBoolean(val)} +} + +//PreallocMethodField is a CHAR field +type PreallocMethodField struct{ quickfix.FIXString } + +//Tag returns tag.PreallocMethod (591) +func (f PreallocMethodField) Tag() quickfix.Tag { return tag.PreallocMethod } + +//NewPreallocMethod returns a new PreallocMethodField initialized with val +func NewPreallocMethod(val string) PreallocMethodField { + return PreallocMethodField{quickfix.FIXString(val)} +} + +//PrevClosePxField is a PRICE field +type PrevClosePxField struct{ quickfix.FIXFloat } + +//Tag returns tag.PrevClosePx (140) +func (f PrevClosePxField) Tag() quickfix.Tag { return tag.PrevClosePx } + +//NewPrevClosePx returns a new PrevClosePxField initialized with val +func NewPrevClosePx(val float64) PrevClosePxField { + return PrevClosePxField{quickfix.FIXFloat(val)} +} + +//PreviouslyReportedField is a BOOLEAN field +type PreviouslyReportedField struct{ quickfix.FIXBoolean } + +//Tag returns tag.PreviouslyReported (570) +func (f PreviouslyReportedField) Tag() quickfix.Tag { return tag.PreviouslyReported } + +//NewPreviouslyReported returns a new PreviouslyReportedField initialized with val +func NewPreviouslyReported(val bool) PreviouslyReportedField { + return PreviouslyReportedField{quickfix.FIXBoolean(val)} +} + +//PriceField is a PRICE field +type PriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.Price (44) +func (f PriceField) Tag() quickfix.Tag { return tag.Price } + +//NewPrice returns a new PriceField initialized with val +func NewPrice(val float64) PriceField { + return PriceField{quickfix.FIXFloat(val)} +} + +//Price2Field is a PRICE field +type Price2Field struct{ quickfix.FIXFloat } + +//Tag returns tag.Price2 (640) +func (f Price2Field) Tag() quickfix.Tag { return tag.Price2 } + +//NewPrice2 returns a new Price2Field initialized with val +func NewPrice2(val float64) Price2Field { + return Price2Field{quickfix.FIXFloat(val)} +} + +//PriceDeltaField is a FLOAT field +type PriceDeltaField struct{ quickfix.FIXFloat } + +//Tag returns tag.PriceDelta (811) +func (f PriceDeltaField) Tag() quickfix.Tag { return tag.PriceDelta } + +//NewPriceDelta returns a new PriceDeltaField initialized with val +func NewPriceDelta(val float64) PriceDeltaField { + return PriceDeltaField{quickfix.FIXFloat(val)} +} + +//PriceImprovementField is a PRICEOFFSET field +type PriceImprovementField struct{ quickfix.FIXFloat } + +//Tag returns tag.PriceImprovement (639) +func (f PriceImprovementField) Tag() quickfix.Tag { return tag.PriceImprovement } + +//NewPriceImprovement returns a new PriceImprovementField initialized with val +func NewPriceImprovement(val float64) PriceImprovementField { + return PriceImprovementField{quickfix.FIXFloat(val)} +} + +//PriceLimitTypeField is a INT field +type PriceLimitTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.PriceLimitType (1306) +func (f PriceLimitTypeField) Tag() quickfix.Tag { return tag.PriceLimitType } + +//NewPriceLimitType returns a new PriceLimitTypeField initialized with val +func NewPriceLimitType(val int) PriceLimitTypeField { + return PriceLimitTypeField{quickfix.FIXInt(val)} +} + +//PriceProtectionScopeField is a CHAR field +type PriceProtectionScopeField struct{ quickfix.FIXString } + +//Tag returns tag.PriceProtectionScope (1092) +func (f PriceProtectionScopeField) Tag() quickfix.Tag { return tag.PriceProtectionScope } + +//NewPriceProtectionScope returns a new PriceProtectionScopeField initialized with val +func NewPriceProtectionScope(val string) PriceProtectionScopeField { + return PriceProtectionScopeField{quickfix.FIXString(val)} +} + +//PriceQuoteMethodField is a STRING field +type PriceQuoteMethodField struct{ quickfix.FIXString } + +//Tag returns tag.PriceQuoteMethod (1196) +func (f PriceQuoteMethodField) Tag() quickfix.Tag { return tag.PriceQuoteMethod } + +//NewPriceQuoteMethod returns a new PriceQuoteMethodField initialized with val +func NewPriceQuoteMethod(val string) PriceQuoteMethodField { + return PriceQuoteMethodField{quickfix.FIXString(val)} +} + +//PriceTypeField is a INT field +type PriceTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.PriceType (423) +func (f PriceTypeField) Tag() quickfix.Tag { return tag.PriceType } + +//NewPriceType returns a new PriceTypeField initialized with val +func NewPriceType(val int) PriceTypeField { + return PriceTypeField{quickfix.FIXInt(val)} +} + +//PriceUnitOfMeasureField is a STRING field +type PriceUnitOfMeasureField struct{ quickfix.FIXString } + +//Tag returns tag.PriceUnitOfMeasure (1191) +func (f PriceUnitOfMeasureField) Tag() quickfix.Tag { return tag.PriceUnitOfMeasure } + +//NewPriceUnitOfMeasure returns a new PriceUnitOfMeasureField initialized with val +func NewPriceUnitOfMeasure(val string) PriceUnitOfMeasureField { + return PriceUnitOfMeasureField{quickfix.FIXString(val)} +} + +//PriceUnitOfMeasureQtyField is a QTY field +type PriceUnitOfMeasureQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.PriceUnitOfMeasureQty (1192) +func (f PriceUnitOfMeasureQtyField) Tag() quickfix.Tag { return tag.PriceUnitOfMeasureQty } + +//NewPriceUnitOfMeasureQty returns a new PriceUnitOfMeasureQtyField initialized with val +func NewPriceUnitOfMeasureQty(val float64) PriceUnitOfMeasureQtyField { + return PriceUnitOfMeasureQtyField{quickfix.FIXFloat(val)} +} + +//PriorSettlPriceField is a PRICE field +type PriorSettlPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.PriorSettlPrice (734) +func (f PriorSettlPriceField) Tag() quickfix.Tag { return tag.PriorSettlPrice } + +//NewPriorSettlPrice returns a new PriorSettlPriceField initialized with val +func NewPriorSettlPrice(val float64) PriorSettlPriceField { + return PriorSettlPriceField{quickfix.FIXFloat(val)} +} + +//PriorSpreadIndicatorField is a BOOLEAN field +type PriorSpreadIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.PriorSpreadIndicator (720) +func (f PriorSpreadIndicatorField) Tag() quickfix.Tag { return tag.PriorSpreadIndicator } + +//NewPriorSpreadIndicator returns a new PriorSpreadIndicatorField initialized with val +func NewPriorSpreadIndicator(val bool) PriorSpreadIndicatorField { + return PriorSpreadIndicatorField{quickfix.FIXBoolean(val)} +} + +//PriorityIndicatorField is a INT field +type PriorityIndicatorField struct{ quickfix.FIXInt } + +//Tag returns tag.PriorityIndicator (638) +func (f PriorityIndicatorField) Tag() quickfix.Tag { return tag.PriorityIndicator } + +//NewPriorityIndicator returns a new PriorityIndicatorField initialized with val +func NewPriorityIndicator(val int) PriorityIndicatorField { + return PriorityIndicatorField{quickfix.FIXInt(val)} +} + +//PrivateQuoteField is a BOOLEAN field +type PrivateQuoteField struct{ quickfix.FIXBoolean } + +//Tag returns tag.PrivateQuote (1171) +func (f PrivateQuoteField) Tag() quickfix.Tag { return tag.PrivateQuote } + +//NewPrivateQuote returns a new PrivateQuoteField initialized with val +func NewPrivateQuote(val bool) PrivateQuoteField { + return PrivateQuoteField{quickfix.FIXBoolean(val)} +} + +//ProcessCodeField is a CHAR field +type ProcessCodeField struct{ quickfix.FIXString } + +//Tag returns tag.ProcessCode (81) +func (f ProcessCodeField) Tag() quickfix.Tag { return tag.ProcessCode } + +//NewProcessCode returns a new ProcessCodeField initialized with val +func NewProcessCode(val string) ProcessCodeField { + return ProcessCodeField{quickfix.FIXString(val)} +} + +//ProductField is a INT field +type ProductField struct{ quickfix.FIXInt } + +//Tag returns tag.Product (460) +func (f ProductField) Tag() quickfix.Tag { return tag.Product } + +//NewProduct returns a new ProductField initialized with val +func NewProduct(val int) ProductField { + return ProductField{quickfix.FIXInt(val)} +} + +//ProductComplexField is a STRING field +type ProductComplexField struct{ quickfix.FIXString } + +//Tag returns tag.ProductComplex (1227) +func (f ProductComplexField) Tag() quickfix.Tag { return tag.ProductComplex } + +//NewProductComplex returns a new ProductComplexField initialized with val +func NewProductComplex(val string) ProductComplexField { + return ProductComplexField{quickfix.FIXString(val)} +} + +//ProgPeriodIntervalField is a INT field +type ProgPeriodIntervalField struct{ quickfix.FIXInt } + +//Tag returns tag.ProgPeriodInterval (415) +func (f ProgPeriodIntervalField) Tag() quickfix.Tag { return tag.ProgPeriodInterval } + +//NewProgPeriodInterval returns a new ProgPeriodIntervalField initialized with val +func NewProgPeriodInterval(val int) ProgPeriodIntervalField { + return ProgPeriodIntervalField{quickfix.FIXInt(val)} +} + +//ProgRptReqsField is a INT field +type ProgRptReqsField struct{ quickfix.FIXInt } + +//Tag returns tag.ProgRptReqs (414) +func (f ProgRptReqsField) Tag() quickfix.Tag { return tag.ProgRptReqs } + +//NewProgRptReqs returns a new ProgRptReqsField initialized with val +func NewProgRptReqs(val int) ProgRptReqsField { + return ProgRptReqsField{quickfix.FIXInt(val)} +} + +//PublishTrdIndicatorField is a BOOLEAN field +type PublishTrdIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.PublishTrdIndicator (852) +func (f PublishTrdIndicatorField) Tag() quickfix.Tag { return tag.PublishTrdIndicator } + +//NewPublishTrdIndicator returns a new PublishTrdIndicatorField initialized with val +func NewPublishTrdIndicator(val bool) PublishTrdIndicatorField { + return PublishTrdIndicatorField{quickfix.FIXBoolean(val)} +} + +//PutOrCallField is a INT field +type PutOrCallField struct{ quickfix.FIXInt } + +//Tag returns tag.PutOrCall (201) +func (f PutOrCallField) Tag() quickfix.Tag { return tag.PutOrCall } + +//NewPutOrCall returns a new PutOrCallField initialized with val +func NewPutOrCall(val int) PutOrCallField { + return PutOrCallField{quickfix.FIXInt(val)} +} + +//QtyTypeField is a INT field +type QtyTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.QtyType (854) +func (f QtyTypeField) Tag() quickfix.Tag { return tag.QtyType } + +//NewQtyType returns a new QtyTypeField initialized with val +func NewQtyType(val int) QtyTypeField { + return QtyTypeField{quickfix.FIXInt(val)} +} + +//QuantityField is a QTY field +type QuantityField struct{ quickfix.FIXFloat } + +//Tag returns tag.Quantity (53) +func (f QuantityField) Tag() quickfix.Tag { return tag.Quantity } + +//NewQuantity returns a new QuantityField initialized with val +func NewQuantity(val float64) QuantityField { + return QuantityField{quickfix.FIXFloat(val)} +} + +//QuantityDateField is a LOCALMKTDATE field +type QuantityDateField struct{ quickfix.FIXString } + +//Tag returns tag.QuantityDate (976) +func (f QuantityDateField) Tag() quickfix.Tag { return tag.QuantityDate } + +//NewQuantityDate returns a new QuantityDateField initialized with val +func NewQuantityDate(val string) QuantityDateField { + return QuantityDateField{quickfix.FIXString(val)} +} + +//QuantityTypeField is a INT field +type QuantityTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.QuantityType (465) +func (f QuantityTypeField) Tag() quickfix.Tag { return tag.QuantityType } + +//NewQuantityType returns a new QuantityTypeField initialized with val +func NewQuantityType(val int) QuantityTypeField { + return QuantityTypeField{quickfix.FIXInt(val)} +} + +//QuoteAckStatusField is a INT field +type QuoteAckStatusField struct{ quickfix.FIXInt } + +//Tag returns tag.QuoteAckStatus (297) +func (f QuoteAckStatusField) Tag() quickfix.Tag { return tag.QuoteAckStatus } + +//NewQuoteAckStatus returns a new QuoteAckStatusField initialized with val +func NewQuoteAckStatus(val int) QuoteAckStatusField { + return QuoteAckStatusField{quickfix.FIXInt(val)} +} + +//QuoteCancelTypeField is a INT field +type QuoteCancelTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.QuoteCancelType (298) +func (f QuoteCancelTypeField) Tag() quickfix.Tag { return tag.QuoteCancelType } + +//NewQuoteCancelType returns a new QuoteCancelTypeField initialized with val +func NewQuoteCancelType(val int) QuoteCancelTypeField { + return QuoteCancelTypeField{quickfix.FIXInt(val)} +} + +//QuoteConditionField is a MULTIPLESTRINGVALUE field +type QuoteConditionField struct{ quickfix.FIXString } + +//Tag returns tag.QuoteCondition (276) +func (f QuoteConditionField) Tag() quickfix.Tag { return tag.QuoteCondition } + +//NewQuoteCondition returns a new QuoteConditionField initialized with val +func NewQuoteCondition(val string) QuoteConditionField { + return QuoteConditionField{quickfix.FIXString(val)} +} + +//QuoteEntryIDField is a STRING field +type QuoteEntryIDField struct{ quickfix.FIXString } + +//Tag returns tag.QuoteEntryID (299) +func (f QuoteEntryIDField) Tag() quickfix.Tag { return tag.QuoteEntryID } + +//NewQuoteEntryID returns a new QuoteEntryIDField initialized with val +func NewQuoteEntryID(val string) QuoteEntryIDField { + return QuoteEntryIDField{quickfix.FIXString(val)} +} + +//QuoteEntryRejectReasonField is a INT field +type QuoteEntryRejectReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.QuoteEntryRejectReason (368) +func (f QuoteEntryRejectReasonField) Tag() quickfix.Tag { return tag.QuoteEntryRejectReason } + +//NewQuoteEntryRejectReason returns a new QuoteEntryRejectReasonField initialized with val +func NewQuoteEntryRejectReason(val int) QuoteEntryRejectReasonField { + return QuoteEntryRejectReasonField{quickfix.FIXInt(val)} +} + +//QuoteEntryStatusField is a INT field +type QuoteEntryStatusField struct{ quickfix.FIXInt } + +//Tag returns tag.QuoteEntryStatus (1167) +func (f QuoteEntryStatusField) Tag() quickfix.Tag { return tag.QuoteEntryStatus } + +//NewQuoteEntryStatus returns a new QuoteEntryStatusField initialized with val +func NewQuoteEntryStatus(val int) QuoteEntryStatusField { + return QuoteEntryStatusField{quickfix.FIXInt(val)} +} + +//QuoteIDField is a STRING field +type QuoteIDField struct{ quickfix.FIXString } + +//Tag returns tag.QuoteID (117) +func (f QuoteIDField) Tag() quickfix.Tag { return tag.QuoteID } + +//NewQuoteID returns a new QuoteIDField initialized with val +func NewQuoteID(val string) QuoteIDField { + return QuoteIDField{quickfix.FIXString(val)} +} + +//QuoteMsgIDField is a STRING field +type QuoteMsgIDField struct{ quickfix.FIXString } + +//Tag returns tag.QuoteMsgID (1166) +func (f QuoteMsgIDField) Tag() quickfix.Tag { return tag.QuoteMsgID } + +//NewQuoteMsgID returns a new QuoteMsgIDField initialized with val +func NewQuoteMsgID(val string) QuoteMsgIDField { + return QuoteMsgIDField{quickfix.FIXString(val)} +} + +//QuotePriceTypeField is a INT field +type QuotePriceTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.QuotePriceType (692) +func (f QuotePriceTypeField) Tag() quickfix.Tag { return tag.QuotePriceType } + +//NewQuotePriceType returns a new QuotePriceTypeField initialized with val +func NewQuotePriceType(val int) QuotePriceTypeField { + return QuotePriceTypeField{quickfix.FIXInt(val)} +} + +//QuoteQualifierField is a CHAR field +type QuoteQualifierField struct{ quickfix.FIXString } + +//Tag returns tag.QuoteQualifier (695) +func (f QuoteQualifierField) Tag() quickfix.Tag { return tag.QuoteQualifier } + +//NewQuoteQualifier returns a new QuoteQualifierField initialized with val +func NewQuoteQualifier(val string) QuoteQualifierField { + return QuoteQualifierField{quickfix.FIXString(val)} +} + +//QuoteRejectReasonField is a INT field +type QuoteRejectReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.QuoteRejectReason (300) +func (f QuoteRejectReasonField) Tag() quickfix.Tag { return tag.QuoteRejectReason } + +//NewQuoteRejectReason returns a new QuoteRejectReasonField initialized with val +func NewQuoteRejectReason(val int) QuoteRejectReasonField { + return QuoteRejectReasonField{quickfix.FIXInt(val)} +} + +//QuoteReqIDField is a STRING field +type QuoteReqIDField struct{ quickfix.FIXString } + +//Tag returns tag.QuoteReqID (131) +func (f QuoteReqIDField) Tag() quickfix.Tag { return tag.QuoteReqID } + +//NewQuoteReqID returns a new QuoteReqIDField initialized with val +func NewQuoteReqID(val string) QuoteReqIDField { + return QuoteReqIDField{quickfix.FIXString(val)} +} + +//QuoteRequestRejectReasonField is a INT field +type QuoteRequestRejectReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.QuoteRequestRejectReason (658) +func (f QuoteRequestRejectReasonField) Tag() quickfix.Tag { return tag.QuoteRequestRejectReason } + +//NewQuoteRequestRejectReason returns a new QuoteRequestRejectReasonField initialized with val +func NewQuoteRequestRejectReason(val int) QuoteRequestRejectReasonField { + return QuoteRequestRejectReasonField{quickfix.FIXInt(val)} +} + +//QuoteRequestTypeField is a INT field +type QuoteRequestTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.QuoteRequestType (303) +func (f QuoteRequestTypeField) Tag() quickfix.Tag { return tag.QuoteRequestType } + +//NewQuoteRequestType returns a new QuoteRequestTypeField initialized with val +func NewQuoteRequestType(val int) QuoteRequestTypeField { + return QuoteRequestTypeField{quickfix.FIXInt(val)} +} + +//QuoteRespIDField is a STRING field +type QuoteRespIDField struct{ quickfix.FIXString } + +//Tag returns tag.QuoteRespID (693) +func (f QuoteRespIDField) Tag() quickfix.Tag { return tag.QuoteRespID } + +//NewQuoteRespID returns a new QuoteRespIDField initialized with val +func NewQuoteRespID(val string) QuoteRespIDField { + return QuoteRespIDField{quickfix.FIXString(val)} +} + +//QuoteRespTypeField is a INT field +type QuoteRespTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.QuoteRespType (694) +func (f QuoteRespTypeField) Tag() quickfix.Tag { return tag.QuoteRespType } + +//NewQuoteRespType returns a new QuoteRespTypeField initialized with val +func NewQuoteRespType(val int) QuoteRespTypeField { + return QuoteRespTypeField{quickfix.FIXInt(val)} +} + +//QuoteResponseLevelField is a INT field +type QuoteResponseLevelField struct{ quickfix.FIXInt } + +//Tag returns tag.QuoteResponseLevel (301) +func (f QuoteResponseLevelField) Tag() quickfix.Tag { return tag.QuoteResponseLevel } + +//NewQuoteResponseLevel returns a new QuoteResponseLevelField initialized with val +func NewQuoteResponseLevel(val int) QuoteResponseLevelField { + return QuoteResponseLevelField{quickfix.FIXInt(val)} +} + +//QuoteSetIDField is a STRING field +type QuoteSetIDField struct{ quickfix.FIXString } + +//Tag returns tag.QuoteSetID (302) +func (f QuoteSetIDField) Tag() quickfix.Tag { return tag.QuoteSetID } + +//NewQuoteSetID returns a new QuoteSetIDField initialized with val +func NewQuoteSetID(val string) QuoteSetIDField { + return QuoteSetIDField{quickfix.FIXString(val)} +} + +//QuoteSetValidUntilTimeField is a UTCTIMESTAMP field +type QuoteSetValidUntilTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.QuoteSetValidUntilTime (367) +func (f QuoteSetValidUntilTimeField) Tag() quickfix.Tag { return tag.QuoteSetValidUntilTime } + +//NewQuoteSetValidUntilTime returns a new QuoteSetValidUntilTimeField initialized with val +func NewQuoteSetValidUntilTime(val time.Time) QuoteSetValidUntilTimeField { + return QuoteSetValidUntilTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewQuoteSetValidUntilTimeNoMillis returns a new QuoteSetValidUntilTimeField initialized with val without millisecs +func NewQuoteSetValidUntilTimeNoMillis(val time.Time) QuoteSetValidUntilTimeField { + return QuoteSetValidUntilTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//QuoteStatusField is a INT field +type QuoteStatusField struct{ quickfix.FIXInt } + +//Tag returns tag.QuoteStatus (297) +func (f QuoteStatusField) Tag() quickfix.Tag { return tag.QuoteStatus } + +//NewQuoteStatus returns a new QuoteStatusField initialized with val +func NewQuoteStatus(val int) QuoteStatusField { + return QuoteStatusField{quickfix.FIXInt(val)} +} + +//QuoteStatusReqIDField is a STRING field +type QuoteStatusReqIDField struct{ quickfix.FIXString } + +//Tag returns tag.QuoteStatusReqID (649) +func (f QuoteStatusReqIDField) Tag() quickfix.Tag { return tag.QuoteStatusReqID } + +//NewQuoteStatusReqID returns a new QuoteStatusReqIDField initialized with val +func NewQuoteStatusReqID(val string) QuoteStatusReqIDField { + return QuoteStatusReqIDField{quickfix.FIXString(val)} +} + +//QuoteTypeField is a INT field +type QuoteTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.QuoteType (537) +func (f QuoteTypeField) Tag() quickfix.Tag { return tag.QuoteType } + +//NewQuoteType returns a new QuoteTypeField initialized with val +func NewQuoteType(val int) QuoteTypeField { + return QuoteTypeField{quickfix.FIXInt(val)} +} + +//RFQReqIDField is a STRING field +type RFQReqIDField struct{ quickfix.FIXString } + +//Tag returns tag.RFQReqID (644) +func (f RFQReqIDField) Tag() quickfix.Tag { return tag.RFQReqID } + +//NewRFQReqID returns a new RFQReqIDField initialized with val +func NewRFQReqID(val string) RFQReqIDField { + return RFQReqIDField{quickfix.FIXString(val)} +} + +//RateSourceField is a INT field +type RateSourceField struct{ quickfix.FIXInt } + +//Tag returns tag.RateSource (1446) +func (f RateSourceField) Tag() quickfix.Tag { return tag.RateSource } + +//NewRateSource returns a new RateSourceField initialized with val +func NewRateSource(val int) RateSourceField { + return RateSourceField{quickfix.FIXInt(val)} +} + +//RateSourceTypeField is a INT field +type RateSourceTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.RateSourceType (1447) +func (f RateSourceTypeField) Tag() quickfix.Tag { return tag.RateSourceType } + +//NewRateSourceType returns a new RateSourceTypeField initialized with val +func NewRateSourceType(val int) RateSourceTypeField { + return RateSourceTypeField{quickfix.FIXInt(val)} +} + +//RatioQtyField is a QTY field +type RatioQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.RatioQty (319) +func (f RatioQtyField) Tag() quickfix.Tag { return tag.RatioQty } + +//NewRatioQty returns a new RatioQtyField initialized with val +func NewRatioQty(val float64) RatioQtyField { + return RatioQtyField{quickfix.FIXFloat(val)} +} + +//RawDataField is a DATA field +type RawDataField struct{ quickfix.FIXString } + +//Tag returns tag.RawData (96) +func (f RawDataField) Tag() quickfix.Tag { return tag.RawData } + +//NewRawData returns a new RawDataField initialized with val +func NewRawData(val string) RawDataField { + return RawDataField{quickfix.FIXString(val)} +} + +//RawDataLengthField is a LENGTH field +type RawDataLengthField struct{ quickfix.FIXInt } + +//Tag returns tag.RawDataLength (95) +func (f RawDataLengthField) Tag() quickfix.Tag { return tag.RawDataLength } + +//NewRawDataLength returns a new RawDataLengthField initialized with val +func NewRawDataLength(val int) RawDataLengthField { + return RawDataLengthField{quickfix.FIXInt(val)} +} + +//ReceivedDeptIDField is a STRING field +type ReceivedDeptIDField struct{ quickfix.FIXString } + +//Tag returns tag.ReceivedDeptID (1030) +func (f ReceivedDeptIDField) Tag() quickfix.Tag { return tag.ReceivedDeptID } + +//NewReceivedDeptID returns a new ReceivedDeptIDField initialized with val +func NewReceivedDeptID(val string) ReceivedDeptIDField { + return ReceivedDeptIDField{quickfix.FIXString(val)} +} + +//RedemptionDateField is a LOCALMKTDATE field +type RedemptionDateField struct{ quickfix.FIXString } + +//Tag returns tag.RedemptionDate (240) +func (f RedemptionDateField) Tag() quickfix.Tag { return tag.RedemptionDate } + +//NewRedemptionDate returns a new RedemptionDateField initialized with val +func NewRedemptionDate(val string) RedemptionDateField { + return RedemptionDateField{quickfix.FIXString(val)} +} + +//RefAllocIDField is a STRING field +type RefAllocIDField struct{ quickfix.FIXString } + +//Tag returns tag.RefAllocID (72) +func (f RefAllocIDField) Tag() quickfix.Tag { return tag.RefAllocID } + +//NewRefAllocID returns a new RefAllocIDField initialized with val +func NewRefAllocID(val string) RefAllocIDField { + return RefAllocIDField{quickfix.FIXString(val)} +} + +//RefApplExtIDField is a INT field +type RefApplExtIDField struct{ quickfix.FIXInt } + +//Tag returns tag.RefApplExtID (1406) +func (f RefApplExtIDField) Tag() quickfix.Tag { return tag.RefApplExtID } + +//NewRefApplExtID returns a new RefApplExtIDField initialized with val +func NewRefApplExtID(val int) RefApplExtIDField { + return RefApplExtIDField{quickfix.FIXInt(val)} +} + +//RefApplIDField is a STRING field +type RefApplIDField struct{ quickfix.FIXString } + +//Tag returns tag.RefApplID (1355) +func (f RefApplIDField) Tag() quickfix.Tag { return tag.RefApplID } + +//NewRefApplID returns a new RefApplIDField initialized with val +func NewRefApplID(val string) RefApplIDField { + return RefApplIDField{quickfix.FIXString(val)} +} + +//RefApplLastSeqNumField is a SEQNUM field +type RefApplLastSeqNumField struct{ quickfix.FIXInt } + +//Tag returns tag.RefApplLastSeqNum (1357) +func (f RefApplLastSeqNumField) Tag() quickfix.Tag { return tag.RefApplLastSeqNum } + +//NewRefApplLastSeqNum returns a new RefApplLastSeqNumField initialized with val +func NewRefApplLastSeqNum(val int) RefApplLastSeqNumField { + return RefApplLastSeqNumField{quickfix.FIXInt(val)} +} + +//RefApplReqIDField is a STRING field +type RefApplReqIDField struct{ quickfix.FIXString } + +//Tag returns tag.RefApplReqID (1433) +func (f RefApplReqIDField) Tag() quickfix.Tag { return tag.RefApplReqID } + +//NewRefApplReqID returns a new RefApplReqIDField initialized with val +func NewRefApplReqID(val string) RefApplReqIDField { + return RefApplReqIDField{quickfix.FIXString(val)} +} + +//RefApplVerIDField is a STRING field +type RefApplVerIDField struct{ quickfix.FIXString } + +//Tag returns tag.RefApplVerID (1130) +func (f RefApplVerIDField) Tag() quickfix.Tag { return tag.RefApplVerID } + +//NewRefApplVerID returns a new RefApplVerIDField initialized with val +func NewRefApplVerID(val string) RefApplVerIDField { + return RefApplVerIDField{quickfix.FIXString(val)} +} + +//RefCompIDField is a STRING field +type RefCompIDField struct{ quickfix.FIXString } + +//Tag returns tag.RefCompID (930) +func (f RefCompIDField) Tag() quickfix.Tag { return tag.RefCompID } + +//NewRefCompID returns a new RefCompIDField initialized with val +func NewRefCompID(val string) RefCompIDField { + return RefCompIDField{quickfix.FIXString(val)} +} + +//RefCstmApplVerIDField is a STRING field +type RefCstmApplVerIDField struct{ quickfix.FIXString } + +//Tag returns tag.RefCstmApplVerID (1131) +func (f RefCstmApplVerIDField) Tag() quickfix.Tag { return tag.RefCstmApplVerID } + +//NewRefCstmApplVerID returns a new RefCstmApplVerIDField initialized with val +func NewRefCstmApplVerID(val string) RefCstmApplVerIDField { + return RefCstmApplVerIDField{quickfix.FIXString(val)} +} + +//RefMsgTypeField is a STRING field +type RefMsgTypeField struct{ quickfix.FIXString } + +//Tag returns tag.RefMsgType (372) +func (f RefMsgTypeField) Tag() quickfix.Tag { return tag.RefMsgType } + +//NewRefMsgType returns a new RefMsgTypeField initialized with val +func NewRefMsgType(val string) RefMsgTypeField { + return RefMsgTypeField{quickfix.FIXString(val)} +} + +//RefOrdIDReasonField is a INT field +type RefOrdIDReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.RefOrdIDReason (1431) +func (f RefOrdIDReasonField) Tag() quickfix.Tag { return tag.RefOrdIDReason } + +//NewRefOrdIDReason returns a new RefOrdIDReasonField initialized with val +func NewRefOrdIDReason(val int) RefOrdIDReasonField { + return RefOrdIDReasonField{quickfix.FIXInt(val)} +} + +//RefOrderIDField is a STRING field +type RefOrderIDField struct{ quickfix.FIXString } + +//Tag returns tag.RefOrderID (1080) +func (f RefOrderIDField) Tag() quickfix.Tag { return tag.RefOrderID } + +//NewRefOrderID returns a new RefOrderIDField initialized with val +func NewRefOrderID(val string) RefOrderIDField { + return RefOrderIDField{quickfix.FIXString(val)} +} + +//RefOrderIDSourceField is a CHAR field +type RefOrderIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.RefOrderIDSource (1081) +func (f RefOrderIDSourceField) Tag() quickfix.Tag { return tag.RefOrderIDSource } + +//NewRefOrderIDSource returns a new RefOrderIDSourceField initialized with val +func NewRefOrderIDSource(val string) RefOrderIDSourceField { + return RefOrderIDSourceField{quickfix.FIXString(val)} +} + +//RefSeqNumField is a SEQNUM field +type RefSeqNumField struct{ quickfix.FIXInt } + +//Tag returns tag.RefSeqNum (45) +func (f RefSeqNumField) Tag() quickfix.Tag { return tag.RefSeqNum } + +//NewRefSeqNum returns a new RefSeqNumField initialized with val +func NewRefSeqNum(val int) RefSeqNumField { + return RefSeqNumField{quickfix.FIXInt(val)} +} + +//RefSubIDField is a STRING field +type RefSubIDField struct{ quickfix.FIXString } + +//Tag returns tag.RefSubID (931) +func (f RefSubIDField) Tag() quickfix.Tag { return tag.RefSubID } + +//NewRefSubID returns a new RefSubIDField initialized with val +func NewRefSubID(val string) RefSubIDField { + return RefSubIDField{quickfix.FIXString(val)} +} + +//RefTagIDField is a INT field +type RefTagIDField struct{ quickfix.FIXInt } + +//Tag returns tag.RefTagID (371) +func (f RefTagIDField) Tag() quickfix.Tag { return tag.RefTagID } + +//NewRefTagID returns a new RefTagIDField initialized with val +func NewRefTagID(val int) RefTagIDField { + return RefTagIDField{quickfix.FIXInt(val)} +} + +//ReferencePageField is a STRING field +type ReferencePageField struct{ quickfix.FIXString } + +//Tag returns tag.ReferencePage (1448) +func (f ReferencePageField) Tag() quickfix.Tag { return tag.ReferencePage } + +//NewReferencePage returns a new ReferencePageField initialized with val +func NewReferencePage(val string) ReferencePageField { + return ReferencePageField{quickfix.FIXString(val)} +} + +//RefreshIndicatorField is a BOOLEAN field +type RefreshIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.RefreshIndicator (1187) +func (f RefreshIndicatorField) Tag() quickfix.Tag { return tag.RefreshIndicator } + +//NewRefreshIndicator returns a new RefreshIndicatorField initialized with val +func NewRefreshIndicator(val bool) RefreshIndicatorField { + return RefreshIndicatorField{quickfix.FIXBoolean(val)} +} + +//RefreshQtyField is a QTY field +type RefreshQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.RefreshQty (1088) +func (f RefreshQtyField) Tag() quickfix.Tag { return tag.RefreshQty } + +//NewRefreshQty returns a new RefreshQtyField initialized with val +func NewRefreshQty(val float64) RefreshQtyField { + return RefreshQtyField{quickfix.FIXFloat(val)} +} + +//RegistAcctTypeField is a STRING field +type RegistAcctTypeField struct{ quickfix.FIXString } + +//Tag returns tag.RegistAcctType (493) +func (f RegistAcctTypeField) Tag() quickfix.Tag { return tag.RegistAcctType } + +//NewRegistAcctType returns a new RegistAcctTypeField initialized with val +func NewRegistAcctType(val string) RegistAcctTypeField { + return RegistAcctTypeField{quickfix.FIXString(val)} +} + +//RegistDetlsField is a STRING field +type RegistDetlsField struct{ quickfix.FIXString } + +//Tag returns tag.RegistDetls (509) +func (f RegistDetlsField) Tag() quickfix.Tag { return tag.RegistDetls } + +//NewRegistDetls returns a new RegistDetlsField initialized with val +func NewRegistDetls(val string) RegistDetlsField { + return RegistDetlsField{quickfix.FIXString(val)} +} + +//RegistDtlsField is a STRING field +type RegistDtlsField struct{ quickfix.FIXString } + +//Tag returns tag.RegistDtls (509) +func (f RegistDtlsField) Tag() quickfix.Tag { return tag.RegistDtls } + +//NewRegistDtls returns a new RegistDtlsField initialized with val +func NewRegistDtls(val string) RegistDtlsField { + return RegistDtlsField{quickfix.FIXString(val)} +} + +//RegistEmailField is a STRING field +type RegistEmailField struct{ quickfix.FIXString } + +//Tag returns tag.RegistEmail (511) +func (f RegistEmailField) Tag() quickfix.Tag { return tag.RegistEmail } + +//NewRegistEmail returns a new RegistEmailField initialized with val +func NewRegistEmail(val string) RegistEmailField { + return RegistEmailField{quickfix.FIXString(val)} +} + +//RegistIDField is a STRING field +type RegistIDField struct{ quickfix.FIXString } + +//Tag returns tag.RegistID (513) +func (f RegistIDField) Tag() quickfix.Tag { return tag.RegistID } + +//NewRegistID returns a new RegistIDField initialized with val +func NewRegistID(val string) RegistIDField { + return RegistIDField{quickfix.FIXString(val)} +} + +//RegistRefIDField is a STRING field +type RegistRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.RegistRefID (508) +func (f RegistRefIDField) Tag() quickfix.Tag { return tag.RegistRefID } + +//NewRegistRefID returns a new RegistRefIDField initialized with val +func NewRegistRefID(val string) RegistRefIDField { + return RegistRefIDField{quickfix.FIXString(val)} +} + +//RegistRejReasonCodeField is a INT field +type RegistRejReasonCodeField struct{ quickfix.FIXInt } + +//Tag returns tag.RegistRejReasonCode (507) +func (f RegistRejReasonCodeField) Tag() quickfix.Tag { return tag.RegistRejReasonCode } + +//NewRegistRejReasonCode returns a new RegistRejReasonCodeField initialized with val +func NewRegistRejReasonCode(val int) RegistRejReasonCodeField { + return RegistRejReasonCodeField{quickfix.FIXInt(val)} +} + +//RegistRejReasonTextField is a STRING field +type RegistRejReasonTextField struct{ quickfix.FIXString } + +//Tag returns tag.RegistRejReasonText (496) +func (f RegistRejReasonTextField) Tag() quickfix.Tag { return tag.RegistRejReasonText } + +//NewRegistRejReasonText returns a new RegistRejReasonTextField initialized with val +func NewRegistRejReasonText(val string) RegistRejReasonTextField { + return RegistRejReasonTextField{quickfix.FIXString(val)} +} + +//RegistStatusField is a CHAR field +type RegistStatusField struct{ quickfix.FIXString } + +//Tag returns tag.RegistStatus (506) +func (f RegistStatusField) Tag() quickfix.Tag { return tag.RegistStatus } + +//NewRegistStatus returns a new RegistStatusField initialized with val +func NewRegistStatus(val string) RegistStatusField { + return RegistStatusField{quickfix.FIXString(val)} +} + +//RegistTransTypeField is a CHAR field +type RegistTransTypeField struct{ quickfix.FIXString } + +//Tag returns tag.RegistTransType (514) +func (f RegistTransTypeField) Tag() quickfix.Tag { return tag.RegistTransType } + +//NewRegistTransType returns a new RegistTransTypeField initialized with val +func NewRegistTransType(val string) RegistTransTypeField { + return RegistTransTypeField{quickfix.FIXString(val)} +} + +//RejectTextField is a STRING field +type RejectTextField struct{ quickfix.FIXString } + +//Tag returns tag.RejectText (1328) +func (f RejectTextField) Tag() quickfix.Tag { return tag.RejectText } + +//NewRejectText returns a new RejectTextField initialized with val +func NewRejectText(val string) RejectTextField { + return RejectTextField{quickfix.FIXString(val)} +} + +//RelSymTransactTimeField is a UTCTIMESTAMP field +type RelSymTransactTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.RelSymTransactTime (1504) +func (f RelSymTransactTimeField) Tag() quickfix.Tag { return tag.RelSymTransactTime } + +//NewRelSymTransactTime returns a new RelSymTransactTimeField initialized with val +func NewRelSymTransactTime(val time.Time) RelSymTransactTimeField { + return RelSymTransactTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewRelSymTransactTimeNoMillis returns a new RelSymTransactTimeField initialized with val without millisecs +func NewRelSymTransactTimeNoMillis(val time.Time) RelSymTransactTimeField { + return RelSymTransactTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//RelatdSymField is a STRING field +type RelatdSymField struct{ quickfix.FIXString } + +//Tag returns tag.RelatdSym (46) +func (f RelatdSymField) Tag() quickfix.Tag { return tag.RelatdSym } + +//NewRelatdSym returns a new RelatdSymField initialized with val +func NewRelatdSym(val string) RelatdSymField { + return RelatdSymField{quickfix.FIXString(val)} +} + +//RelatedContextPartyIDField is a STRING field +type RelatedContextPartyIDField struct{ quickfix.FIXString } + +//Tag returns tag.RelatedContextPartyID (1576) +func (f RelatedContextPartyIDField) Tag() quickfix.Tag { return tag.RelatedContextPartyID } + +//NewRelatedContextPartyID returns a new RelatedContextPartyIDField initialized with val +func NewRelatedContextPartyID(val string) RelatedContextPartyIDField { + return RelatedContextPartyIDField{quickfix.FIXString(val)} +} + +//RelatedContextPartyIDSourceField is a CHAR field +type RelatedContextPartyIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.RelatedContextPartyIDSource (1577) +func (f RelatedContextPartyIDSourceField) Tag() quickfix.Tag { return tag.RelatedContextPartyIDSource } + +//NewRelatedContextPartyIDSource returns a new RelatedContextPartyIDSourceField initialized with val +func NewRelatedContextPartyIDSource(val string) RelatedContextPartyIDSourceField { + return RelatedContextPartyIDSourceField{quickfix.FIXString(val)} +} + +//RelatedContextPartyRoleField is a INT field +type RelatedContextPartyRoleField struct{ quickfix.FIXInt } + +//Tag returns tag.RelatedContextPartyRole (1578) +func (f RelatedContextPartyRoleField) Tag() quickfix.Tag { return tag.RelatedContextPartyRole } + +//NewRelatedContextPartyRole returns a new RelatedContextPartyRoleField initialized with val +func NewRelatedContextPartyRole(val int) RelatedContextPartyRoleField { + return RelatedContextPartyRoleField{quickfix.FIXInt(val)} +} + +//RelatedContextPartySubIDField is a STRING field +type RelatedContextPartySubIDField struct{ quickfix.FIXString } + +//Tag returns tag.RelatedContextPartySubID (1580) +func (f RelatedContextPartySubIDField) Tag() quickfix.Tag { return tag.RelatedContextPartySubID } + +//NewRelatedContextPartySubID returns a new RelatedContextPartySubIDField initialized with val +func NewRelatedContextPartySubID(val string) RelatedContextPartySubIDField { + return RelatedContextPartySubIDField{quickfix.FIXString(val)} +} + +//RelatedContextPartySubIDTypeField is a INT field +type RelatedContextPartySubIDTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.RelatedContextPartySubIDType (1581) +func (f RelatedContextPartySubIDTypeField) Tag() quickfix.Tag { return tag.RelatedContextPartySubIDType } + +//NewRelatedContextPartySubIDType returns a new RelatedContextPartySubIDTypeField initialized with val +func NewRelatedContextPartySubIDType(val int) RelatedContextPartySubIDTypeField { + return RelatedContextPartySubIDTypeField{quickfix.FIXInt(val)} +} + +//RelatedPartyAltIDField is a STRING field +type RelatedPartyAltIDField struct{ quickfix.FIXString } + +//Tag returns tag.RelatedPartyAltID (1570) +func (f RelatedPartyAltIDField) Tag() quickfix.Tag { return tag.RelatedPartyAltID } + +//NewRelatedPartyAltID returns a new RelatedPartyAltIDField initialized with val +func NewRelatedPartyAltID(val string) RelatedPartyAltIDField { + return RelatedPartyAltIDField{quickfix.FIXString(val)} +} + +//RelatedPartyAltIDSourceField is a CHAR field +type RelatedPartyAltIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.RelatedPartyAltIDSource (1571) +func (f RelatedPartyAltIDSourceField) Tag() quickfix.Tag { return tag.RelatedPartyAltIDSource } + +//NewRelatedPartyAltIDSource returns a new RelatedPartyAltIDSourceField initialized with val +func NewRelatedPartyAltIDSource(val string) RelatedPartyAltIDSourceField { + return RelatedPartyAltIDSourceField{quickfix.FIXString(val)} +} + +//RelatedPartyAltSubIDField is a STRING field +type RelatedPartyAltSubIDField struct{ quickfix.FIXString } + +//Tag returns tag.RelatedPartyAltSubID (1573) +func (f RelatedPartyAltSubIDField) Tag() quickfix.Tag { return tag.RelatedPartyAltSubID } + +//NewRelatedPartyAltSubID returns a new RelatedPartyAltSubIDField initialized with val +func NewRelatedPartyAltSubID(val string) RelatedPartyAltSubIDField { + return RelatedPartyAltSubIDField{quickfix.FIXString(val)} +} + +//RelatedPartyAltSubIDTypeField is a INT field +type RelatedPartyAltSubIDTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.RelatedPartyAltSubIDType (1574) +func (f RelatedPartyAltSubIDTypeField) Tag() quickfix.Tag { return tag.RelatedPartyAltSubIDType } + +//NewRelatedPartyAltSubIDType returns a new RelatedPartyAltSubIDTypeField initialized with val +func NewRelatedPartyAltSubIDType(val int) RelatedPartyAltSubIDTypeField { + return RelatedPartyAltSubIDTypeField{quickfix.FIXInt(val)} +} + +//RelatedPartyIDField is a STRING field +type RelatedPartyIDField struct{ quickfix.FIXString } + +//Tag returns tag.RelatedPartyID (1563) +func (f RelatedPartyIDField) Tag() quickfix.Tag { return tag.RelatedPartyID } + +//NewRelatedPartyID returns a new RelatedPartyIDField initialized with val +func NewRelatedPartyID(val string) RelatedPartyIDField { + return RelatedPartyIDField{quickfix.FIXString(val)} +} + +//RelatedPartyIDSourceField is a CHAR field +type RelatedPartyIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.RelatedPartyIDSource (1564) +func (f RelatedPartyIDSourceField) Tag() quickfix.Tag { return tag.RelatedPartyIDSource } + +//NewRelatedPartyIDSource returns a new RelatedPartyIDSourceField initialized with val +func NewRelatedPartyIDSource(val string) RelatedPartyIDSourceField { + return RelatedPartyIDSourceField{quickfix.FIXString(val)} +} + +//RelatedPartyRoleField is a INT field +type RelatedPartyRoleField struct{ quickfix.FIXInt } + +//Tag returns tag.RelatedPartyRole (1565) +func (f RelatedPartyRoleField) Tag() quickfix.Tag { return tag.RelatedPartyRole } + +//NewRelatedPartyRole returns a new RelatedPartyRoleField initialized with val +func NewRelatedPartyRole(val int) RelatedPartyRoleField { + return RelatedPartyRoleField{quickfix.FIXInt(val)} +} + +//RelatedPartySubIDField is a STRING field +type RelatedPartySubIDField struct{ quickfix.FIXString } + +//Tag returns tag.RelatedPartySubID (1567) +func (f RelatedPartySubIDField) Tag() quickfix.Tag { return tag.RelatedPartySubID } + +//NewRelatedPartySubID returns a new RelatedPartySubIDField initialized with val +func NewRelatedPartySubID(val string) RelatedPartySubIDField { + return RelatedPartySubIDField{quickfix.FIXString(val)} +} + +//RelatedPartySubIDTypeField is a INT field +type RelatedPartySubIDTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.RelatedPartySubIDType (1568) +func (f RelatedPartySubIDTypeField) Tag() quickfix.Tag { return tag.RelatedPartySubIDType } + +//NewRelatedPartySubIDType returns a new RelatedPartySubIDTypeField initialized with val +func NewRelatedPartySubIDType(val int) RelatedPartySubIDTypeField { + return RelatedPartySubIDTypeField{quickfix.FIXInt(val)} +} + +//RelationshipRiskCFICodeField is a STRING field +type RelationshipRiskCFICodeField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskCFICode (1599) +func (f RelationshipRiskCFICodeField) Tag() quickfix.Tag { return tag.RelationshipRiskCFICode } + +//NewRelationshipRiskCFICode returns a new RelationshipRiskCFICodeField initialized with val +func NewRelationshipRiskCFICode(val string) RelationshipRiskCFICodeField { + return RelationshipRiskCFICodeField{quickfix.FIXString(val)} +} + +//RelationshipRiskCouponRateField is a PERCENTAGE field +type RelationshipRiskCouponRateField struct{ quickfix.FIXFloat } + +//Tag returns tag.RelationshipRiskCouponRate (1608) +func (f RelationshipRiskCouponRateField) Tag() quickfix.Tag { return tag.RelationshipRiskCouponRate } + +//NewRelationshipRiskCouponRate returns a new RelationshipRiskCouponRateField initialized with val +func NewRelationshipRiskCouponRate(val float64) RelationshipRiskCouponRateField { + return RelationshipRiskCouponRateField{quickfix.FIXFloat(val)} +} + +//RelationshipRiskEncodedSecurityDescField is a DATA field +type RelationshipRiskEncodedSecurityDescField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskEncodedSecurityDesc (1619) +func (f RelationshipRiskEncodedSecurityDescField) Tag() quickfix.Tag { + return tag.RelationshipRiskEncodedSecurityDesc +} + +//NewRelationshipRiskEncodedSecurityDesc returns a new RelationshipRiskEncodedSecurityDescField initialized with val +func NewRelationshipRiskEncodedSecurityDesc(val string) RelationshipRiskEncodedSecurityDescField { + return RelationshipRiskEncodedSecurityDescField{quickfix.FIXString(val)} +} + +//RelationshipRiskEncodedSecurityDescLenField is a LENGTH field +type RelationshipRiskEncodedSecurityDescLenField struct{ quickfix.FIXInt } + +//Tag returns tag.RelationshipRiskEncodedSecurityDescLen (1618) +func (f RelationshipRiskEncodedSecurityDescLenField) Tag() quickfix.Tag { + return tag.RelationshipRiskEncodedSecurityDescLen +} + +//NewRelationshipRiskEncodedSecurityDescLen returns a new RelationshipRiskEncodedSecurityDescLenField initialized with val +func NewRelationshipRiskEncodedSecurityDescLen(val int) RelationshipRiskEncodedSecurityDescLenField { + return RelationshipRiskEncodedSecurityDescLenField{quickfix.FIXInt(val)} +} + +//RelationshipRiskFlexibleIndicatorField is a BOOLEAN field +type RelationshipRiskFlexibleIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.RelationshipRiskFlexibleIndicator (1607) +func (f RelationshipRiskFlexibleIndicatorField) Tag() quickfix.Tag { + return tag.RelationshipRiskFlexibleIndicator +} + +//NewRelationshipRiskFlexibleIndicator returns a new RelationshipRiskFlexibleIndicatorField initialized with val +func NewRelationshipRiskFlexibleIndicator(val bool) RelationshipRiskFlexibleIndicatorField { + return RelationshipRiskFlexibleIndicatorField{quickfix.FIXBoolean(val)} +} + +//RelationshipRiskInstrumentMultiplierField is a FLOAT field +type RelationshipRiskInstrumentMultiplierField struct{ quickfix.FIXFloat } + +//Tag returns tag.RelationshipRiskInstrumentMultiplier (1612) +func (f RelationshipRiskInstrumentMultiplierField) Tag() quickfix.Tag { + return tag.RelationshipRiskInstrumentMultiplier +} + +//NewRelationshipRiskInstrumentMultiplier returns a new RelationshipRiskInstrumentMultiplierField initialized with val +func NewRelationshipRiskInstrumentMultiplier(val float64) RelationshipRiskInstrumentMultiplierField { + return RelationshipRiskInstrumentMultiplierField{quickfix.FIXFloat(val)} +} + +//RelationshipRiskInstrumentOperatorField is a INT field +type RelationshipRiskInstrumentOperatorField struct{ quickfix.FIXInt } + +//Tag returns tag.RelationshipRiskInstrumentOperator (1588) +func (f RelationshipRiskInstrumentOperatorField) Tag() quickfix.Tag { + return tag.RelationshipRiskInstrumentOperator +} + +//NewRelationshipRiskInstrumentOperator returns a new RelationshipRiskInstrumentOperatorField initialized with val +func NewRelationshipRiskInstrumentOperator(val int) RelationshipRiskInstrumentOperatorField { + return RelationshipRiskInstrumentOperatorField{quickfix.FIXInt(val)} +} + +//RelationshipRiskInstrumentSettlTypeField is a STRING field +type RelationshipRiskInstrumentSettlTypeField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskInstrumentSettlType (1611) +func (f RelationshipRiskInstrumentSettlTypeField) Tag() quickfix.Tag { + return tag.RelationshipRiskInstrumentSettlType +} + +//NewRelationshipRiskInstrumentSettlType returns a new RelationshipRiskInstrumentSettlTypeField initialized with val +func NewRelationshipRiskInstrumentSettlType(val string) RelationshipRiskInstrumentSettlTypeField { + return RelationshipRiskInstrumentSettlTypeField{quickfix.FIXString(val)} +} + +//RelationshipRiskLimitAmountField is a AMT field +type RelationshipRiskLimitAmountField struct{ quickfix.FIXFloat } + +//Tag returns tag.RelationshipRiskLimitAmount (1584) +func (f RelationshipRiskLimitAmountField) Tag() quickfix.Tag { return tag.RelationshipRiskLimitAmount } + +//NewRelationshipRiskLimitAmount returns a new RelationshipRiskLimitAmountField initialized with val +func NewRelationshipRiskLimitAmount(val float64) RelationshipRiskLimitAmountField { + return RelationshipRiskLimitAmountField{quickfix.FIXFloat(val)} +} + +//RelationshipRiskLimitCurrencyField is a CURRENCY field +type RelationshipRiskLimitCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskLimitCurrency (1585) +func (f RelationshipRiskLimitCurrencyField) Tag() quickfix.Tag { + return tag.RelationshipRiskLimitCurrency +} + +//NewRelationshipRiskLimitCurrency returns a new RelationshipRiskLimitCurrencyField initialized with val +func NewRelationshipRiskLimitCurrency(val string) RelationshipRiskLimitCurrencyField { + return RelationshipRiskLimitCurrencyField{quickfix.FIXString(val)} +} + +//RelationshipRiskLimitPlatformField is a STRING field +type RelationshipRiskLimitPlatformField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskLimitPlatform (1586) +func (f RelationshipRiskLimitPlatformField) Tag() quickfix.Tag { + return tag.RelationshipRiskLimitPlatform +} + +//NewRelationshipRiskLimitPlatform returns a new RelationshipRiskLimitPlatformField initialized with val +func NewRelationshipRiskLimitPlatform(val string) RelationshipRiskLimitPlatformField { + return RelationshipRiskLimitPlatformField{quickfix.FIXString(val)} +} + +//RelationshipRiskLimitTypeField is a INT field +type RelationshipRiskLimitTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.RelationshipRiskLimitType (1583) +func (f RelationshipRiskLimitTypeField) Tag() quickfix.Tag { return tag.RelationshipRiskLimitType } + +//NewRelationshipRiskLimitType returns a new RelationshipRiskLimitTypeField initialized with val +func NewRelationshipRiskLimitType(val int) RelationshipRiskLimitTypeField { + return RelationshipRiskLimitTypeField{quickfix.FIXInt(val)} +} + +//RelationshipRiskMaturityMonthYearField is a MONTHYEAR field +type RelationshipRiskMaturityMonthYearField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskMaturityMonthYear (1602) +func (f RelationshipRiskMaturityMonthYearField) Tag() quickfix.Tag { + return tag.RelationshipRiskMaturityMonthYear +} + +//NewRelationshipRiskMaturityMonthYear returns a new RelationshipRiskMaturityMonthYearField initialized with val +func NewRelationshipRiskMaturityMonthYear(val string) RelationshipRiskMaturityMonthYearField { + return RelationshipRiskMaturityMonthYearField{quickfix.FIXString(val)} +} + +//RelationshipRiskMaturityTimeField is a TZTIMEONLY field +type RelationshipRiskMaturityTimeField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskMaturityTime (1603) +func (f RelationshipRiskMaturityTimeField) Tag() quickfix.Tag { return tag.RelationshipRiskMaturityTime } + +//NewRelationshipRiskMaturityTime returns a new RelationshipRiskMaturityTimeField initialized with val +func NewRelationshipRiskMaturityTime(val string) RelationshipRiskMaturityTimeField { + return RelationshipRiskMaturityTimeField{quickfix.FIXString(val)} +} + +//RelationshipRiskProductField is a INT field +type RelationshipRiskProductField struct{ quickfix.FIXInt } + +//Tag returns tag.RelationshipRiskProduct (1596) +func (f RelationshipRiskProductField) Tag() quickfix.Tag { return tag.RelationshipRiskProduct } + +//NewRelationshipRiskProduct returns a new RelationshipRiskProductField initialized with val +func NewRelationshipRiskProduct(val int) RelationshipRiskProductField { + return RelationshipRiskProductField{quickfix.FIXInt(val)} +} + +//RelationshipRiskProductComplexField is a STRING field +type RelationshipRiskProductComplexField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskProductComplex (1597) +func (f RelationshipRiskProductComplexField) Tag() quickfix.Tag { + return tag.RelationshipRiskProductComplex +} + +//NewRelationshipRiskProductComplex returns a new RelationshipRiskProductComplexField initialized with val +func NewRelationshipRiskProductComplex(val string) RelationshipRiskProductComplexField { + return RelationshipRiskProductComplexField{quickfix.FIXString(val)} +} + +//RelationshipRiskPutOrCallField is a INT field +type RelationshipRiskPutOrCallField struct{ quickfix.FIXInt } + +//Tag returns tag.RelationshipRiskPutOrCall (1606) +func (f RelationshipRiskPutOrCallField) Tag() quickfix.Tag { return tag.RelationshipRiskPutOrCall } + +//NewRelationshipRiskPutOrCall returns a new RelationshipRiskPutOrCallField initialized with val +func NewRelationshipRiskPutOrCall(val int) RelationshipRiskPutOrCallField { + return RelationshipRiskPutOrCallField{quickfix.FIXInt(val)} +} + +//RelationshipRiskRestructuringTypeField is a STRING field +type RelationshipRiskRestructuringTypeField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskRestructuringType (1604) +func (f RelationshipRiskRestructuringTypeField) Tag() quickfix.Tag { + return tag.RelationshipRiskRestructuringType +} + +//NewRelationshipRiskRestructuringType returns a new RelationshipRiskRestructuringTypeField initialized with val +func NewRelationshipRiskRestructuringType(val string) RelationshipRiskRestructuringTypeField { + return RelationshipRiskRestructuringTypeField{quickfix.FIXString(val)} +} + +//RelationshipRiskSecurityAltIDField is a STRING field +type RelationshipRiskSecurityAltIDField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskSecurityAltID (1594) +func (f RelationshipRiskSecurityAltIDField) Tag() quickfix.Tag { + return tag.RelationshipRiskSecurityAltID +} + +//NewRelationshipRiskSecurityAltID returns a new RelationshipRiskSecurityAltIDField initialized with val +func NewRelationshipRiskSecurityAltID(val string) RelationshipRiskSecurityAltIDField { + return RelationshipRiskSecurityAltIDField{quickfix.FIXString(val)} +} + +//RelationshipRiskSecurityAltIDSourceField is a STRING field +type RelationshipRiskSecurityAltIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskSecurityAltIDSource (1595) +func (f RelationshipRiskSecurityAltIDSourceField) Tag() quickfix.Tag { + return tag.RelationshipRiskSecurityAltIDSource +} + +//NewRelationshipRiskSecurityAltIDSource returns a new RelationshipRiskSecurityAltIDSourceField initialized with val +func NewRelationshipRiskSecurityAltIDSource(val string) RelationshipRiskSecurityAltIDSourceField { + return RelationshipRiskSecurityAltIDSourceField{quickfix.FIXString(val)} +} + +//RelationshipRiskSecurityDescField is a STRING field +type RelationshipRiskSecurityDescField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskSecurityDesc (1610) +func (f RelationshipRiskSecurityDescField) Tag() quickfix.Tag { return tag.RelationshipRiskSecurityDesc } + +//NewRelationshipRiskSecurityDesc returns a new RelationshipRiskSecurityDescField initialized with val +func NewRelationshipRiskSecurityDesc(val string) RelationshipRiskSecurityDescField { + return RelationshipRiskSecurityDescField{quickfix.FIXString(val)} +} + +//RelationshipRiskSecurityExchangeField is a EXCHANGE field +type RelationshipRiskSecurityExchangeField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskSecurityExchange (1609) +func (f RelationshipRiskSecurityExchangeField) Tag() quickfix.Tag { + return tag.RelationshipRiskSecurityExchange +} + +//NewRelationshipRiskSecurityExchange returns a new RelationshipRiskSecurityExchangeField initialized with val +func NewRelationshipRiskSecurityExchange(val string) RelationshipRiskSecurityExchangeField { + return RelationshipRiskSecurityExchangeField{quickfix.FIXString(val)} +} + +//RelationshipRiskSecurityGroupField is a STRING field +type RelationshipRiskSecurityGroupField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskSecurityGroup (1598) +func (f RelationshipRiskSecurityGroupField) Tag() quickfix.Tag { + return tag.RelationshipRiskSecurityGroup +} + +//NewRelationshipRiskSecurityGroup returns a new RelationshipRiskSecurityGroupField initialized with val +func NewRelationshipRiskSecurityGroup(val string) RelationshipRiskSecurityGroupField { + return RelationshipRiskSecurityGroupField{quickfix.FIXString(val)} +} + +//RelationshipRiskSecurityIDField is a STRING field +type RelationshipRiskSecurityIDField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskSecurityID (1591) +func (f RelationshipRiskSecurityIDField) Tag() quickfix.Tag { return tag.RelationshipRiskSecurityID } + +//NewRelationshipRiskSecurityID returns a new RelationshipRiskSecurityIDField initialized with val +func NewRelationshipRiskSecurityID(val string) RelationshipRiskSecurityIDField { + return RelationshipRiskSecurityIDField{quickfix.FIXString(val)} +} + +//RelationshipRiskSecurityIDSourceField is a STRING field +type RelationshipRiskSecurityIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskSecurityIDSource (1592) +func (f RelationshipRiskSecurityIDSourceField) Tag() quickfix.Tag { + return tag.RelationshipRiskSecurityIDSource +} + +//NewRelationshipRiskSecurityIDSource returns a new RelationshipRiskSecurityIDSourceField initialized with val +func NewRelationshipRiskSecurityIDSource(val string) RelationshipRiskSecurityIDSourceField { + return RelationshipRiskSecurityIDSourceField{quickfix.FIXString(val)} +} + +//RelationshipRiskSecuritySubTypeField is a STRING field +type RelationshipRiskSecuritySubTypeField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskSecuritySubType (1601) +func (f RelationshipRiskSecuritySubTypeField) Tag() quickfix.Tag { + return tag.RelationshipRiskSecuritySubType +} + +//NewRelationshipRiskSecuritySubType returns a new RelationshipRiskSecuritySubTypeField initialized with val +func NewRelationshipRiskSecuritySubType(val string) RelationshipRiskSecuritySubTypeField { + return RelationshipRiskSecuritySubTypeField{quickfix.FIXString(val)} +} + +//RelationshipRiskSecurityTypeField is a STRING field +type RelationshipRiskSecurityTypeField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskSecurityType (1600) +func (f RelationshipRiskSecurityTypeField) Tag() quickfix.Tag { return tag.RelationshipRiskSecurityType } + +//NewRelationshipRiskSecurityType returns a new RelationshipRiskSecurityTypeField initialized with val +func NewRelationshipRiskSecurityType(val string) RelationshipRiskSecurityTypeField { + return RelationshipRiskSecurityTypeField{quickfix.FIXString(val)} +} + +//RelationshipRiskSeniorityField is a STRING field +type RelationshipRiskSeniorityField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskSeniority (1605) +func (f RelationshipRiskSeniorityField) Tag() quickfix.Tag { return tag.RelationshipRiskSeniority } + +//NewRelationshipRiskSeniority returns a new RelationshipRiskSeniorityField initialized with val +func NewRelationshipRiskSeniority(val string) RelationshipRiskSeniorityField { + return RelationshipRiskSeniorityField{quickfix.FIXString(val)} +} + +//RelationshipRiskSymbolField is a STRING field +type RelationshipRiskSymbolField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskSymbol (1589) +func (f RelationshipRiskSymbolField) Tag() quickfix.Tag { return tag.RelationshipRiskSymbol } + +//NewRelationshipRiskSymbol returns a new RelationshipRiskSymbolField initialized with val +func NewRelationshipRiskSymbol(val string) RelationshipRiskSymbolField { + return RelationshipRiskSymbolField{quickfix.FIXString(val)} +} + +//RelationshipRiskSymbolSfxField is a STRING field +type RelationshipRiskSymbolSfxField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskSymbolSfx (1590) +func (f RelationshipRiskSymbolSfxField) Tag() quickfix.Tag { return tag.RelationshipRiskSymbolSfx } + +//NewRelationshipRiskSymbolSfx returns a new RelationshipRiskSymbolSfxField initialized with val +func NewRelationshipRiskSymbolSfx(val string) RelationshipRiskSymbolSfxField { + return RelationshipRiskSymbolSfxField{quickfix.FIXString(val)} +} + +//RelationshipRiskWarningLevelNameField is a STRING field +type RelationshipRiskWarningLevelNameField struct{ quickfix.FIXString } + +//Tag returns tag.RelationshipRiskWarningLevelName (1615) +func (f RelationshipRiskWarningLevelNameField) Tag() quickfix.Tag { + return tag.RelationshipRiskWarningLevelName +} + +//NewRelationshipRiskWarningLevelName returns a new RelationshipRiskWarningLevelNameField initialized with val +func NewRelationshipRiskWarningLevelName(val string) RelationshipRiskWarningLevelNameField { + return RelationshipRiskWarningLevelNameField{quickfix.FIXString(val)} +} + +//RelationshipRiskWarningLevelPercentField is a PERCENTAGE field +type RelationshipRiskWarningLevelPercentField struct{ quickfix.FIXFloat } + +//Tag returns tag.RelationshipRiskWarningLevelPercent (1614) +func (f RelationshipRiskWarningLevelPercentField) Tag() quickfix.Tag { + return tag.RelationshipRiskWarningLevelPercent +} + +//NewRelationshipRiskWarningLevelPercent returns a new RelationshipRiskWarningLevelPercentField initialized with val +func NewRelationshipRiskWarningLevelPercent(val float64) RelationshipRiskWarningLevelPercentField { + return RelationshipRiskWarningLevelPercentField{quickfix.FIXFloat(val)} +} + +//RepoCollateralSecurityTypeField is a INT field +type RepoCollateralSecurityTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.RepoCollateralSecurityType (239) +func (f RepoCollateralSecurityTypeField) Tag() quickfix.Tag { return tag.RepoCollateralSecurityType } + +//NewRepoCollateralSecurityType returns a new RepoCollateralSecurityTypeField initialized with val +func NewRepoCollateralSecurityType(val int) RepoCollateralSecurityTypeField { + return RepoCollateralSecurityTypeField{quickfix.FIXInt(val)} +} + +//ReportToExchField is a BOOLEAN field +type ReportToExchField struct{ quickfix.FIXBoolean } + +//Tag returns tag.ReportToExch (113) +func (f ReportToExchField) Tag() quickfix.Tag { return tag.ReportToExch } + +//NewReportToExch returns a new ReportToExchField initialized with val +func NewReportToExch(val bool) ReportToExchField { + return ReportToExchField{quickfix.FIXBoolean(val)} +} + +//ReportedPxField is a PRICE field +type ReportedPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.ReportedPx (861) +func (f ReportedPxField) Tag() quickfix.Tag { return tag.ReportedPx } + +//NewReportedPx returns a new ReportedPxField initialized with val +func NewReportedPx(val float64) ReportedPxField { + return ReportedPxField{quickfix.FIXFloat(val)} +} + +//ReportedPxDiffField is a BOOLEAN field +type ReportedPxDiffField struct{ quickfix.FIXBoolean } + +//Tag returns tag.ReportedPxDiff (1134) +func (f ReportedPxDiffField) Tag() quickfix.Tag { return tag.ReportedPxDiff } + +//NewReportedPxDiff returns a new ReportedPxDiffField initialized with val +func NewReportedPxDiff(val bool) ReportedPxDiffField { + return ReportedPxDiffField{quickfix.FIXBoolean(val)} +} + +//RepurchaseRateField is a PERCENTAGE field +type RepurchaseRateField struct{ quickfix.FIXFloat } + +//Tag returns tag.RepurchaseRate (227) +func (f RepurchaseRateField) Tag() quickfix.Tag { return tag.RepurchaseRate } + +//NewRepurchaseRate returns a new RepurchaseRateField initialized with val +func NewRepurchaseRate(val float64) RepurchaseRateField { + return RepurchaseRateField{quickfix.FIXFloat(val)} +} + +//RepurchaseTermField is a INT field +type RepurchaseTermField struct{ quickfix.FIXInt } + +//Tag returns tag.RepurchaseTerm (226) +func (f RepurchaseTermField) Tag() quickfix.Tag { return tag.RepurchaseTerm } + +//NewRepurchaseTerm returns a new RepurchaseTermField initialized with val +func NewRepurchaseTerm(val int) RepurchaseTermField { + return RepurchaseTermField{quickfix.FIXInt(val)} +} + +//RequestedPartyRoleField is a INT field +type RequestedPartyRoleField struct{ quickfix.FIXInt } + +//Tag returns tag.RequestedPartyRole (1509) +func (f RequestedPartyRoleField) Tag() quickfix.Tag { return tag.RequestedPartyRole } + +//NewRequestedPartyRole returns a new RequestedPartyRoleField initialized with val +func NewRequestedPartyRole(val int) RequestedPartyRoleField { + return RequestedPartyRoleField{quickfix.FIXInt(val)} +} + +//ResetSeqNumFlagField is a BOOLEAN field +type ResetSeqNumFlagField struct{ quickfix.FIXBoolean } + +//Tag returns tag.ResetSeqNumFlag (141) +func (f ResetSeqNumFlagField) Tag() quickfix.Tag { return tag.ResetSeqNumFlag } + +//NewResetSeqNumFlag returns a new ResetSeqNumFlagField initialized with val +func NewResetSeqNumFlag(val bool) ResetSeqNumFlagField { + return ResetSeqNumFlagField{quickfix.FIXBoolean(val)} +} + +//RespondentTypeField is a INT field +type RespondentTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.RespondentType (1172) +func (f RespondentTypeField) Tag() quickfix.Tag { return tag.RespondentType } + +//NewRespondentType returns a new RespondentTypeField initialized with val +func NewRespondentType(val int) RespondentTypeField { + return RespondentTypeField{quickfix.FIXInt(val)} +} + +//ResponseDestinationField is a STRING field +type ResponseDestinationField struct{ quickfix.FIXString } + +//Tag returns tag.ResponseDestination (726) +func (f ResponseDestinationField) Tag() quickfix.Tag { return tag.ResponseDestination } + +//NewResponseDestination returns a new ResponseDestinationField initialized with val +func NewResponseDestination(val string) ResponseDestinationField { + return ResponseDestinationField{quickfix.FIXString(val)} +} + +//ResponseTransportTypeField is a INT field +type ResponseTransportTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.ResponseTransportType (725) +func (f ResponseTransportTypeField) Tag() quickfix.Tag { return tag.ResponseTransportType } + +//NewResponseTransportType returns a new ResponseTransportTypeField initialized with val +func NewResponseTransportType(val int) ResponseTransportTypeField { + return ResponseTransportTypeField{quickfix.FIXInt(val)} +} + +//RestructuringTypeField is a STRING field +type RestructuringTypeField struct{ quickfix.FIXString } + +//Tag returns tag.RestructuringType (1449) +func (f RestructuringTypeField) Tag() quickfix.Tag { return tag.RestructuringType } + +//NewRestructuringType returns a new RestructuringTypeField initialized with val +func NewRestructuringType(val string) RestructuringTypeField { + return RestructuringTypeField{quickfix.FIXString(val)} +} + +//ReversalIndicatorField is a BOOLEAN field +type ReversalIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.ReversalIndicator (700) +func (f ReversalIndicatorField) Tag() quickfix.Tag { return tag.ReversalIndicator } + +//NewReversalIndicator returns a new ReversalIndicatorField initialized with val +func NewReversalIndicator(val bool) ReversalIndicatorField { + return ReversalIndicatorField{quickfix.FIXBoolean(val)} +} + +//RiskCFICodeField is a STRING field +type RiskCFICodeField struct{ quickfix.FIXString } + +//Tag returns tag.RiskCFICode (1546) +func (f RiskCFICodeField) Tag() quickfix.Tag { return tag.RiskCFICode } + +//NewRiskCFICode returns a new RiskCFICodeField initialized with val +func NewRiskCFICode(val string) RiskCFICodeField { + return RiskCFICodeField{quickfix.FIXString(val)} +} + +//RiskCouponRateField is a PERCENTAGE field +type RiskCouponRateField struct{ quickfix.FIXFloat } + +//Tag returns tag.RiskCouponRate (1555) +func (f RiskCouponRateField) Tag() quickfix.Tag { return tag.RiskCouponRate } + +//NewRiskCouponRate returns a new RiskCouponRateField initialized with val +func NewRiskCouponRate(val float64) RiskCouponRateField { + return RiskCouponRateField{quickfix.FIXFloat(val)} +} + +//RiskEncodedSecurityDescField is a DATA field +type RiskEncodedSecurityDescField struct{ quickfix.FIXString } + +//Tag returns tag.RiskEncodedSecurityDesc (1621) +func (f RiskEncodedSecurityDescField) Tag() quickfix.Tag { return tag.RiskEncodedSecurityDesc } + +//NewRiskEncodedSecurityDesc returns a new RiskEncodedSecurityDescField initialized with val +func NewRiskEncodedSecurityDesc(val string) RiskEncodedSecurityDescField { + return RiskEncodedSecurityDescField{quickfix.FIXString(val)} +} + +//RiskEncodedSecurityDescLenField is a LENGTH field +type RiskEncodedSecurityDescLenField struct{ quickfix.FIXInt } + +//Tag returns tag.RiskEncodedSecurityDescLen (1620) +func (f RiskEncodedSecurityDescLenField) Tag() quickfix.Tag { return tag.RiskEncodedSecurityDescLen } + +//NewRiskEncodedSecurityDescLen returns a new RiskEncodedSecurityDescLenField initialized with val +func NewRiskEncodedSecurityDescLen(val int) RiskEncodedSecurityDescLenField { + return RiskEncodedSecurityDescLenField{quickfix.FIXInt(val)} +} + +//RiskFlexibleIndicatorField is a BOOLEAN field +type RiskFlexibleIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.RiskFlexibleIndicator (1554) +func (f RiskFlexibleIndicatorField) Tag() quickfix.Tag { return tag.RiskFlexibleIndicator } + +//NewRiskFlexibleIndicator returns a new RiskFlexibleIndicatorField initialized with val +func NewRiskFlexibleIndicator(val bool) RiskFlexibleIndicatorField { + return RiskFlexibleIndicatorField{quickfix.FIXBoolean(val)} +} + +//RiskFreeRateField is a FLOAT field +type RiskFreeRateField struct{ quickfix.FIXFloat } + +//Tag returns tag.RiskFreeRate (1190) +func (f RiskFreeRateField) Tag() quickfix.Tag { return tag.RiskFreeRate } + +//NewRiskFreeRate returns a new RiskFreeRateField initialized with val +func NewRiskFreeRate(val float64) RiskFreeRateField { + return RiskFreeRateField{quickfix.FIXFloat(val)} +} + +//RiskInstrumentMultiplierField is a FLOAT field +type RiskInstrumentMultiplierField struct{ quickfix.FIXFloat } + +//Tag returns tag.RiskInstrumentMultiplier (1558) +func (f RiskInstrumentMultiplierField) Tag() quickfix.Tag { return tag.RiskInstrumentMultiplier } + +//NewRiskInstrumentMultiplier returns a new RiskInstrumentMultiplierField initialized with val +func NewRiskInstrumentMultiplier(val float64) RiskInstrumentMultiplierField { + return RiskInstrumentMultiplierField{quickfix.FIXFloat(val)} +} + +//RiskInstrumentOperatorField is a INT field +type RiskInstrumentOperatorField struct{ quickfix.FIXInt } + +//Tag returns tag.RiskInstrumentOperator (1535) +func (f RiskInstrumentOperatorField) Tag() quickfix.Tag { return tag.RiskInstrumentOperator } + +//NewRiskInstrumentOperator returns a new RiskInstrumentOperatorField initialized with val +func NewRiskInstrumentOperator(val int) RiskInstrumentOperatorField { + return RiskInstrumentOperatorField{quickfix.FIXInt(val)} +} + +//RiskInstrumentSettlTypeField is a STRING field +type RiskInstrumentSettlTypeField struct{ quickfix.FIXString } + +//Tag returns tag.RiskInstrumentSettlType (1557) +func (f RiskInstrumentSettlTypeField) Tag() quickfix.Tag { return tag.RiskInstrumentSettlType } + +//NewRiskInstrumentSettlType returns a new RiskInstrumentSettlTypeField initialized with val +func NewRiskInstrumentSettlType(val string) RiskInstrumentSettlTypeField { + return RiskInstrumentSettlTypeField{quickfix.FIXString(val)} +} + +//RiskLimitAmountField is a AMT field +type RiskLimitAmountField struct{ quickfix.FIXFloat } + +//Tag returns tag.RiskLimitAmount (1531) +func (f RiskLimitAmountField) Tag() quickfix.Tag { return tag.RiskLimitAmount } + +//NewRiskLimitAmount returns a new RiskLimitAmountField initialized with val +func NewRiskLimitAmount(val float64) RiskLimitAmountField { + return RiskLimitAmountField{quickfix.FIXFloat(val)} +} + +//RiskLimitCurrencyField is a CURRENCY field +type RiskLimitCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.RiskLimitCurrency (1532) +func (f RiskLimitCurrencyField) Tag() quickfix.Tag { return tag.RiskLimitCurrency } + +//NewRiskLimitCurrency returns a new RiskLimitCurrencyField initialized with val +func NewRiskLimitCurrency(val string) RiskLimitCurrencyField { + return RiskLimitCurrencyField{quickfix.FIXString(val)} +} + +//RiskLimitPlatformField is a STRING field +type RiskLimitPlatformField struct{ quickfix.FIXString } + +//Tag returns tag.RiskLimitPlatform (1533) +func (f RiskLimitPlatformField) Tag() quickfix.Tag { return tag.RiskLimitPlatform } + +//NewRiskLimitPlatform returns a new RiskLimitPlatformField initialized with val +func NewRiskLimitPlatform(val string) RiskLimitPlatformField { + return RiskLimitPlatformField{quickfix.FIXString(val)} +} + +//RiskLimitTypeField is a INT field +type RiskLimitTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.RiskLimitType (1530) +func (f RiskLimitTypeField) Tag() quickfix.Tag { return tag.RiskLimitType } + +//NewRiskLimitType returns a new RiskLimitTypeField initialized with val +func NewRiskLimitType(val int) RiskLimitTypeField { + return RiskLimitTypeField{quickfix.FIXInt(val)} +} + +//RiskMaturityMonthYearField is a MONTHYEAR field +type RiskMaturityMonthYearField struct{ quickfix.FIXString } + +//Tag returns tag.RiskMaturityMonthYear (1549) +func (f RiskMaturityMonthYearField) Tag() quickfix.Tag { return tag.RiskMaturityMonthYear } + +//NewRiskMaturityMonthYear returns a new RiskMaturityMonthYearField initialized with val +func NewRiskMaturityMonthYear(val string) RiskMaturityMonthYearField { + return RiskMaturityMonthYearField{quickfix.FIXString(val)} +} + +//RiskMaturityTimeField is a TZTIMEONLY field +type RiskMaturityTimeField struct{ quickfix.FIXString } + +//Tag returns tag.RiskMaturityTime (1550) +func (f RiskMaturityTimeField) Tag() quickfix.Tag { return tag.RiskMaturityTime } + +//NewRiskMaturityTime returns a new RiskMaturityTimeField initialized with val +func NewRiskMaturityTime(val string) RiskMaturityTimeField { + return RiskMaturityTimeField{quickfix.FIXString(val)} +} + +//RiskProductField is a INT field +type RiskProductField struct{ quickfix.FIXInt } + +//Tag returns tag.RiskProduct (1543) +func (f RiskProductField) Tag() quickfix.Tag { return tag.RiskProduct } + +//NewRiskProduct returns a new RiskProductField initialized with val +func NewRiskProduct(val int) RiskProductField { + return RiskProductField{quickfix.FIXInt(val)} +} + +//RiskProductComplexField is a STRING field +type RiskProductComplexField struct{ quickfix.FIXString } + +//Tag returns tag.RiskProductComplex (1544) +func (f RiskProductComplexField) Tag() quickfix.Tag { return tag.RiskProductComplex } + +//NewRiskProductComplex returns a new RiskProductComplexField initialized with val +func NewRiskProductComplex(val string) RiskProductComplexField { + return RiskProductComplexField{quickfix.FIXString(val)} +} + +//RiskPutOrCallField is a INT field +type RiskPutOrCallField struct{ quickfix.FIXInt } + +//Tag returns tag.RiskPutOrCall (1553) +func (f RiskPutOrCallField) Tag() quickfix.Tag { return tag.RiskPutOrCall } + +//NewRiskPutOrCall returns a new RiskPutOrCallField initialized with val +func NewRiskPutOrCall(val int) RiskPutOrCallField { + return RiskPutOrCallField{quickfix.FIXInt(val)} +} + +//RiskRestructuringTypeField is a STRING field +type RiskRestructuringTypeField struct{ quickfix.FIXString } + +//Tag returns tag.RiskRestructuringType (1551) +func (f RiskRestructuringTypeField) Tag() quickfix.Tag { return tag.RiskRestructuringType } + +//NewRiskRestructuringType returns a new RiskRestructuringTypeField initialized with val +func NewRiskRestructuringType(val string) RiskRestructuringTypeField { + return RiskRestructuringTypeField{quickfix.FIXString(val)} +} + +//RiskSecurityAltIDField is a STRING field +type RiskSecurityAltIDField struct{ quickfix.FIXString } + +//Tag returns tag.RiskSecurityAltID (1541) +func (f RiskSecurityAltIDField) Tag() quickfix.Tag { return tag.RiskSecurityAltID } + +//NewRiskSecurityAltID returns a new RiskSecurityAltIDField initialized with val +func NewRiskSecurityAltID(val string) RiskSecurityAltIDField { + return RiskSecurityAltIDField{quickfix.FIXString(val)} +} + +//RiskSecurityAltIDSourceField is a STRING field +type RiskSecurityAltIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.RiskSecurityAltIDSource (1542) +func (f RiskSecurityAltIDSourceField) Tag() quickfix.Tag { return tag.RiskSecurityAltIDSource } + +//NewRiskSecurityAltIDSource returns a new RiskSecurityAltIDSourceField initialized with val +func NewRiskSecurityAltIDSource(val string) RiskSecurityAltIDSourceField { + return RiskSecurityAltIDSourceField{quickfix.FIXString(val)} +} + +//RiskSecurityDescField is a STRING field +type RiskSecurityDescField struct{ quickfix.FIXString } + +//Tag returns tag.RiskSecurityDesc (1556) +func (f RiskSecurityDescField) Tag() quickfix.Tag { return tag.RiskSecurityDesc } + +//NewRiskSecurityDesc returns a new RiskSecurityDescField initialized with val +func NewRiskSecurityDesc(val string) RiskSecurityDescField { + return RiskSecurityDescField{quickfix.FIXString(val)} +} + +//RiskSecurityExchangeField is a EXCHANGE field +type RiskSecurityExchangeField struct{ quickfix.FIXString } + +//Tag returns tag.RiskSecurityExchange (1616) +func (f RiskSecurityExchangeField) Tag() quickfix.Tag { return tag.RiskSecurityExchange } + +//NewRiskSecurityExchange returns a new RiskSecurityExchangeField initialized with val +func NewRiskSecurityExchange(val string) RiskSecurityExchangeField { + return RiskSecurityExchangeField{quickfix.FIXString(val)} +} + +//RiskSecurityGroupField is a STRING field +type RiskSecurityGroupField struct{ quickfix.FIXString } + +//Tag returns tag.RiskSecurityGroup (1545) +func (f RiskSecurityGroupField) Tag() quickfix.Tag { return tag.RiskSecurityGroup } + +//NewRiskSecurityGroup returns a new RiskSecurityGroupField initialized with val +func NewRiskSecurityGroup(val string) RiskSecurityGroupField { + return RiskSecurityGroupField{quickfix.FIXString(val)} +} + +//RiskSecurityIDField is a STRING field +type RiskSecurityIDField struct{ quickfix.FIXString } + +//Tag returns tag.RiskSecurityID (1538) +func (f RiskSecurityIDField) Tag() quickfix.Tag { return tag.RiskSecurityID } + +//NewRiskSecurityID returns a new RiskSecurityIDField initialized with val +func NewRiskSecurityID(val string) RiskSecurityIDField { + return RiskSecurityIDField{quickfix.FIXString(val)} +} + +//RiskSecurityIDSourceField is a STRING field +type RiskSecurityIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.RiskSecurityIDSource (1539) +func (f RiskSecurityIDSourceField) Tag() quickfix.Tag { return tag.RiskSecurityIDSource } + +//NewRiskSecurityIDSource returns a new RiskSecurityIDSourceField initialized with val +func NewRiskSecurityIDSource(val string) RiskSecurityIDSourceField { + return RiskSecurityIDSourceField{quickfix.FIXString(val)} +} + +//RiskSecuritySubTypeField is a STRING field +type RiskSecuritySubTypeField struct{ quickfix.FIXString } + +//Tag returns tag.RiskSecuritySubType (1548) +func (f RiskSecuritySubTypeField) Tag() quickfix.Tag { return tag.RiskSecuritySubType } + +//NewRiskSecuritySubType returns a new RiskSecuritySubTypeField initialized with val +func NewRiskSecuritySubType(val string) RiskSecuritySubTypeField { + return RiskSecuritySubTypeField{quickfix.FIXString(val)} +} + +//RiskSecurityTypeField is a STRING field +type RiskSecurityTypeField struct{ quickfix.FIXString } + +//Tag returns tag.RiskSecurityType (1547) +func (f RiskSecurityTypeField) Tag() quickfix.Tag { return tag.RiskSecurityType } + +//NewRiskSecurityType returns a new RiskSecurityTypeField initialized with val +func NewRiskSecurityType(val string) RiskSecurityTypeField { + return RiskSecurityTypeField{quickfix.FIXString(val)} +} + +//RiskSeniorityField is a STRING field +type RiskSeniorityField struct{ quickfix.FIXString } + +//Tag returns tag.RiskSeniority (1552) +func (f RiskSeniorityField) Tag() quickfix.Tag { return tag.RiskSeniority } + +//NewRiskSeniority returns a new RiskSeniorityField initialized with val +func NewRiskSeniority(val string) RiskSeniorityField { + return RiskSeniorityField{quickfix.FIXString(val)} +} + +//RiskSymbolField is a STRING field +type RiskSymbolField struct{ quickfix.FIXString } + +//Tag returns tag.RiskSymbol (1536) +func (f RiskSymbolField) Tag() quickfix.Tag { return tag.RiskSymbol } + +//NewRiskSymbol returns a new RiskSymbolField initialized with val +func NewRiskSymbol(val string) RiskSymbolField { + return RiskSymbolField{quickfix.FIXString(val)} +} + +//RiskSymbolSfxField is a STRING field +type RiskSymbolSfxField struct{ quickfix.FIXString } + +//Tag returns tag.RiskSymbolSfx (1537) +func (f RiskSymbolSfxField) Tag() quickfix.Tag { return tag.RiskSymbolSfx } + +//NewRiskSymbolSfx returns a new RiskSymbolSfxField initialized with val +func NewRiskSymbolSfx(val string) RiskSymbolSfxField { + return RiskSymbolSfxField{quickfix.FIXString(val)} +} + +//RiskWarningLevelNameField is a STRING field +type RiskWarningLevelNameField struct{ quickfix.FIXString } + +//Tag returns tag.RiskWarningLevelName (1561) +func (f RiskWarningLevelNameField) Tag() quickfix.Tag { return tag.RiskWarningLevelName } + +//NewRiskWarningLevelName returns a new RiskWarningLevelNameField initialized with val +func NewRiskWarningLevelName(val string) RiskWarningLevelNameField { + return RiskWarningLevelNameField{quickfix.FIXString(val)} +} + +//RiskWarningLevelPercentField is a PERCENTAGE field +type RiskWarningLevelPercentField struct{ quickfix.FIXFloat } + +//Tag returns tag.RiskWarningLevelPercent (1560) +func (f RiskWarningLevelPercentField) Tag() quickfix.Tag { return tag.RiskWarningLevelPercent } + +//NewRiskWarningLevelPercent returns a new RiskWarningLevelPercentField initialized with val +func NewRiskWarningLevelPercent(val float64) RiskWarningLevelPercentField { + return RiskWarningLevelPercentField{quickfix.FIXFloat(val)} +} + +//RndPxField is a PRICE field +type RndPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.RndPx (991) +func (f RndPxField) Tag() quickfix.Tag { return tag.RndPx } + +//NewRndPx returns a new RndPxField initialized with val +func NewRndPx(val float64) RndPxField { + return RndPxField{quickfix.FIXFloat(val)} +} + +//RootPartyIDField is a STRING field +type RootPartyIDField struct{ quickfix.FIXString } + +//Tag returns tag.RootPartyID (1117) +func (f RootPartyIDField) Tag() quickfix.Tag { return tag.RootPartyID } + +//NewRootPartyID returns a new RootPartyIDField initialized with val +func NewRootPartyID(val string) RootPartyIDField { + return RootPartyIDField{quickfix.FIXString(val)} +} + +//RootPartyIDSourceField is a CHAR field +type RootPartyIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.RootPartyIDSource (1118) +func (f RootPartyIDSourceField) Tag() quickfix.Tag { return tag.RootPartyIDSource } + +//NewRootPartyIDSource returns a new RootPartyIDSourceField initialized with val +func NewRootPartyIDSource(val string) RootPartyIDSourceField { + return RootPartyIDSourceField{quickfix.FIXString(val)} +} + +//RootPartyRoleField is a INT field +type RootPartyRoleField struct{ quickfix.FIXInt } + +//Tag returns tag.RootPartyRole (1119) +func (f RootPartyRoleField) Tag() quickfix.Tag { return tag.RootPartyRole } + +//NewRootPartyRole returns a new RootPartyRoleField initialized with val +func NewRootPartyRole(val int) RootPartyRoleField { + return RootPartyRoleField{quickfix.FIXInt(val)} +} + +//RootPartySubIDField is a STRING field +type RootPartySubIDField struct{ quickfix.FIXString } + +//Tag returns tag.RootPartySubID (1121) +func (f RootPartySubIDField) Tag() quickfix.Tag { return tag.RootPartySubID } + +//NewRootPartySubID returns a new RootPartySubIDField initialized with val +func NewRootPartySubID(val string) RootPartySubIDField { + return RootPartySubIDField{quickfix.FIXString(val)} +} + +//RootPartySubIDTypeField is a INT field +type RootPartySubIDTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.RootPartySubIDType (1122) +func (f RootPartySubIDTypeField) Tag() quickfix.Tag { return tag.RootPartySubIDType } + +//NewRootPartySubIDType returns a new RootPartySubIDTypeField initialized with val +func NewRootPartySubIDType(val int) RootPartySubIDTypeField { + return RootPartySubIDTypeField{quickfix.FIXInt(val)} +} + +//RoundLotField is a QTY field +type RoundLotField struct{ quickfix.FIXFloat } + +//Tag returns tag.RoundLot (561) +func (f RoundLotField) Tag() quickfix.Tag { return tag.RoundLot } + +//NewRoundLot returns a new RoundLotField initialized with val +func NewRoundLot(val float64) RoundLotField { + return RoundLotField{quickfix.FIXFloat(val)} +} + +//RoundingDirectionField is a CHAR field +type RoundingDirectionField struct{ quickfix.FIXString } + +//Tag returns tag.RoundingDirection (468) +func (f RoundingDirectionField) Tag() quickfix.Tag { return tag.RoundingDirection } + +//NewRoundingDirection returns a new RoundingDirectionField initialized with val +func NewRoundingDirection(val string) RoundingDirectionField { + return RoundingDirectionField{quickfix.FIXString(val)} +} + +//RoundingModulusField is a FLOAT field +type RoundingModulusField struct{ quickfix.FIXFloat } + +//Tag returns tag.RoundingModulus (469) +func (f RoundingModulusField) Tag() quickfix.Tag { return tag.RoundingModulus } + +//NewRoundingModulus returns a new RoundingModulusField initialized with val +func NewRoundingModulus(val float64) RoundingModulusField { + return RoundingModulusField{quickfix.FIXFloat(val)} +} + +//RoutingIDField is a STRING field +type RoutingIDField struct{ quickfix.FIXString } + +//Tag returns tag.RoutingID (217) +func (f RoutingIDField) Tag() quickfix.Tag { return tag.RoutingID } + +//NewRoutingID returns a new RoutingIDField initialized with val +func NewRoutingID(val string) RoutingIDField { + return RoutingIDField{quickfix.FIXString(val)} +} + +//RoutingTypeField is a INT field +type RoutingTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.RoutingType (216) +func (f RoutingTypeField) Tag() quickfix.Tag { return tag.RoutingType } + +//NewRoutingType returns a new RoutingTypeField initialized with val +func NewRoutingType(val int) RoutingTypeField { + return RoutingTypeField{quickfix.FIXInt(val)} +} + +//RptSeqField is a INT field +type RptSeqField struct{ quickfix.FIXInt } + +//Tag returns tag.RptSeq (83) +func (f RptSeqField) Tag() quickfix.Tag { return tag.RptSeq } + +//NewRptSeq returns a new RptSeqField initialized with val +func NewRptSeq(val int) RptSeqField { + return RptSeqField{quickfix.FIXInt(val)} +} + +//RptSysField is a STRING field +type RptSysField struct{ quickfix.FIXString } + +//Tag returns tag.RptSys (1135) +func (f RptSysField) Tag() quickfix.Tag { return tag.RptSys } + +//NewRptSys returns a new RptSysField initialized with val +func NewRptSys(val string) RptSysField { + return RptSysField{quickfix.FIXString(val)} +} + +//Rule80AField is a CHAR field +type Rule80AField struct{ quickfix.FIXString } + +//Tag returns tag.Rule80A (47) +func (f Rule80AField) Tag() quickfix.Tag { return tag.Rule80A } + +//NewRule80A returns a new Rule80AField initialized with val +func NewRule80A(val string) Rule80AField { + return Rule80AField{quickfix.FIXString(val)} +} + +//ScopeField is a MULTIPLECHARVALUE field +type ScopeField struct{ quickfix.FIXString } + +//Tag returns tag.Scope (546) +func (f ScopeField) Tag() quickfix.Tag { return tag.Scope } + +//NewScope returns a new ScopeField initialized with val +func NewScope(val string) ScopeField { + return ScopeField{quickfix.FIXString(val)} +} + +//SecDefStatusField is a INT field +type SecDefStatusField struct{ quickfix.FIXInt } + +//Tag returns tag.SecDefStatus (653) +func (f SecDefStatusField) Tag() quickfix.Tag { return tag.SecDefStatus } + +//NewSecDefStatus returns a new SecDefStatusField initialized with val +func NewSecDefStatus(val int) SecDefStatusField { + return SecDefStatusField{quickfix.FIXInt(val)} +} + +//SecondaryAllocIDField is a STRING field +type SecondaryAllocIDField struct{ quickfix.FIXString } + +//Tag returns tag.SecondaryAllocID (793) +func (f SecondaryAllocIDField) Tag() quickfix.Tag { return tag.SecondaryAllocID } + +//NewSecondaryAllocID returns a new SecondaryAllocIDField initialized with val +func NewSecondaryAllocID(val string) SecondaryAllocIDField { + return SecondaryAllocIDField{quickfix.FIXString(val)} +} + +//SecondaryClOrdIDField is a STRING field +type SecondaryClOrdIDField struct{ quickfix.FIXString } + +//Tag returns tag.SecondaryClOrdID (526) +func (f SecondaryClOrdIDField) Tag() quickfix.Tag { return tag.SecondaryClOrdID } + +//NewSecondaryClOrdID returns a new SecondaryClOrdIDField initialized with val +func NewSecondaryClOrdID(val string) SecondaryClOrdIDField { + return SecondaryClOrdIDField{quickfix.FIXString(val)} +} + +//SecondaryDisplayQtyField is a QTY field +type SecondaryDisplayQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.SecondaryDisplayQty (1082) +func (f SecondaryDisplayQtyField) Tag() quickfix.Tag { return tag.SecondaryDisplayQty } + +//NewSecondaryDisplayQty returns a new SecondaryDisplayQtyField initialized with val +func NewSecondaryDisplayQty(val float64) SecondaryDisplayQtyField { + return SecondaryDisplayQtyField{quickfix.FIXFloat(val)} +} + +//SecondaryExecIDField is a STRING field +type SecondaryExecIDField struct{ quickfix.FIXString } + +//Tag returns tag.SecondaryExecID (527) +func (f SecondaryExecIDField) Tag() quickfix.Tag { return tag.SecondaryExecID } + +//NewSecondaryExecID returns a new SecondaryExecIDField initialized with val +func NewSecondaryExecID(val string) SecondaryExecIDField { + return SecondaryExecIDField{quickfix.FIXString(val)} +} + +//SecondaryFirmTradeIDField is a STRING field +type SecondaryFirmTradeIDField struct{ quickfix.FIXString } + +//Tag returns tag.SecondaryFirmTradeID (1042) +func (f SecondaryFirmTradeIDField) Tag() quickfix.Tag { return tag.SecondaryFirmTradeID } + +//NewSecondaryFirmTradeID returns a new SecondaryFirmTradeIDField initialized with val +func NewSecondaryFirmTradeID(val string) SecondaryFirmTradeIDField { + return SecondaryFirmTradeIDField{quickfix.FIXString(val)} +} + +//SecondaryHighLimitPriceField is a PRICE field +type SecondaryHighLimitPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.SecondaryHighLimitPrice (1230) +func (f SecondaryHighLimitPriceField) Tag() quickfix.Tag { return tag.SecondaryHighLimitPrice } + +//NewSecondaryHighLimitPrice returns a new SecondaryHighLimitPriceField initialized with val +func NewSecondaryHighLimitPrice(val float64) SecondaryHighLimitPriceField { + return SecondaryHighLimitPriceField{quickfix.FIXFloat(val)} +} + +//SecondaryIndividualAllocIDField is a STRING field +type SecondaryIndividualAllocIDField struct{ quickfix.FIXString } + +//Tag returns tag.SecondaryIndividualAllocID (989) +func (f SecondaryIndividualAllocIDField) Tag() quickfix.Tag { return tag.SecondaryIndividualAllocID } + +//NewSecondaryIndividualAllocID returns a new SecondaryIndividualAllocIDField initialized with val +func NewSecondaryIndividualAllocID(val string) SecondaryIndividualAllocIDField { + return SecondaryIndividualAllocIDField{quickfix.FIXString(val)} +} + +//SecondaryLowLimitPriceField is a PRICE field +type SecondaryLowLimitPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.SecondaryLowLimitPrice (1221) +func (f SecondaryLowLimitPriceField) Tag() quickfix.Tag { return tag.SecondaryLowLimitPrice } + +//NewSecondaryLowLimitPrice returns a new SecondaryLowLimitPriceField initialized with val +func NewSecondaryLowLimitPrice(val float64) SecondaryLowLimitPriceField { + return SecondaryLowLimitPriceField{quickfix.FIXFloat(val)} +} + +//SecondaryOrderIDField is a STRING field +type SecondaryOrderIDField struct{ quickfix.FIXString } + +//Tag returns tag.SecondaryOrderID (198) +func (f SecondaryOrderIDField) Tag() quickfix.Tag { return tag.SecondaryOrderID } + +//NewSecondaryOrderID returns a new SecondaryOrderIDField initialized with val +func NewSecondaryOrderID(val string) SecondaryOrderIDField { + return SecondaryOrderIDField{quickfix.FIXString(val)} +} + +//SecondaryPriceLimitTypeField is a INT field +type SecondaryPriceLimitTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.SecondaryPriceLimitType (1305) +func (f SecondaryPriceLimitTypeField) Tag() quickfix.Tag { return tag.SecondaryPriceLimitType } + +//NewSecondaryPriceLimitType returns a new SecondaryPriceLimitTypeField initialized with val +func NewSecondaryPriceLimitType(val int) SecondaryPriceLimitTypeField { + return SecondaryPriceLimitTypeField{quickfix.FIXInt(val)} +} + +//SecondaryTradeIDField is a STRING field +type SecondaryTradeIDField struct{ quickfix.FIXString } + +//Tag returns tag.SecondaryTradeID (1040) +func (f SecondaryTradeIDField) Tag() quickfix.Tag { return tag.SecondaryTradeID } + +//NewSecondaryTradeID returns a new SecondaryTradeIDField initialized with val +func NewSecondaryTradeID(val string) SecondaryTradeIDField { + return SecondaryTradeIDField{quickfix.FIXString(val)} +} + +//SecondaryTradeReportIDField is a STRING field +type SecondaryTradeReportIDField struct{ quickfix.FIXString } + +//Tag returns tag.SecondaryTradeReportID (818) +func (f SecondaryTradeReportIDField) Tag() quickfix.Tag { return tag.SecondaryTradeReportID } + +//NewSecondaryTradeReportID returns a new SecondaryTradeReportIDField initialized with val +func NewSecondaryTradeReportID(val string) SecondaryTradeReportIDField { + return SecondaryTradeReportIDField{quickfix.FIXString(val)} +} + +//SecondaryTradeReportRefIDField is a STRING field +type SecondaryTradeReportRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.SecondaryTradeReportRefID (881) +func (f SecondaryTradeReportRefIDField) Tag() quickfix.Tag { return tag.SecondaryTradeReportRefID } + +//NewSecondaryTradeReportRefID returns a new SecondaryTradeReportRefIDField initialized with val +func NewSecondaryTradeReportRefID(val string) SecondaryTradeReportRefIDField { + return SecondaryTradeReportRefIDField{quickfix.FIXString(val)} +} + +//SecondaryTradingReferencePriceField is a PRICE field +type SecondaryTradingReferencePriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.SecondaryTradingReferencePrice (1240) +func (f SecondaryTradingReferencePriceField) Tag() quickfix.Tag { + return tag.SecondaryTradingReferencePrice +} + +//NewSecondaryTradingReferencePrice returns a new SecondaryTradingReferencePriceField initialized with val +func NewSecondaryTradingReferencePrice(val float64) SecondaryTradingReferencePriceField { + return SecondaryTradingReferencePriceField{quickfix.FIXFloat(val)} +} + +//SecondaryTrdTypeField is a INT field +type SecondaryTrdTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.SecondaryTrdType (855) +func (f SecondaryTrdTypeField) Tag() quickfix.Tag { return tag.SecondaryTrdType } + +//NewSecondaryTrdType returns a new SecondaryTrdTypeField initialized with val +func NewSecondaryTrdType(val int) SecondaryTrdTypeField { + return SecondaryTrdTypeField{quickfix.FIXInt(val)} +} + +//SecureDataField is a DATA field +type SecureDataField struct{ quickfix.FIXString } + +//Tag returns tag.SecureData (91) +func (f SecureDataField) Tag() quickfix.Tag { return tag.SecureData } + +//NewSecureData returns a new SecureDataField initialized with val +func NewSecureData(val string) SecureDataField { + return SecureDataField{quickfix.FIXString(val)} +} + +//SecureDataLenField is a LENGTH field +type SecureDataLenField struct{ quickfix.FIXInt } + +//Tag returns tag.SecureDataLen (90) +func (f SecureDataLenField) Tag() quickfix.Tag { return tag.SecureDataLen } + +//NewSecureDataLen returns a new SecureDataLenField initialized with val +func NewSecureDataLen(val int) SecureDataLenField { + return SecureDataLenField{quickfix.FIXInt(val)} +} + +//SecurityAltIDField is a STRING field +type SecurityAltIDField struct{ quickfix.FIXString } + +//Tag returns tag.SecurityAltID (455) +func (f SecurityAltIDField) Tag() quickfix.Tag { return tag.SecurityAltID } + +//NewSecurityAltID returns a new SecurityAltIDField initialized with val +func NewSecurityAltID(val string) SecurityAltIDField { + return SecurityAltIDField{quickfix.FIXString(val)} +} + +//SecurityAltIDSourceField is a STRING field +type SecurityAltIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.SecurityAltIDSource (456) +func (f SecurityAltIDSourceField) Tag() quickfix.Tag { return tag.SecurityAltIDSource } + +//NewSecurityAltIDSource returns a new SecurityAltIDSourceField initialized with val +func NewSecurityAltIDSource(val string) SecurityAltIDSourceField { + return SecurityAltIDSourceField{quickfix.FIXString(val)} +} + +//SecurityDescField is a STRING field +type SecurityDescField struct{ quickfix.FIXString } + +//Tag returns tag.SecurityDesc (107) +func (f SecurityDescField) Tag() quickfix.Tag { return tag.SecurityDesc } + +//NewSecurityDesc returns a new SecurityDescField initialized with val +func NewSecurityDesc(val string) SecurityDescField { + return SecurityDescField{quickfix.FIXString(val)} +} + +//SecurityExchangeField is a EXCHANGE field +type SecurityExchangeField struct{ quickfix.FIXString } + +//Tag returns tag.SecurityExchange (207) +func (f SecurityExchangeField) Tag() quickfix.Tag { return tag.SecurityExchange } + +//NewSecurityExchange returns a new SecurityExchangeField initialized with val +func NewSecurityExchange(val string) SecurityExchangeField { + return SecurityExchangeField{quickfix.FIXString(val)} +} + +//SecurityGroupField is a STRING field +type SecurityGroupField struct{ quickfix.FIXString } + +//Tag returns tag.SecurityGroup (1151) +func (f SecurityGroupField) Tag() quickfix.Tag { return tag.SecurityGroup } + +//NewSecurityGroup returns a new SecurityGroupField initialized with val +func NewSecurityGroup(val string) SecurityGroupField { + return SecurityGroupField{quickfix.FIXString(val)} +} + +//SecurityIDField is a STRING field +type SecurityIDField struct{ quickfix.FIXString } + +//Tag returns tag.SecurityID (48) +func (f SecurityIDField) Tag() quickfix.Tag { return tag.SecurityID } + +//NewSecurityID returns a new SecurityIDField initialized with val +func NewSecurityID(val string) SecurityIDField { + return SecurityIDField{quickfix.FIXString(val)} +} + +//SecurityIDSourceField is a STRING field +type SecurityIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.SecurityIDSource (22) +func (f SecurityIDSourceField) Tag() quickfix.Tag { return tag.SecurityIDSource } + +//NewSecurityIDSource returns a new SecurityIDSourceField initialized with val +func NewSecurityIDSource(val string) SecurityIDSourceField { + return SecurityIDSourceField{quickfix.FIXString(val)} +} + +//SecurityListDescField is a STRING field +type SecurityListDescField struct{ quickfix.FIXString } + +//Tag returns tag.SecurityListDesc (1467) +func (f SecurityListDescField) Tag() quickfix.Tag { return tag.SecurityListDesc } + +//NewSecurityListDesc returns a new SecurityListDescField initialized with val +func NewSecurityListDesc(val string) SecurityListDescField { + return SecurityListDescField{quickfix.FIXString(val)} +} + +//SecurityListIDField is a STRING field +type SecurityListIDField struct{ quickfix.FIXString } + +//Tag returns tag.SecurityListID (1465) +func (f SecurityListIDField) Tag() quickfix.Tag { return tag.SecurityListID } + +//NewSecurityListID returns a new SecurityListIDField initialized with val +func NewSecurityListID(val string) SecurityListIDField { + return SecurityListIDField{quickfix.FIXString(val)} +} + +//SecurityListRefIDField is a STRING field +type SecurityListRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.SecurityListRefID (1466) +func (f SecurityListRefIDField) Tag() quickfix.Tag { return tag.SecurityListRefID } + +//NewSecurityListRefID returns a new SecurityListRefIDField initialized with val +func NewSecurityListRefID(val string) SecurityListRefIDField { + return SecurityListRefIDField{quickfix.FIXString(val)} +} + +//SecurityListRequestTypeField is a INT field +type SecurityListRequestTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.SecurityListRequestType (559) +func (f SecurityListRequestTypeField) Tag() quickfix.Tag { return tag.SecurityListRequestType } + +//NewSecurityListRequestType returns a new SecurityListRequestTypeField initialized with val +func NewSecurityListRequestType(val int) SecurityListRequestTypeField { + return SecurityListRequestTypeField{quickfix.FIXInt(val)} +} + +//SecurityListTypeField is a INT field +type SecurityListTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.SecurityListType (1470) +func (f SecurityListTypeField) Tag() quickfix.Tag { return tag.SecurityListType } + +//NewSecurityListType returns a new SecurityListTypeField initialized with val +func NewSecurityListType(val int) SecurityListTypeField { + return SecurityListTypeField{quickfix.FIXInt(val)} +} + +//SecurityListTypeSourceField is a INT field +type SecurityListTypeSourceField struct{ quickfix.FIXInt } + +//Tag returns tag.SecurityListTypeSource (1471) +func (f SecurityListTypeSourceField) Tag() quickfix.Tag { return tag.SecurityListTypeSource } + +//NewSecurityListTypeSource returns a new SecurityListTypeSourceField initialized with val +func NewSecurityListTypeSource(val int) SecurityListTypeSourceField { + return SecurityListTypeSourceField{quickfix.FIXInt(val)} +} + +//SecurityReportIDField is a INT field +type SecurityReportIDField struct{ quickfix.FIXInt } + +//Tag returns tag.SecurityReportID (964) +func (f SecurityReportIDField) Tag() quickfix.Tag { return tag.SecurityReportID } + +//NewSecurityReportID returns a new SecurityReportIDField initialized with val +func NewSecurityReportID(val int) SecurityReportIDField { + return SecurityReportIDField{quickfix.FIXInt(val)} +} + +//SecurityReqIDField is a STRING field +type SecurityReqIDField struct{ quickfix.FIXString } + +//Tag returns tag.SecurityReqID (320) +func (f SecurityReqIDField) Tag() quickfix.Tag { return tag.SecurityReqID } + +//NewSecurityReqID returns a new SecurityReqIDField initialized with val +func NewSecurityReqID(val string) SecurityReqIDField { + return SecurityReqIDField{quickfix.FIXString(val)} +} + +//SecurityRequestResultField is a INT field +type SecurityRequestResultField struct{ quickfix.FIXInt } + +//Tag returns tag.SecurityRequestResult (560) +func (f SecurityRequestResultField) Tag() quickfix.Tag { return tag.SecurityRequestResult } + +//NewSecurityRequestResult returns a new SecurityRequestResultField initialized with val +func NewSecurityRequestResult(val int) SecurityRequestResultField { + return SecurityRequestResultField{quickfix.FIXInt(val)} +} + +//SecurityRequestTypeField is a INT field +type SecurityRequestTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.SecurityRequestType (321) +func (f SecurityRequestTypeField) Tag() quickfix.Tag { return tag.SecurityRequestType } + +//NewSecurityRequestType returns a new SecurityRequestTypeField initialized with val +func NewSecurityRequestType(val int) SecurityRequestTypeField { + return SecurityRequestTypeField{quickfix.FIXInt(val)} +} + +//SecurityResponseIDField is a STRING field +type SecurityResponseIDField struct{ quickfix.FIXString } + +//Tag returns tag.SecurityResponseID (322) +func (f SecurityResponseIDField) Tag() quickfix.Tag { return tag.SecurityResponseID } + +//NewSecurityResponseID returns a new SecurityResponseIDField initialized with val +func NewSecurityResponseID(val string) SecurityResponseIDField { + return SecurityResponseIDField{quickfix.FIXString(val)} +} + +//SecurityResponseTypeField is a INT field +type SecurityResponseTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.SecurityResponseType (323) +func (f SecurityResponseTypeField) Tag() quickfix.Tag { return tag.SecurityResponseType } + +//NewSecurityResponseType returns a new SecurityResponseTypeField initialized with val +func NewSecurityResponseType(val int) SecurityResponseTypeField { + return SecurityResponseTypeField{quickfix.FIXInt(val)} +} + +//SecuritySettlAgentAcctNameField is a STRING field +type SecuritySettlAgentAcctNameField struct{ quickfix.FIXString } + +//Tag returns tag.SecuritySettlAgentAcctName (179) +func (f SecuritySettlAgentAcctNameField) Tag() quickfix.Tag { return tag.SecuritySettlAgentAcctName } + +//NewSecuritySettlAgentAcctName returns a new SecuritySettlAgentAcctNameField initialized with val +func NewSecuritySettlAgentAcctName(val string) SecuritySettlAgentAcctNameField { + return SecuritySettlAgentAcctNameField{quickfix.FIXString(val)} +} + +//SecuritySettlAgentAcctNumField is a STRING field +type SecuritySettlAgentAcctNumField struct{ quickfix.FIXString } + +//Tag returns tag.SecuritySettlAgentAcctNum (178) +func (f SecuritySettlAgentAcctNumField) Tag() quickfix.Tag { return tag.SecuritySettlAgentAcctNum } + +//NewSecuritySettlAgentAcctNum returns a new SecuritySettlAgentAcctNumField initialized with val +func NewSecuritySettlAgentAcctNum(val string) SecuritySettlAgentAcctNumField { + return SecuritySettlAgentAcctNumField{quickfix.FIXString(val)} +} + +//SecuritySettlAgentCodeField is a STRING field +type SecuritySettlAgentCodeField struct{ quickfix.FIXString } + +//Tag returns tag.SecuritySettlAgentCode (177) +func (f SecuritySettlAgentCodeField) Tag() quickfix.Tag { return tag.SecuritySettlAgentCode } + +//NewSecuritySettlAgentCode returns a new SecuritySettlAgentCodeField initialized with val +func NewSecuritySettlAgentCode(val string) SecuritySettlAgentCodeField { + return SecuritySettlAgentCodeField{quickfix.FIXString(val)} +} + +//SecuritySettlAgentContactNameField is a STRING field +type SecuritySettlAgentContactNameField struct{ quickfix.FIXString } + +//Tag returns tag.SecuritySettlAgentContactName (180) +func (f SecuritySettlAgentContactNameField) Tag() quickfix.Tag { + return tag.SecuritySettlAgentContactName +} + +//NewSecuritySettlAgentContactName returns a new SecuritySettlAgentContactNameField initialized with val +func NewSecuritySettlAgentContactName(val string) SecuritySettlAgentContactNameField { + return SecuritySettlAgentContactNameField{quickfix.FIXString(val)} +} + +//SecuritySettlAgentContactPhoneField is a STRING field +type SecuritySettlAgentContactPhoneField struct{ quickfix.FIXString } + +//Tag returns tag.SecuritySettlAgentContactPhone (181) +func (f SecuritySettlAgentContactPhoneField) Tag() quickfix.Tag { + return tag.SecuritySettlAgentContactPhone +} + +//NewSecuritySettlAgentContactPhone returns a new SecuritySettlAgentContactPhoneField initialized with val +func NewSecuritySettlAgentContactPhone(val string) SecuritySettlAgentContactPhoneField { + return SecuritySettlAgentContactPhoneField{quickfix.FIXString(val)} +} + +//SecuritySettlAgentNameField is a STRING field +type SecuritySettlAgentNameField struct{ quickfix.FIXString } + +//Tag returns tag.SecuritySettlAgentName (176) +func (f SecuritySettlAgentNameField) Tag() quickfix.Tag { return tag.SecuritySettlAgentName } + +//NewSecuritySettlAgentName returns a new SecuritySettlAgentNameField initialized with val +func NewSecuritySettlAgentName(val string) SecuritySettlAgentNameField { + return SecuritySettlAgentNameField{quickfix.FIXString(val)} +} + +//SecurityStatusField is a STRING field +type SecurityStatusField struct{ quickfix.FIXString } + +//Tag returns tag.SecurityStatus (965) +func (f SecurityStatusField) Tag() quickfix.Tag { return tag.SecurityStatus } + +//NewSecurityStatus returns a new SecurityStatusField initialized with val +func NewSecurityStatus(val string) SecurityStatusField { + return SecurityStatusField{quickfix.FIXString(val)} +} + +//SecurityStatusReqIDField is a STRING field +type SecurityStatusReqIDField struct{ quickfix.FIXString } + +//Tag returns tag.SecurityStatusReqID (324) +func (f SecurityStatusReqIDField) Tag() quickfix.Tag { return tag.SecurityStatusReqID } + +//NewSecurityStatusReqID returns a new SecurityStatusReqIDField initialized with val +func NewSecurityStatusReqID(val string) SecurityStatusReqIDField { + return SecurityStatusReqIDField{quickfix.FIXString(val)} +} + +//SecuritySubTypeField is a STRING field +type SecuritySubTypeField struct{ quickfix.FIXString } + +//Tag returns tag.SecuritySubType (762) +func (f SecuritySubTypeField) Tag() quickfix.Tag { return tag.SecuritySubType } + +//NewSecuritySubType returns a new SecuritySubTypeField initialized with val +func NewSecuritySubType(val string) SecuritySubTypeField { + return SecuritySubTypeField{quickfix.FIXString(val)} +} + +//SecurityTradingEventField is a INT field +type SecurityTradingEventField struct{ quickfix.FIXInt } + +//Tag returns tag.SecurityTradingEvent (1174) +func (f SecurityTradingEventField) Tag() quickfix.Tag { return tag.SecurityTradingEvent } + +//NewSecurityTradingEvent returns a new SecurityTradingEventField initialized with val +func NewSecurityTradingEvent(val int) SecurityTradingEventField { + return SecurityTradingEventField{quickfix.FIXInt(val)} +} + +//SecurityTradingStatusField is a INT field +type SecurityTradingStatusField struct{ quickfix.FIXInt } + +//Tag returns tag.SecurityTradingStatus (326) +func (f SecurityTradingStatusField) Tag() quickfix.Tag { return tag.SecurityTradingStatus } + +//NewSecurityTradingStatus returns a new SecurityTradingStatusField initialized with val +func NewSecurityTradingStatus(val int) SecurityTradingStatusField { + return SecurityTradingStatusField{quickfix.FIXInt(val)} +} + +//SecurityTypeField is a STRING field +type SecurityTypeField struct{ quickfix.FIXString } + +//Tag returns tag.SecurityType (167) +func (f SecurityTypeField) Tag() quickfix.Tag { return tag.SecurityType } + +//NewSecurityType returns a new SecurityTypeField initialized with val +func NewSecurityType(val string) SecurityTypeField { + return SecurityTypeField{quickfix.FIXString(val)} +} + +//SecurityUpdateActionField is a CHAR field +type SecurityUpdateActionField struct{ quickfix.FIXString } + +//Tag returns tag.SecurityUpdateAction (980) +func (f SecurityUpdateActionField) Tag() quickfix.Tag { return tag.SecurityUpdateAction } + +//NewSecurityUpdateAction returns a new SecurityUpdateActionField initialized with val +func NewSecurityUpdateAction(val string) SecurityUpdateActionField { + return SecurityUpdateActionField{quickfix.FIXString(val)} +} + +//SecurityXMLField is a XMLDATA field +type SecurityXMLField struct{ quickfix.FIXString } + +//Tag returns tag.SecurityXML (1185) +func (f SecurityXMLField) Tag() quickfix.Tag { return tag.SecurityXML } + +//NewSecurityXML returns a new SecurityXMLField initialized with val +func NewSecurityXML(val string) SecurityXMLField { + return SecurityXMLField{quickfix.FIXString(val)} +} + +//SecurityXMLLenField is a LENGTH field +type SecurityXMLLenField struct{ quickfix.FIXInt } + +//Tag returns tag.SecurityXMLLen (1184) +func (f SecurityXMLLenField) Tag() quickfix.Tag { return tag.SecurityXMLLen } + +//NewSecurityXMLLen returns a new SecurityXMLLenField initialized with val +func NewSecurityXMLLen(val int) SecurityXMLLenField { + return SecurityXMLLenField{quickfix.FIXInt(val)} +} + +//SecurityXMLSchemaField is a STRING field +type SecurityXMLSchemaField struct{ quickfix.FIXString } + +//Tag returns tag.SecurityXMLSchema (1186) +func (f SecurityXMLSchemaField) Tag() quickfix.Tag { return tag.SecurityXMLSchema } + +//NewSecurityXMLSchema returns a new SecurityXMLSchemaField initialized with val +func NewSecurityXMLSchema(val string) SecurityXMLSchemaField { + return SecurityXMLSchemaField{quickfix.FIXString(val)} +} + +//SellVolumeField is a QTY field +type SellVolumeField struct{ quickfix.FIXFloat } + +//Tag returns tag.SellVolume (331) +func (f SellVolumeField) Tag() quickfix.Tag { return tag.SellVolume } + +//NewSellVolume returns a new SellVolumeField initialized with val +func NewSellVolume(val float64) SellVolumeField { + return SellVolumeField{quickfix.FIXFloat(val)} +} + +//SellerDaysField is a INT field +type SellerDaysField struct{ quickfix.FIXInt } + +//Tag returns tag.SellerDays (287) +func (f SellerDaysField) Tag() quickfix.Tag { return tag.SellerDays } + +//NewSellerDays returns a new SellerDaysField initialized with val +func NewSellerDays(val int) SellerDaysField { + return SellerDaysField{quickfix.FIXInt(val)} +} + +//SenderCompIDField is a STRING field +type SenderCompIDField struct{ quickfix.FIXString } + +//Tag returns tag.SenderCompID (49) +func (f SenderCompIDField) Tag() quickfix.Tag { return tag.SenderCompID } + +//NewSenderCompID returns a new SenderCompIDField initialized with val +func NewSenderCompID(val string) SenderCompIDField { + return SenderCompIDField{quickfix.FIXString(val)} +} + +//SenderLocationIDField is a STRING field +type SenderLocationIDField struct{ quickfix.FIXString } + +//Tag returns tag.SenderLocationID (142) +func (f SenderLocationIDField) Tag() quickfix.Tag { return tag.SenderLocationID } + +//NewSenderLocationID returns a new SenderLocationIDField initialized with val +func NewSenderLocationID(val string) SenderLocationIDField { + return SenderLocationIDField{quickfix.FIXString(val)} +} + +//SenderSubIDField is a STRING field +type SenderSubIDField struct{ quickfix.FIXString } + +//Tag returns tag.SenderSubID (50) +func (f SenderSubIDField) Tag() quickfix.Tag { return tag.SenderSubID } + +//NewSenderSubID returns a new SenderSubIDField initialized with val +func NewSenderSubID(val string) SenderSubIDField { + return SenderSubIDField{quickfix.FIXString(val)} +} + +//SendingDateField is a LOCALMKTDATE field +type SendingDateField struct{ quickfix.FIXString } + +//Tag returns tag.SendingDate (51) +func (f SendingDateField) Tag() quickfix.Tag { return tag.SendingDate } + +//NewSendingDate returns a new SendingDateField initialized with val +func NewSendingDate(val string) SendingDateField { + return SendingDateField{quickfix.FIXString(val)} +} + +//SendingTimeField is a UTCTIMESTAMP field +type SendingTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.SendingTime (52) +func (f SendingTimeField) Tag() quickfix.Tag { return tag.SendingTime } + +//NewSendingTime returns a new SendingTimeField initialized with val +func NewSendingTime(val time.Time) SendingTimeField { + return SendingTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewSendingTimeNoMillis returns a new SendingTimeField initialized with val without millisecs +func NewSendingTimeNoMillis(val time.Time) SendingTimeField { + return SendingTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//SeniorityField is a STRING field +type SeniorityField struct{ quickfix.FIXString } + +//Tag returns tag.Seniority (1450) +func (f SeniorityField) Tag() quickfix.Tag { return tag.Seniority } + +//NewSeniority returns a new SeniorityField initialized with val +func NewSeniority(val string) SeniorityField { + return SeniorityField{quickfix.FIXString(val)} +} + +//SessionRejectReasonField is a INT field +type SessionRejectReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.SessionRejectReason (373) +func (f SessionRejectReasonField) Tag() quickfix.Tag { return tag.SessionRejectReason } + +//NewSessionRejectReason returns a new SessionRejectReasonField initialized with val +func NewSessionRejectReason(val int) SessionRejectReasonField { + return SessionRejectReasonField{quickfix.FIXInt(val)} +} + +//SessionStatusField is a INT field +type SessionStatusField struct{ quickfix.FIXInt } + +//Tag returns tag.SessionStatus (1409) +func (f SessionStatusField) Tag() quickfix.Tag { return tag.SessionStatus } + +//NewSessionStatus returns a new SessionStatusField initialized with val +func NewSessionStatus(val int) SessionStatusField { + return SessionStatusField{quickfix.FIXInt(val)} +} + +//SettlBrkrCodeField is a STRING field +type SettlBrkrCodeField struct{ quickfix.FIXString } + +//Tag returns tag.SettlBrkrCode (174) +func (f SettlBrkrCodeField) Tag() quickfix.Tag { return tag.SettlBrkrCode } + +//NewSettlBrkrCode returns a new SettlBrkrCodeField initialized with val +func NewSettlBrkrCode(val string) SettlBrkrCodeField { + return SettlBrkrCodeField{quickfix.FIXString(val)} +} + +//SettlCurrAmtField is a AMT field +type SettlCurrAmtField struct{ quickfix.FIXFloat } + +//Tag returns tag.SettlCurrAmt (119) +func (f SettlCurrAmtField) Tag() quickfix.Tag { return tag.SettlCurrAmt } + +//NewSettlCurrAmt returns a new SettlCurrAmtField initialized with val +func NewSettlCurrAmt(val float64) SettlCurrAmtField { + return SettlCurrAmtField{quickfix.FIXFloat(val)} +} + +//SettlCurrBidFxRateField is a FLOAT field +type SettlCurrBidFxRateField struct{ quickfix.FIXFloat } + +//Tag returns tag.SettlCurrBidFxRate (656) +func (f SettlCurrBidFxRateField) Tag() quickfix.Tag { return tag.SettlCurrBidFxRate } + +//NewSettlCurrBidFxRate returns a new SettlCurrBidFxRateField initialized with val +func NewSettlCurrBidFxRate(val float64) SettlCurrBidFxRateField { + return SettlCurrBidFxRateField{quickfix.FIXFloat(val)} +} + +//SettlCurrFxRateField is a FLOAT field +type SettlCurrFxRateField struct{ quickfix.FIXFloat } + +//Tag returns tag.SettlCurrFxRate (155) +func (f SettlCurrFxRateField) Tag() quickfix.Tag { return tag.SettlCurrFxRate } + +//NewSettlCurrFxRate returns a new SettlCurrFxRateField initialized with val +func NewSettlCurrFxRate(val float64) SettlCurrFxRateField { + return SettlCurrFxRateField{quickfix.FIXFloat(val)} +} + +//SettlCurrFxRateCalcField is a CHAR field +type SettlCurrFxRateCalcField struct{ quickfix.FIXString } + +//Tag returns tag.SettlCurrFxRateCalc (156) +func (f SettlCurrFxRateCalcField) Tag() quickfix.Tag { return tag.SettlCurrFxRateCalc } + +//NewSettlCurrFxRateCalc returns a new SettlCurrFxRateCalcField initialized with val +func NewSettlCurrFxRateCalc(val string) SettlCurrFxRateCalcField { + return SettlCurrFxRateCalcField{quickfix.FIXString(val)} +} + +//SettlCurrOfferFxRateField is a FLOAT field +type SettlCurrOfferFxRateField struct{ quickfix.FIXFloat } + +//Tag returns tag.SettlCurrOfferFxRate (657) +func (f SettlCurrOfferFxRateField) Tag() quickfix.Tag { return tag.SettlCurrOfferFxRate } + +//NewSettlCurrOfferFxRate returns a new SettlCurrOfferFxRateField initialized with val +func NewSettlCurrOfferFxRate(val float64) SettlCurrOfferFxRateField { + return SettlCurrOfferFxRateField{quickfix.FIXFloat(val)} +} + +//SettlCurrencyField is a CURRENCY field +type SettlCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.SettlCurrency (120) +func (f SettlCurrencyField) Tag() quickfix.Tag { return tag.SettlCurrency } + +//NewSettlCurrency returns a new SettlCurrencyField initialized with val +func NewSettlCurrency(val string) SettlCurrencyField { + return SettlCurrencyField{quickfix.FIXString(val)} +} + +//SettlDateField is a LOCALMKTDATE field +type SettlDateField struct{ quickfix.FIXString } + +//Tag returns tag.SettlDate (64) +func (f SettlDateField) Tag() quickfix.Tag { return tag.SettlDate } + +//NewSettlDate returns a new SettlDateField initialized with val +func NewSettlDate(val string) SettlDateField { + return SettlDateField{quickfix.FIXString(val)} +} + +//SettlDate2Field is a LOCALMKTDATE field +type SettlDate2Field struct{ quickfix.FIXString } + +//Tag returns tag.SettlDate2 (193) +func (f SettlDate2Field) Tag() quickfix.Tag { return tag.SettlDate2 } + +//NewSettlDate2 returns a new SettlDate2Field initialized with val +func NewSettlDate2(val string) SettlDate2Field { + return SettlDate2Field{quickfix.FIXString(val)} +} + +//SettlDeliveryTypeField is a INT field +type SettlDeliveryTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.SettlDeliveryType (172) +func (f SettlDeliveryTypeField) Tag() quickfix.Tag { return tag.SettlDeliveryType } + +//NewSettlDeliveryType returns a new SettlDeliveryTypeField initialized with val +func NewSettlDeliveryType(val int) SettlDeliveryTypeField { + return SettlDeliveryTypeField{quickfix.FIXInt(val)} +} + +//SettlDepositoryCodeField is a STRING field +type SettlDepositoryCodeField struct{ quickfix.FIXString } + +//Tag returns tag.SettlDepositoryCode (173) +func (f SettlDepositoryCodeField) Tag() quickfix.Tag { return tag.SettlDepositoryCode } + +//NewSettlDepositoryCode returns a new SettlDepositoryCodeField initialized with val +func NewSettlDepositoryCode(val string) SettlDepositoryCodeField { + return SettlDepositoryCodeField{quickfix.FIXString(val)} +} + +//SettlInstCodeField is a STRING field +type SettlInstCodeField struct{ quickfix.FIXString } + +//Tag returns tag.SettlInstCode (175) +func (f SettlInstCodeField) Tag() quickfix.Tag { return tag.SettlInstCode } + +//NewSettlInstCode returns a new SettlInstCodeField initialized with val +func NewSettlInstCode(val string) SettlInstCodeField { + return SettlInstCodeField{quickfix.FIXString(val)} +} + +//SettlInstIDField is a STRING field +type SettlInstIDField struct{ quickfix.FIXString } + +//Tag returns tag.SettlInstID (162) +func (f SettlInstIDField) Tag() quickfix.Tag { return tag.SettlInstID } + +//NewSettlInstID returns a new SettlInstIDField initialized with val +func NewSettlInstID(val string) SettlInstIDField { + return SettlInstIDField{quickfix.FIXString(val)} +} + +//SettlInstModeField is a CHAR field +type SettlInstModeField struct{ quickfix.FIXString } + +//Tag returns tag.SettlInstMode (160) +func (f SettlInstModeField) Tag() quickfix.Tag { return tag.SettlInstMode } + +//NewSettlInstMode returns a new SettlInstModeField initialized with val +func NewSettlInstMode(val string) SettlInstModeField { + return SettlInstModeField{quickfix.FIXString(val)} +} + +//SettlInstMsgIDField is a STRING field +type SettlInstMsgIDField struct{ quickfix.FIXString } + +//Tag returns tag.SettlInstMsgID (777) +func (f SettlInstMsgIDField) Tag() quickfix.Tag { return tag.SettlInstMsgID } + +//NewSettlInstMsgID returns a new SettlInstMsgIDField initialized with val +func NewSettlInstMsgID(val string) SettlInstMsgIDField { + return SettlInstMsgIDField{quickfix.FIXString(val)} +} + +//SettlInstRefIDField is a STRING field +type SettlInstRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.SettlInstRefID (214) +func (f SettlInstRefIDField) Tag() quickfix.Tag { return tag.SettlInstRefID } + +//NewSettlInstRefID returns a new SettlInstRefIDField initialized with val +func NewSettlInstRefID(val string) SettlInstRefIDField { + return SettlInstRefIDField{quickfix.FIXString(val)} +} + +//SettlInstReqIDField is a STRING field +type SettlInstReqIDField struct{ quickfix.FIXString } + +//Tag returns tag.SettlInstReqID (791) +func (f SettlInstReqIDField) Tag() quickfix.Tag { return tag.SettlInstReqID } + +//NewSettlInstReqID returns a new SettlInstReqIDField initialized with val +func NewSettlInstReqID(val string) SettlInstReqIDField { + return SettlInstReqIDField{quickfix.FIXString(val)} +} + +//SettlInstReqRejCodeField is a INT field +type SettlInstReqRejCodeField struct{ quickfix.FIXInt } + +//Tag returns tag.SettlInstReqRejCode (792) +func (f SettlInstReqRejCodeField) Tag() quickfix.Tag { return tag.SettlInstReqRejCode } + +//NewSettlInstReqRejCode returns a new SettlInstReqRejCodeField initialized with val +func NewSettlInstReqRejCode(val int) SettlInstReqRejCodeField { + return SettlInstReqRejCodeField{quickfix.FIXInt(val)} +} + +//SettlInstSourceField is a CHAR field +type SettlInstSourceField struct{ quickfix.FIXString } + +//Tag returns tag.SettlInstSource (165) +func (f SettlInstSourceField) Tag() quickfix.Tag { return tag.SettlInstSource } + +//NewSettlInstSource returns a new SettlInstSourceField initialized with val +func NewSettlInstSource(val string) SettlInstSourceField { + return SettlInstSourceField{quickfix.FIXString(val)} +} + +//SettlInstTransTypeField is a CHAR field +type SettlInstTransTypeField struct{ quickfix.FIXString } + +//Tag returns tag.SettlInstTransType (163) +func (f SettlInstTransTypeField) Tag() quickfix.Tag { return tag.SettlInstTransType } + +//NewSettlInstTransType returns a new SettlInstTransTypeField initialized with val +func NewSettlInstTransType(val string) SettlInstTransTypeField { + return SettlInstTransTypeField{quickfix.FIXString(val)} +} + +//SettlLocationField is a STRING field +type SettlLocationField struct{ quickfix.FIXString } + +//Tag returns tag.SettlLocation (166) +func (f SettlLocationField) Tag() quickfix.Tag { return tag.SettlLocation } + +//NewSettlLocation returns a new SettlLocationField initialized with val +func NewSettlLocation(val string) SettlLocationField { + return SettlLocationField{quickfix.FIXString(val)} +} + +//SettlMethodField is a CHAR field +type SettlMethodField struct{ quickfix.FIXString } + +//Tag returns tag.SettlMethod (1193) +func (f SettlMethodField) Tag() quickfix.Tag { return tag.SettlMethod } + +//NewSettlMethod returns a new SettlMethodField initialized with val +func NewSettlMethod(val string) SettlMethodField { + return SettlMethodField{quickfix.FIXString(val)} +} + +//SettlObligIDField is a STRING field +type SettlObligIDField struct{ quickfix.FIXString } + +//Tag returns tag.SettlObligID (1161) +func (f SettlObligIDField) Tag() quickfix.Tag { return tag.SettlObligID } + +//NewSettlObligID returns a new SettlObligIDField initialized with val +func NewSettlObligID(val string) SettlObligIDField { + return SettlObligIDField{quickfix.FIXString(val)} +} + +//SettlObligModeField is a INT field +type SettlObligModeField struct{ quickfix.FIXInt } + +//Tag returns tag.SettlObligMode (1159) +func (f SettlObligModeField) Tag() quickfix.Tag { return tag.SettlObligMode } + +//NewSettlObligMode returns a new SettlObligModeField initialized with val +func NewSettlObligMode(val int) SettlObligModeField { + return SettlObligModeField{quickfix.FIXInt(val)} +} + +//SettlObligMsgIDField is a STRING field +type SettlObligMsgIDField struct{ quickfix.FIXString } + +//Tag returns tag.SettlObligMsgID (1160) +func (f SettlObligMsgIDField) Tag() quickfix.Tag { return tag.SettlObligMsgID } + +//NewSettlObligMsgID returns a new SettlObligMsgIDField initialized with val +func NewSettlObligMsgID(val string) SettlObligMsgIDField { + return SettlObligMsgIDField{quickfix.FIXString(val)} +} + +//SettlObligRefIDField is a STRING field +type SettlObligRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.SettlObligRefID (1163) +func (f SettlObligRefIDField) Tag() quickfix.Tag { return tag.SettlObligRefID } + +//NewSettlObligRefID returns a new SettlObligRefIDField initialized with val +func NewSettlObligRefID(val string) SettlObligRefIDField { + return SettlObligRefIDField{quickfix.FIXString(val)} +} + +//SettlObligSourceField is a CHAR field +type SettlObligSourceField struct{ quickfix.FIXString } + +//Tag returns tag.SettlObligSource (1164) +func (f SettlObligSourceField) Tag() quickfix.Tag { return tag.SettlObligSource } + +//NewSettlObligSource returns a new SettlObligSourceField initialized with val +func NewSettlObligSource(val string) SettlObligSourceField { + return SettlObligSourceField{quickfix.FIXString(val)} +} + +//SettlObligTransTypeField is a CHAR field +type SettlObligTransTypeField struct{ quickfix.FIXString } + +//Tag returns tag.SettlObligTransType (1162) +func (f SettlObligTransTypeField) Tag() quickfix.Tag { return tag.SettlObligTransType } + +//NewSettlObligTransType returns a new SettlObligTransTypeField initialized with val +func NewSettlObligTransType(val string) SettlObligTransTypeField { + return SettlObligTransTypeField{quickfix.FIXString(val)} +} + +//SettlPartyIDField is a STRING field +type SettlPartyIDField struct{ quickfix.FIXString } + +//Tag returns tag.SettlPartyID (782) +func (f SettlPartyIDField) Tag() quickfix.Tag { return tag.SettlPartyID } + +//NewSettlPartyID returns a new SettlPartyIDField initialized with val +func NewSettlPartyID(val string) SettlPartyIDField { + return SettlPartyIDField{quickfix.FIXString(val)} +} + +//SettlPartyIDSourceField is a CHAR field +type SettlPartyIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.SettlPartyIDSource (783) +func (f SettlPartyIDSourceField) Tag() quickfix.Tag { return tag.SettlPartyIDSource } + +//NewSettlPartyIDSource returns a new SettlPartyIDSourceField initialized with val +func NewSettlPartyIDSource(val string) SettlPartyIDSourceField { + return SettlPartyIDSourceField{quickfix.FIXString(val)} +} + +//SettlPartyRoleField is a INT field +type SettlPartyRoleField struct{ quickfix.FIXInt } + +//Tag returns tag.SettlPartyRole (784) +func (f SettlPartyRoleField) Tag() quickfix.Tag { return tag.SettlPartyRole } + +//NewSettlPartyRole returns a new SettlPartyRoleField initialized with val +func NewSettlPartyRole(val int) SettlPartyRoleField { + return SettlPartyRoleField{quickfix.FIXInt(val)} +} + +//SettlPartySubIDField is a STRING field +type SettlPartySubIDField struct{ quickfix.FIXString } + +//Tag returns tag.SettlPartySubID (785) +func (f SettlPartySubIDField) Tag() quickfix.Tag { return tag.SettlPartySubID } + +//NewSettlPartySubID returns a new SettlPartySubIDField initialized with val +func NewSettlPartySubID(val string) SettlPartySubIDField { + return SettlPartySubIDField{quickfix.FIXString(val)} +} + +//SettlPartySubIDTypeField is a INT field +type SettlPartySubIDTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.SettlPartySubIDType (786) +func (f SettlPartySubIDTypeField) Tag() quickfix.Tag { return tag.SettlPartySubIDType } + +//NewSettlPartySubIDType returns a new SettlPartySubIDTypeField initialized with val +func NewSettlPartySubIDType(val int) SettlPartySubIDTypeField { + return SettlPartySubIDTypeField{quickfix.FIXInt(val)} +} + +//SettlPriceField is a PRICE field +type SettlPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.SettlPrice (730) +func (f SettlPriceField) Tag() quickfix.Tag { return tag.SettlPrice } + +//NewSettlPrice returns a new SettlPriceField initialized with val +func NewSettlPrice(val float64) SettlPriceField { + return SettlPriceField{quickfix.FIXFloat(val)} +} + +//SettlPriceTypeField is a INT field +type SettlPriceTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.SettlPriceType (731) +func (f SettlPriceTypeField) Tag() quickfix.Tag { return tag.SettlPriceType } + +//NewSettlPriceType returns a new SettlPriceTypeField initialized with val +func NewSettlPriceType(val int) SettlPriceTypeField { + return SettlPriceTypeField{quickfix.FIXInt(val)} +} + +//SettlSessIDField is a STRING field +type SettlSessIDField struct{ quickfix.FIXString } + +//Tag returns tag.SettlSessID (716) +func (f SettlSessIDField) Tag() quickfix.Tag { return tag.SettlSessID } + +//NewSettlSessID returns a new SettlSessIDField initialized with val +func NewSettlSessID(val string) SettlSessIDField { + return SettlSessIDField{quickfix.FIXString(val)} +} + +//SettlSessSubIDField is a STRING field +type SettlSessSubIDField struct{ quickfix.FIXString } + +//Tag returns tag.SettlSessSubID (717) +func (f SettlSessSubIDField) Tag() quickfix.Tag { return tag.SettlSessSubID } + +//NewSettlSessSubID returns a new SettlSessSubIDField initialized with val +func NewSettlSessSubID(val string) SettlSessSubIDField { + return SettlSessSubIDField{quickfix.FIXString(val)} +} + +//SettlTypeField is a STRING field +type SettlTypeField struct{ quickfix.FIXString } + +//Tag returns tag.SettlType (63) +func (f SettlTypeField) Tag() quickfix.Tag { return tag.SettlType } + +//NewSettlType returns a new SettlTypeField initialized with val +func NewSettlType(val string) SettlTypeField { + return SettlTypeField{quickfix.FIXString(val)} +} + +//SettleOnOpenFlagField is a STRING field +type SettleOnOpenFlagField struct{ quickfix.FIXString } + +//Tag returns tag.SettleOnOpenFlag (966) +func (f SettleOnOpenFlagField) Tag() quickfix.Tag { return tag.SettleOnOpenFlag } + +//NewSettleOnOpenFlag returns a new SettleOnOpenFlagField initialized with val +func NewSettleOnOpenFlag(val string) SettleOnOpenFlagField { + return SettleOnOpenFlagField{quickfix.FIXString(val)} +} + +//SettlementCycleNoField is a INT field +type SettlementCycleNoField struct{ quickfix.FIXInt } + +//Tag returns tag.SettlementCycleNo (1153) +func (f SettlementCycleNoField) Tag() quickfix.Tag { return tag.SettlementCycleNo } + +//NewSettlementCycleNo returns a new SettlementCycleNoField initialized with val +func NewSettlementCycleNo(val int) SettlementCycleNoField { + return SettlementCycleNoField{quickfix.FIXInt(val)} +} + +//SettlmntTypField is a CHAR field +type SettlmntTypField struct{ quickfix.FIXString } + +//Tag returns tag.SettlmntTyp (63) +func (f SettlmntTypField) Tag() quickfix.Tag { return tag.SettlmntTyp } + +//NewSettlmntTyp returns a new SettlmntTypField initialized with val +func NewSettlmntTyp(val string) SettlmntTypField { + return SettlmntTypField{quickfix.FIXString(val)} +} + +//SharedCommissionField is a AMT field +type SharedCommissionField struct{ quickfix.FIXFloat } + +//Tag returns tag.SharedCommission (858) +func (f SharedCommissionField) Tag() quickfix.Tag { return tag.SharedCommission } + +//NewSharedCommission returns a new SharedCommissionField initialized with val +func NewSharedCommission(val float64) SharedCommissionField { + return SharedCommissionField{quickfix.FIXFloat(val)} +} + +//SharesField is a QTY field +type SharesField struct{ quickfix.FIXFloat } + +//Tag returns tag.Shares (53) +func (f SharesField) Tag() quickfix.Tag { return tag.Shares } + +//NewShares returns a new SharesField initialized with val +func NewShares(val float64) SharesField { + return SharesField{quickfix.FIXFloat(val)} +} + +//ShortQtyField is a QTY field +type ShortQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.ShortQty (705) +func (f ShortQtyField) Tag() quickfix.Tag { return tag.ShortQty } + +//NewShortQty returns a new ShortQtyField initialized with val +func NewShortQty(val float64) ShortQtyField { + return ShortQtyField{quickfix.FIXFloat(val)} +} + +//ShortSaleReasonField is a INT field +type ShortSaleReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.ShortSaleReason (853) +func (f ShortSaleReasonField) Tag() quickfix.Tag { return tag.ShortSaleReason } + +//NewShortSaleReason returns a new ShortSaleReasonField initialized with val +func NewShortSaleReason(val int) ShortSaleReasonField { + return ShortSaleReasonField{quickfix.FIXInt(val)} +} + +//SideField is a CHAR field +type SideField struct{ quickfix.FIXString } + +//Tag returns tag.Side (54) +func (f SideField) Tag() quickfix.Tag { return tag.Side } + +//NewSide returns a new SideField initialized with val +func NewSide(val string) SideField { + return SideField{quickfix.FIXString(val)} +} + +//SideComplianceIDField is a STRING field +type SideComplianceIDField struct{ quickfix.FIXString } + +//Tag returns tag.SideComplianceID (659) +func (f SideComplianceIDField) Tag() quickfix.Tag { return tag.SideComplianceID } + +//NewSideComplianceID returns a new SideComplianceIDField initialized with val +func NewSideComplianceID(val string) SideComplianceIDField { + return SideComplianceIDField{quickfix.FIXString(val)} +} + +//SideCurrencyField is a CURRENCY field +type SideCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.SideCurrency (1154) +func (f SideCurrencyField) Tag() quickfix.Tag { return tag.SideCurrency } + +//NewSideCurrency returns a new SideCurrencyField initialized with val +func NewSideCurrency(val string) SideCurrencyField { + return SideCurrencyField{quickfix.FIXString(val)} +} + +//SideExecIDField is a STRING field +type SideExecIDField struct{ quickfix.FIXString } + +//Tag returns tag.SideExecID (1427) +func (f SideExecIDField) Tag() quickfix.Tag { return tag.SideExecID } + +//NewSideExecID returns a new SideExecIDField initialized with val +func NewSideExecID(val string) SideExecIDField { + return SideExecIDField{quickfix.FIXString(val)} +} + +//SideFillStationCdField is a STRING field +type SideFillStationCdField struct{ quickfix.FIXString } + +//Tag returns tag.SideFillStationCd (1006) +func (f SideFillStationCdField) Tag() quickfix.Tag { return tag.SideFillStationCd } + +//NewSideFillStationCd returns a new SideFillStationCdField initialized with val +func NewSideFillStationCd(val string) SideFillStationCdField { + return SideFillStationCdField{quickfix.FIXString(val)} +} + +//SideGrossTradeAmtField is a AMT field +type SideGrossTradeAmtField struct{ quickfix.FIXFloat } + +//Tag returns tag.SideGrossTradeAmt (1072) +func (f SideGrossTradeAmtField) Tag() quickfix.Tag { return tag.SideGrossTradeAmt } + +//NewSideGrossTradeAmt returns a new SideGrossTradeAmtField initialized with val +func NewSideGrossTradeAmt(val float64) SideGrossTradeAmtField { + return SideGrossTradeAmtField{quickfix.FIXFloat(val)} +} + +//SideLastQtyField is a INT field +type SideLastQtyField struct{ quickfix.FIXInt } + +//Tag returns tag.SideLastQty (1009) +func (f SideLastQtyField) Tag() quickfix.Tag { return tag.SideLastQty } + +//NewSideLastQty returns a new SideLastQtyField initialized with val +func NewSideLastQty(val int) SideLastQtyField { + return SideLastQtyField{quickfix.FIXInt(val)} +} + +//SideLiquidityIndField is a INT field +type SideLiquidityIndField struct{ quickfix.FIXInt } + +//Tag returns tag.SideLiquidityInd (1444) +func (f SideLiquidityIndField) Tag() quickfix.Tag { return tag.SideLiquidityInd } + +//NewSideLiquidityInd returns a new SideLiquidityIndField initialized with val +func NewSideLiquidityInd(val int) SideLiquidityIndField { + return SideLiquidityIndField{quickfix.FIXInt(val)} +} + +//SideMultiLegReportingTypeField is a INT field +type SideMultiLegReportingTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.SideMultiLegReportingType (752) +func (f SideMultiLegReportingTypeField) Tag() quickfix.Tag { return tag.SideMultiLegReportingType } + +//NewSideMultiLegReportingType returns a new SideMultiLegReportingTypeField initialized with val +func NewSideMultiLegReportingType(val int) SideMultiLegReportingTypeField { + return SideMultiLegReportingTypeField{quickfix.FIXInt(val)} +} + +//SideQtyField is a INT field +type SideQtyField struct{ quickfix.FIXInt } + +//Tag returns tag.SideQty (1009) +func (f SideQtyField) Tag() quickfix.Tag { return tag.SideQty } + +//NewSideQty returns a new SideQtyField initialized with val +func NewSideQty(val int) SideQtyField { + return SideQtyField{quickfix.FIXInt(val)} +} + +//SideReasonCdField is a STRING field +type SideReasonCdField struct{ quickfix.FIXString } + +//Tag returns tag.SideReasonCd (1007) +func (f SideReasonCdField) Tag() quickfix.Tag { return tag.SideReasonCd } + +//NewSideReasonCd returns a new SideReasonCdField initialized with val +func NewSideReasonCd(val string) SideReasonCdField { + return SideReasonCdField{quickfix.FIXString(val)} +} + +//SideSettlCurrencyField is a CURRENCY field +type SideSettlCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.SideSettlCurrency (1155) +func (f SideSettlCurrencyField) Tag() quickfix.Tag { return tag.SideSettlCurrency } + +//NewSideSettlCurrency returns a new SideSettlCurrencyField initialized with val +func NewSideSettlCurrency(val string) SideSettlCurrencyField { + return SideSettlCurrencyField{quickfix.FIXString(val)} +} + +//SideTimeInForceField is a UTCTIMESTAMP field +type SideTimeInForceField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.SideTimeInForce (962) +func (f SideTimeInForceField) Tag() quickfix.Tag { return tag.SideTimeInForce } + +//NewSideTimeInForce returns a new SideTimeInForceField initialized with val +func NewSideTimeInForce(val time.Time) SideTimeInForceField { + return SideTimeInForceField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewSideTimeInForceNoMillis returns a new SideTimeInForceField initialized with val without millisecs +func NewSideTimeInForceNoMillis(val time.Time) SideTimeInForceField { + return SideTimeInForceField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//SideTradeReportIDField is a STRING field +type SideTradeReportIDField struct{ quickfix.FIXString } + +//Tag returns tag.SideTradeReportID (1005) +func (f SideTradeReportIDField) Tag() quickfix.Tag { return tag.SideTradeReportID } + +//NewSideTradeReportID returns a new SideTradeReportIDField initialized with val +func NewSideTradeReportID(val string) SideTradeReportIDField { + return SideTradeReportIDField{quickfix.FIXString(val)} +} + +//SideTrdRegTimestampField is a UTCTIMESTAMP field +type SideTrdRegTimestampField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.SideTrdRegTimestamp (1012) +func (f SideTrdRegTimestampField) Tag() quickfix.Tag { return tag.SideTrdRegTimestamp } + +//NewSideTrdRegTimestamp returns a new SideTrdRegTimestampField initialized with val +func NewSideTrdRegTimestamp(val time.Time) SideTrdRegTimestampField { + return SideTrdRegTimestampField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewSideTrdRegTimestampNoMillis returns a new SideTrdRegTimestampField initialized with val without millisecs +func NewSideTrdRegTimestampNoMillis(val time.Time) SideTrdRegTimestampField { + return SideTrdRegTimestampField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//SideTrdRegTimestampSrcField is a STRING field +type SideTrdRegTimestampSrcField struct{ quickfix.FIXString } + +//Tag returns tag.SideTrdRegTimestampSrc (1014) +func (f SideTrdRegTimestampSrcField) Tag() quickfix.Tag { return tag.SideTrdRegTimestampSrc } + +//NewSideTrdRegTimestampSrc returns a new SideTrdRegTimestampSrcField initialized with val +func NewSideTrdRegTimestampSrc(val string) SideTrdRegTimestampSrcField { + return SideTrdRegTimestampSrcField{quickfix.FIXString(val)} +} + +//SideTrdRegTimestampTypeField is a INT field +type SideTrdRegTimestampTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.SideTrdRegTimestampType (1013) +func (f SideTrdRegTimestampTypeField) Tag() quickfix.Tag { return tag.SideTrdRegTimestampType } + +//NewSideTrdRegTimestampType returns a new SideTrdRegTimestampTypeField initialized with val +func NewSideTrdRegTimestampType(val int) SideTrdRegTimestampTypeField { + return SideTrdRegTimestampTypeField{quickfix.FIXInt(val)} +} + +//SideTrdSubTypField is a INT field +type SideTrdSubTypField struct{ quickfix.FIXInt } + +//Tag returns tag.SideTrdSubTyp (1008) +func (f SideTrdSubTypField) Tag() quickfix.Tag { return tag.SideTrdSubTyp } + +//NewSideTrdSubTyp returns a new SideTrdSubTypField initialized with val +func NewSideTrdSubTyp(val int) SideTrdSubTypField { + return SideTrdSubTypField{quickfix.FIXInt(val)} +} + +//SideValue1Field is a AMT field +type SideValue1Field struct{ quickfix.FIXFloat } + +//Tag returns tag.SideValue1 (396) +func (f SideValue1Field) Tag() quickfix.Tag { return tag.SideValue1 } + +//NewSideValue1 returns a new SideValue1Field initialized with val +func NewSideValue1(val float64) SideValue1Field { + return SideValue1Field{quickfix.FIXFloat(val)} +} + +//SideValue2Field is a AMT field +type SideValue2Field struct{ quickfix.FIXFloat } + +//Tag returns tag.SideValue2 (397) +func (f SideValue2Field) Tag() quickfix.Tag { return tag.SideValue2 } + +//NewSideValue2 returns a new SideValue2Field initialized with val +func NewSideValue2(val float64) SideValue2Field { + return SideValue2Field{quickfix.FIXFloat(val)} +} + +//SideValueIndField is a INT field +type SideValueIndField struct{ quickfix.FIXInt } + +//Tag returns tag.SideValueInd (401) +func (f SideValueIndField) Tag() quickfix.Tag { return tag.SideValueInd } + +//NewSideValueInd returns a new SideValueIndField initialized with val +func NewSideValueInd(val int) SideValueIndField { + return SideValueIndField{quickfix.FIXInt(val)} +} + +//SignatureField is a DATA field +type SignatureField struct{ quickfix.FIXString } + +//Tag returns tag.Signature (89) +func (f SignatureField) Tag() quickfix.Tag { return tag.Signature } + +//NewSignature returns a new SignatureField initialized with val +func NewSignature(val string) SignatureField { + return SignatureField{quickfix.FIXString(val)} +} + +//SignatureLengthField is a LENGTH field +type SignatureLengthField struct{ quickfix.FIXInt } + +//Tag returns tag.SignatureLength (93) +func (f SignatureLengthField) Tag() quickfix.Tag { return tag.SignatureLength } + +//NewSignatureLength returns a new SignatureLengthField initialized with val +func NewSignatureLength(val int) SignatureLengthField { + return SignatureLengthField{quickfix.FIXInt(val)} +} + +//SolicitedFlagField is a BOOLEAN field +type SolicitedFlagField struct{ quickfix.FIXBoolean } + +//Tag returns tag.SolicitedFlag (377) +func (f SolicitedFlagField) Tag() quickfix.Tag { return tag.SolicitedFlag } + +//NewSolicitedFlag returns a new SolicitedFlagField initialized with val +func NewSolicitedFlag(val bool) SolicitedFlagField { + return SolicitedFlagField{quickfix.FIXBoolean(val)} +} + +//SpreadField is a PRICEOFFSET field +type SpreadField struct{ quickfix.FIXFloat } + +//Tag returns tag.Spread (218) +func (f SpreadField) Tag() quickfix.Tag { return tag.Spread } + +//NewSpread returns a new SpreadField initialized with val +func NewSpread(val float64) SpreadField { + return SpreadField{quickfix.FIXFloat(val)} +} + +//SpreadToBenchmarkField is a PRICEOFFSET field +type SpreadToBenchmarkField struct{ quickfix.FIXFloat } + +//Tag returns tag.SpreadToBenchmark (218) +func (f SpreadToBenchmarkField) Tag() quickfix.Tag { return tag.SpreadToBenchmark } + +//NewSpreadToBenchmark returns a new SpreadToBenchmarkField initialized with val +func NewSpreadToBenchmark(val float64) SpreadToBenchmarkField { + return SpreadToBenchmarkField{quickfix.FIXFloat(val)} +} + +//StandInstDbIDField is a STRING field +type StandInstDbIDField struct{ quickfix.FIXString } + +//Tag returns tag.StandInstDbID (171) +func (f StandInstDbIDField) Tag() quickfix.Tag { return tag.StandInstDbID } + +//NewStandInstDbID returns a new StandInstDbIDField initialized with val +func NewStandInstDbID(val string) StandInstDbIDField { + return StandInstDbIDField{quickfix.FIXString(val)} +} + +//StandInstDbNameField is a STRING field +type StandInstDbNameField struct{ quickfix.FIXString } + +//Tag returns tag.StandInstDbName (170) +func (f StandInstDbNameField) Tag() quickfix.Tag { return tag.StandInstDbName } + +//NewStandInstDbName returns a new StandInstDbNameField initialized with val +func NewStandInstDbName(val string) StandInstDbNameField { + return StandInstDbNameField{quickfix.FIXString(val)} +} + +//StandInstDbTypeField is a INT field +type StandInstDbTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.StandInstDbType (169) +func (f StandInstDbTypeField) Tag() quickfix.Tag { return tag.StandInstDbType } + +//NewStandInstDbType returns a new StandInstDbTypeField initialized with val +func NewStandInstDbType(val int) StandInstDbTypeField { + return StandInstDbTypeField{quickfix.FIXInt(val)} +} + +//StartCashField is a AMT field +type StartCashField struct{ quickfix.FIXFloat } + +//Tag returns tag.StartCash (921) +func (f StartCashField) Tag() quickfix.Tag { return tag.StartCash } + +//NewStartCash returns a new StartCashField initialized with val +func NewStartCash(val float64) StartCashField { + return StartCashField{quickfix.FIXFloat(val)} +} + +//StartDateField is a LOCALMKTDATE field +type StartDateField struct{ quickfix.FIXString } + +//Tag returns tag.StartDate (916) +func (f StartDateField) Tag() quickfix.Tag { return tag.StartDate } + +//NewStartDate returns a new StartDateField initialized with val +func NewStartDate(val string) StartDateField { + return StartDateField{quickfix.FIXString(val)} +} + +//StartMaturityMonthYearField is a MONTHYEAR field +type StartMaturityMonthYearField struct{ quickfix.FIXString } + +//Tag returns tag.StartMaturityMonthYear (1241) +func (f StartMaturityMonthYearField) Tag() quickfix.Tag { return tag.StartMaturityMonthYear } + +//NewStartMaturityMonthYear returns a new StartMaturityMonthYearField initialized with val +func NewStartMaturityMonthYear(val string) StartMaturityMonthYearField { + return StartMaturityMonthYearField{quickfix.FIXString(val)} +} + +//StartStrikePxRangeField is a PRICE field +type StartStrikePxRangeField struct{ quickfix.FIXFloat } + +//Tag returns tag.StartStrikePxRange (1202) +func (f StartStrikePxRangeField) Tag() quickfix.Tag { return tag.StartStrikePxRange } + +//NewStartStrikePxRange returns a new StartStrikePxRangeField initialized with val +func NewStartStrikePxRange(val float64) StartStrikePxRangeField { + return StartStrikePxRangeField{quickfix.FIXFloat(val)} +} + +//StartTickPriceRangeField is a PRICE field +type StartTickPriceRangeField struct{ quickfix.FIXFloat } + +//Tag returns tag.StartTickPriceRange (1206) +func (f StartTickPriceRangeField) Tag() quickfix.Tag { return tag.StartTickPriceRange } + +//NewStartTickPriceRange returns a new StartTickPriceRangeField initialized with val +func NewStartTickPriceRange(val float64) StartTickPriceRangeField { + return StartTickPriceRangeField{quickfix.FIXFloat(val)} +} + +//StateOrProvinceOfIssueField is a STRING field +type StateOrProvinceOfIssueField struct{ quickfix.FIXString } + +//Tag returns tag.StateOrProvinceOfIssue (471) +func (f StateOrProvinceOfIssueField) Tag() quickfix.Tag { return tag.StateOrProvinceOfIssue } + +//NewStateOrProvinceOfIssue returns a new StateOrProvinceOfIssueField initialized with val +func NewStateOrProvinceOfIssue(val string) StateOrProvinceOfIssueField { + return StateOrProvinceOfIssueField{quickfix.FIXString(val)} +} + +//StatsTypeField is a INT field +type StatsTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.StatsType (1176) +func (f StatsTypeField) Tag() quickfix.Tag { return tag.StatsType } + +//NewStatsType returns a new StatsTypeField initialized with val +func NewStatsType(val int) StatsTypeField { + return StatsTypeField{quickfix.FIXInt(val)} +} + +//StatusTextField is a STRING field +type StatusTextField struct{ quickfix.FIXString } + +//Tag returns tag.StatusText (929) +func (f StatusTextField) Tag() quickfix.Tag { return tag.StatusText } + +//NewStatusText returns a new StatusTextField initialized with val +func NewStatusText(val string) StatusTextField { + return StatusTextField{quickfix.FIXString(val)} +} + +//StatusValueField is a INT field +type StatusValueField struct{ quickfix.FIXInt } + +//Tag returns tag.StatusValue (928) +func (f StatusValueField) Tag() quickfix.Tag { return tag.StatusValue } + +//NewStatusValue returns a new StatusValueField initialized with val +func NewStatusValue(val int) StatusValueField { + return StatusValueField{quickfix.FIXInt(val)} +} + +//StipulationTypeField is a STRING field +type StipulationTypeField struct{ quickfix.FIXString } + +//Tag returns tag.StipulationType (233) +func (f StipulationTypeField) Tag() quickfix.Tag { return tag.StipulationType } + +//NewStipulationType returns a new StipulationTypeField initialized with val +func NewStipulationType(val string) StipulationTypeField { + return StipulationTypeField{quickfix.FIXString(val)} +} + +//StipulationValueField is a STRING field +type StipulationValueField struct{ quickfix.FIXString } + +//Tag returns tag.StipulationValue (234) +func (f StipulationValueField) Tag() quickfix.Tag { return tag.StipulationValue } + +//NewStipulationValue returns a new StipulationValueField initialized with val +func NewStipulationValue(val string) StipulationValueField { + return StipulationValueField{quickfix.FIXString(val)} +} + +//StopPxField is a PRICE field +type StopPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.StopPx (99) +func (f StopPxField) Tag() quickfix.Tag { return tag.StopPx } + +//NewStopPx returns a new StopPxField initialized with val +func NewStopPx(val float64) StopPxField { + return StopPxField{quickfix.FIXFloat(val)} +} + +//StrategyParameterNameField is a STRING field +type StrategyParameterNameField struct{ quickfix.FIXString } + +//Tag returns tag.StrategyParameterName (958) +func (f StrategyParameterNameField) Tag() quickfix.Tag { return tag.StrategyParameterName } + +//NewStrategyParameterName returns a new StrategyParameterNameField initialized with val +func NewStrategyParameterName(val string) StrategyParameterNameField { + return StrategyParameterNameField{quickfix.FIXString(val)} +} + +//StrategyParameterTypeField is a INT field +type StrategyParameterTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.StrategyParameterType (959) +func (f StrategyParameterTypeField) Tag() quickfix.Tag { return tag.StrategyParameterType } + +//NewStrategyParameterType returns a new StrategyParameterTypeField initialized with val +func NewStrategyParameterType(val int) StrategyParameterTypeField { + return StrategyParameterTypeField{quickfix.FIXInt(val)} +} + +//StrategyParameterValueField is a STRING field +type StrategyParameterValueField struct{ quickfix.FIXString } + +//Tag returns tag.StrategyParameterValue (960) +func (f StrategyParameterValueField) Tag() quickfix.Tag { return tag.StrategyParameterValue } + +//NewStrategyParameterValue returns a new StrategyParameterValueField initialized with val +func NewStrategyParameterValue(val string) StrategyParameterValueField { + return StrategyParameterValueField{quickfix.FIXString(val)} +} + +//StreamAsgnAckTypeField is a INT field +type StreamAsgnAckTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.StreamAsgnAckType (1503) +func (f StreamAsgnAckTypeField) Tag() quickfix.Tag { return tag.StreamAsgnAckType } + +//NewStreamAsgnAckType returns a new StreamAsgnAckTypeField initialized with val +func NewStreamAsgnAckType(val int) StreamAsgnAckTypeField { + return StreamAsgnAckTypeField{quickfix.FIXInt(val)} +} + +//StreamAsgnRejReasonField is a INT field +type StreamAsgnRejReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.StreamAsgnRejReason (1502) +func (f StreamAsgnRejReasonField) Tag() quickfix.Tag { return tag.StreamAsgnRejReason } + +//NewStreamAsgnRejReason returns a new StreamAsgnRejReasonField initialized with val +func NewStreamAsgnRejReason(val int) StreamAsgnRejReasonField { + return StreamAsgnRejReasonField{quickfix.FIXInt(val)} +} + +//StreamAsgnReqIDField is a STRING field +type StreamAsgnReqIDField struct{ quickfix.FIXString } + +//Tag returns tag.StreamAsgnReqID (1497) +func (f StreamAsgnReqIDField) Tag() quickfix.Tag { return tag.StreamAsgnReqID } + +//NewStreamAsgnReqID returns a new StreamAsgnReqIDField initialized with val +func NewStreamAsgnReqID(val string) StreamAsgnReqIDField { + return StreamAsgnReqIDField{quickfix.FIXString(val)} +} + +//StreamAsgnReqTypeField is a INT field +type StreamAsgnReqTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.StreamAsgnReqType (1498) +func (f StreamAsgnReqTypeField) Tag() quickfix.Tag { return tag.StreamAsgnReqType } + +//NewStreamAsgnReqType returns a new StreamAsgnReqTypeField initialized with val +func NewStreamAsgnReqType(val int) StreamAsgnReqTypeField { + return StreamAsgnReqTypeField{quickfix.FIXInt(val)} +} + +//StreamAsgnRptIDField is a STRING field +type StreamAsgnRptIDField struct{ quickfix.FIXString } + +//Tag returns tag.StreamAsgnRptID (1501) +func (f StreamAsgnRptIDField) Tag() quickfix.Tag { return tag.StreamAsgnRptID } + +//NewStreamAsgnRptID returns a new StreamAsgnRptIDField initialized with val +func NewStreamAsgnRptID(val string) StreamAsgnRptIDField { + return StreamAsgnRptIDField{quickfix.FIXString(val)} +} + +//StreamAsgnTypeField is a INT field +type StreamAsgnTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.StreamAsgnType (1617) +func (f StreamAsgnTypeField) Tag() quickfix.Tag { return tag.StreamAsgnType } + +//NewStreamAsgnType returns a new StreamAsgnTypeField initialized with val +func NewStreamAsgnType(val int) StreamAsgnTypeField { + return StreamAsgnTypeField{quickfix.FIXInt(val)} +} + +//StrikeCurrencyField is a CURRENCY field +type StrikeCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.StrikeCurrency (947) +func (f StrikeCurrencyField) Tag() quickfix.Tag { return tag.StrikeCurrency } + +//NewStrikeCurrency returns a new StrikeCurrencyField initialized with val +func NewStrikeCurrency(val string) StrikeCurrencyField { + return StrikeCurrencyField{quickfix.FIXString(val)} +} + +//StrikeExerciseStyleField is a INT field +type StrikeExerciseStyleField struct{ quickfix.FIXInt } + +//Tag returns tag.StrikeExerciseStyle (1304) +func (f StrikeExerciseStyleField) Tag() quickfix.Tag { return tag.StrikeExerciseStyle } + +//NewStrikeExerciseStyle returns a new StrikeExerciseStyleField initialized with val +func NewStrikeExerciseStyle(val int) StrikeExerciseStyleField { + return StrikeExerciseStyleField{quickfix.FIXInt(val)} +} + +//StrikeIncrementField is a FLOAT field +type StrikeIncrementField struct{ quickfix.FIXFloat } + +//Tag returns tag.StrikeIncrement (1204) +func (f StrikeIncrementField) Tag() quickfix.Tag { return tag.StrikeIncrement } + +//NewStrikeIncrement returns a new StrikeIncrementField initialized with val +func NewStrikeIncrement(val float64) StrikeIncrementField { + return StrikeIncrementField{quickfix.FIXFloat(val)} +} + +//StrikeMultiplierField is a FLOAT field +type StrikeMultiplierField struct{ quickfix.FIXFloat } + +//Tag returns tag.StrikeMultiplier (967) +func (f StrikeMultiplierField) Tag() quickfix.Tag { return tag.StrikeMultiplier } + +//NewStrikeMultiplier returns a new StrikeMultiplierField initialized with val +func NewStrikeMultiplier(val float64) StrikeMultiplierField { + return StrikeMultiplierField{quickfix.FIXFloat(val)} +} + +//StrikePriceField is a PRICE field +type StrikePriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.StrikePrice (202) +func (f StrikePriceField) Tag() quickfix.Tag { return tag.StrikePrice } + +//NewStrikePrice returns a new StrikePriceField initialized with val +func NewStrikePrice(val float64) StrikePriceField { + return StrikePriceField{quickfix.FIXFloat(val)} +} + +//StrikePriceBoundaryMethodField is a INT field +type StrikePriceBoundaryMethodField struct{ quickfix.FIXInt } + +//Tag returns tag.StrikePriceBoundaryMethod (1479) +func (f StrikePriceBoundaryMethodField) Tag() quickfix.Tag { return tag.StrikePriceBoundaryMethod } + +//NewStrikePriceBoundaryMethod returns a new StrikePriceBoundaryMethodField initialized with val +func NewStrikePriceBoundaryMethod(val int) StrikePriceBoundaryMethodField { + return StrikePriceBoundaryMethodField{quickfix.FIXInt(val)} +} + +//StrikePriceBoundaryPrecisionField is a PERCENTAGE field +type StrikePriceBoundaryPrecisionField struct{ quickfix.FIXFloat } + +//Tag returns tag.StrikePriceBoundaryPrecision (1480) +func (f StrikePriceBoundaryPrecisionField) Tag() quickfix.Tag { return tag.StrikePriceBoundaryPrecision } + +//NewStrikePriceBoundaryPrecision returns a new StrikePriceBoundaryPrecisionField initialized with val +func NewStrikePriceBoundaryPrecision(val float64) StrikePriceBoundaryPrecisionField { + return StrikePriceBoundaryPrecisionField{quickfix.FIXFloat(val)} +} + +//StrikePriceDeterminationMethodField is a INT field +type StrikePriceDeterminationMethodField struct{ quickfix.FIXInt } + +//Tag returns tag.StrikePriceDeterminationMethod (1478) +func (f StrikePriceDeterminationMethodField) Tag() quickfix.Tag { + return tag.StrikePriceDeterminationMethod +} + +//NewStrikePriceDeterminationMethod returns a new StrikePriceDeterminationMethodField initialized with val +func NewStrikePriceDeterminationMethod(val int) StrikePriceDeterminationMethodField { + return StrikePriceDeterminationMethodField{quickfix.FIXInt(val)} +} + +//StrikeRuleIDField is a STRING field +type StrikeRuleIDField struct{ quickfix.FIXString } + +//Tag returns tag.StrikeRuleID (1223) +func (f StrikeRuleIDField) Tag() quickfix.Tag { return tag.StrikeRuleID } + +//NewStrikeRuleID returns a new StrikeRuleIDField initialized with val +func NewStrikeRuleID(val string) StrikeRuleIDField { + return StrikeRuleIDField{quickfix.FIXString(val)} +} + +//StrikeTimeField is a UTCTIMESTAMP field +type StrikeTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.StrikeTime (443) +func (f StrikeTimeField) Tag() quickfix.Tag { return tag.StrikeTime } + +//NewStrikeTime returns a new StrikeTimeField initialized with val +func NewStrikeTime(val time.Time) StrikeTimeField { + return StrikeTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewStrikeTimeNoMillis returns a new StrikeTimeField initialized with val without millisecs +func NewStrikeTimeNoMillis(val time.Time) StrikeTimeField { + return StrikeTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//StrikeValueField is a FLOAT field +type StrikeValueField struct{ quickfix.FIXFloat } + +//Tag returns tag.StrikeValue (968) +func (f StrikeValueField) Tag() quickfix.Tag { return tag.StrikeValue } + +//NewStrikeValue returns a new StrikeValueField initialized with val +func NewStrikeValue(val float64) StrikeValueField { + return StrikeValueField{quickfix.FIXFloat(val)} +} + +//SubjectField is a STRING field +type SubjectField struct{ quickfix.FIXString } + +//Tag returns tag.Subject (147) +func (f SubjectField) Tag() quickfix.Tag { return tag.Subject } + +//NewSubject returns a new SubjectField initialized with val +func NewSubject(val string) SubjectField { + return SubjectField{quickfix.FIXString(val)} +} + +//SubscriptionRequestTypeField is a CHAR field +type SubscriptionRequestTypeField struct{ quickfix.FIXString } + +//Tag returns tag.SubscriptionRequestType (263) +func (f SubscriptionRequestTypeField) Tag() quickfix.Tag { return tag.SubscriptionRequestType } + +//NewSubscriptionRequestType returns a new SubscriptionRequestTypeField initialized with val +func NewSubscriptionRequestType(val string) SubscriptionRequestTypeField { + return SubscriptionRequestTypeField{quickfix.FIXString(val)} +} + +//SwapPointsField is a PRICEOFFSET field +type SwapPointsField struct{ quickfix.FIXFloat } + +//Tag returns tag.SwapPoints (1069) +func (f SwapPointsField) Tag() quickfix.Tag { return tag.SwapPoints } + +//NewSwapPoints returns a new SwapPointsField initialized with val +func NewSwapPoints(val float64) SwapPointsField { + return SwapPointsField{quickfix.FIXFloat(val)} +} + +//SymbolField is a STRING field +type SymbolField struct{ quickfix.FIXString } + +//Tag returns tag.Symbol (55) +func (f SymbolField) Tag() quickfix.Tag { return tag.Symbol } + +//NewSymbol returns a new SymbolField initialized with val +func NewSymbol(val string) SymbolField { + return SymbolField{quickfix.FIXString(val)} +} + +//SymbolSfxField is a STRING field +type SymbolSfxField struct{ quickfix.FIXString } + +//Tag returns tag.SymbolSfx (65) +func (f SymbolSfxField) Tag() quickfix.Tag { return tag.SymbolSfx } + +//NewSymbolSfx returns a new SymbolSfxField initialized with val +func NewSymbolSfx(val string) SymbolSfxField { + return SymbolSfxField{quickfix.FIXString(val)} +} + +//TZTransactTimeField is a TZTIMESTAMP field +type TZTransactTimeField struct{ quickfix.FIXString } + +//Tag returns tag.TZTransactTime (1132) +func (f TZTransactTimeField) Tag() quickfix.Tag { return tag.TZTransactTime } + +//NewTZTransactTime returns a new TZTransactTimeField initialized with val +func NewTZTransactTime(val string) TZTransactTimeField { + return TZTransactTimeField{quickfix.FIXString(val)} +} + +//TargetCompIDField is a STRING field +type TargetCompIDField struct{ quickfix.FIXString } + +//Tag returns tag.TargetCompID (56) +func (f TargetCompIDField) Tag() quickfix.Tag { return tag.TargetCompID } + +//NewTargetCompID returns a new TargetCompIDField initialized with val +func NewTargetCompID(val string) TargetCompIDField { + return TargetCompIDField{quickfix.FIXString(val)} +} + +//TargetLocationIDField is a STRING field +type TargetLocationIDField struct{ quickfix.FIXString } + +//Tag returns tag.TargetLocationID (143) +func (f TargetLocationIDField) Tag() quickfix.Tag { return tag.TargetLocationID } + +//NewTargetLocationID returns a new TargetLocationIDField initialized with val +func NewTargetLocationID(val string) TargetLocationIDField { + return TargetLocationIDField{quickfix.FIXString(val)} +} + +//TargetPartyIDField is a STRING field +type TargetPartyIDField struct{ quickfix.FIXString } + +//Tag returns tag.TargetPartyID (1462) +func (f TargetPartyIDField) Tag() quickfix.Tag { return tag.TargetPartyID } + +//NewTargetPartyID returns a new TargetPartyIDField initialized with val +func NewTargetPartyID(val string) TargetPartyIDField { + return TargetPartyIDField{quickfix.FIXString(val)} +} + +//TargetPartyIDSourceField is a CHAR field +type TargetPartyIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.TargetPartyIDSource (1463) +func (f TargetPartyIDSourceField) Tag() quickfix.Tag { return tag.TargetPartyIDSource } + +//NewTargetPartyIDSource returns a new TargetPartyIDSourceField initialized with val +func NewTargetPartyIDSource(val string) TargetPartyIDSourceField { + return TargetPartyIDSourceField{quickfix.FIXString(val)} +} + +//TargetPartyRoleField is a INT field +type TargetPartyRoleField struct{ quickfix.FIXInt } + +//Tag returns tag.TargetPartyRole (1464) +func (f TargetPartyRoleField) Tag() quickfix.Tag { return tag.TargetPartyRole } + +//NewTargetPartyRole returns a new TargetPartyRoleField initialized with val +func NewTargetPartyRole(val int) TargetPartyRoleField { + return TargetPartyRoleField{quickfix.FIXInt(val)} +} + +//TargetStrategyField is a INT field +type TargetStrategyField struct{ quickfix.FIXInt } + +//Tag returns tag.TargetStrategy (847) +func (f TargetStrategyField) Tag() quickfix.Tag { return tag.TargetStrategy } + +//NewTargetStrategy returns a new TargetStrategyField initialized with val +func NewTargetStrategy(val int) TargetStrategyField { + return TargetStrategyField{quickfix.FIXInt(val)} +} + +//TargetStrategyParametersField is a STRING field +type TargetStrategyParametersField struct{ quickfix.FIXString } + +//Tag returns tag.TargetStrategyParameters (848) +func (f TargetStrategyParametersField) Tag() quickfix.Tag { return tag.TargetStrategyParameters } + +//NewTargetStrategyParameters returns a new TargetStrategyParametersField initialized with val +func NewTargetStrategyParameters(val string) TargetStrategyParametersField { + return TargetStrategyParametersField{quickfix.FIXString(val)} +} + +//TargetStrategyPerformanceField is a FLOAT field +type TargetStrategyPerformanceField struct{ quickfix.FIXFloat } + +//Tag returns tag.TargetStrategyPerformance (850) +func (f TargetStrategyPerformanceField) Tag() quickfix.Tag { return tag.TargetStrategyPerformance } + +//NewTargetStrategyPerformance returns a new TargetStrategyPerformanceField initialized with val +func NewTargetStrategyPerformance(val float64) TargetStrategyPerformanceField { + return TargetStrategyPerformanceField{quickfix.FIXFloat(val)} +} + +//TargetSubIDField is a STRING field +type TargetSubIDField struct{ quickfix.FIXString } + +//Tag returns tag.TargetSubID (57) +func (f TargetSubIDField) Tag() quickfix.Tag { return tag.TargetSubID } + +//NewTargetSubID returns a new TargetSubIDField initialized with val +func NewTargetSubID(val string) TargetSubIDField { + return TargetSubIDField{quickfix.FIXString(val)} +} + +//TaxAdvantageTypeField is a INT field +type TaxAdvantageTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.TaxAdvantageType (495) +func (f TaxAdvantageTypeField) Tag() quickfix.Tag { return tag.TaxAdvantageType } + +//NewTaxAdvantageType returns a new TaxAdvantageTypeField initialized with val +func NewTaxAdvantageType(val int) TaxAdvantageTypeField { + return TaxAdvantageTypeField{quickfix.FIXInt(val)} +} + +//TerminationTypeField is a INT field +type TerminationTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.TerminationType (788) +func (f TerminationTypeField) Tag() quickfix.Tag { return tag.TerminationType } + +//NewTerminationType returns a new TerminationTypeField initialized with val +func NewTerminationType(val int) TerminationTypeField { + return TerminationTypeField{quickfix.FIXInt(val)} +} + +//TestMessageIndicatorField is a BOOLEAN field +type TestMessageIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.TestMessageIndicator (464) +func (f TestMessageIndicatorField) Tag() quickfix.Tag { return tag.TestMessageIndicator } + +//NewTestMessageIndicator returns a new TestMessageIndicatorField initialized with val +func NewTestMessageIndicator(val bool) TestMessageIndicatorField { + return TestMessageIndicatorField{quickfix.FIXBoolean(val)} +} + +//TestReqIDField is a STRING field +type TestReqIDField struct{ quickfix.FIXString } + +//Tag returns tag.TestReqID (112) +func (f TestReqIDField) Tag() quickfix.Tag { return tag.TestReqID } + +//NewTestReqID returns a new TestReqIDField initialized with val +func NewTestReqID(val string) TestReqIDField { + return TestReqIDField{quickfix.FIXString(val)} +} + +//TextField is a STRING field +type TextField struct{ quickfix.FIXString } + +//Tag returns tag.Text (58) +func (f TextField) Tag() quickfix.Tag { return tag.Text } + +//NewText returns a new TextField initialized with val +func NewText(val string) TextField { + return TextField{quickfix.FIXString(val)} +} + +//ThresholdAmountField is a PRICEOFFSET field +type ThresholdAmountField struct{ quickfix.FIXFloat } + +//Tag returns tag.ThresholdAmount (834) +func (f ThresholdAmountField) Tag() quickfix.Tag { return tag.ThresholdAmount } + +//NewThresholdAmount returns a new ThresholdAmountField initialized with val +func NewThresholdAmount(val float64) ThresholdAmountField { + return ThresholdAmountField{quickfix.FIXFloat(val)} +} + +//TickDirectionField is a CHAR field +type TickDirectionField struct{ quickfix.FIXString } + +//Tag returns tag.TickDirection (274) +func (f TickDirectionField) Tag() quickfix.Tag { return tag.TickDirection } + +//NewTickDirection returns a new TickDirectionField initialized with val +func NewTickDirection(val string) TickDirectionField { + return TickDirectionField{quickfix.FIXString(val)} +} + +//TickIncrementField is a PRICE field +type TickIncrementField struct{ quickfix.FIXFloat } + +//Tag returns tag.TickIncrement (1208) +func (f TickIncrementField) Tag() quickfix.Tag { return tag.TickIncrement } + +//NewTickIncrement returns a new TickIncrementField initialized with val +func NewTickIncrement(val float64) TickIncrementField { + return TickIncrementField{quickfix.FIXFloat(val)} +} + +//TickRuleTypeField is a INT field +type TickRuleTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.TickRuleType (1209) +func (f TickRuleTypeField) Tag() quickfix.Tag { return tag.TickRuleType } + +//NewTickRuleType returns a new TickRuleTypeField initialized with val +func NewTickRuleType(val int) TickRuleTypeField { + return TickRuleTypeField{quickfix.FIXInt(val)} +} + +//TierCodeField is a STRING field +type TierCodeField struct{ quickfix.FIXString } + +//Tag returns tag.TierCode (994) +func (f TierCodeField) Tag() quickfix.Tag { return tag.TierCode } + +//NewTierCode returns a new TierCodeField initialized with val +func NewTierCode(val string) TierCodeField { + return TierCodeField{quickfix.FIXString(val)} +} + +//TimeBracketField is a STRING field +type TimeBracketField struct{ quickfix.FIXString } + +//Tag returns tag.TimeBracket (943) +func (f TimeBracketField) Tag() quickfix.Tag { return tag.TimeBracket } + +//NewTimeBracket returns a new TimeBracketField initialized with val +func NewTimeBracket(val string) TimeBracketField { + return TimeBracketField{quickfix.FIXString(val)} +} + +//TimeInForceField is a CHAR field +type TimeInForceField struct{ quickfix.FIXString } + +//Tag returns tag.TimeInForce (59) +func (f TimeInForceField) Tag() quickfix.Tag { return tag.TimeInForce } + +//NewTimeInForce returns a new TimeInForceField initialized with val +func NewTimeInForce(val string) TimeInForceField { + return TimeInForceField{quickfix.FIXString(val)} +} + +//TimeToExpirationField is a FLOAT field +type TimeToExpirationField struct{ quickfix.FIXFloat } + +//Tag returns tag.TimeToExpiration (1189) +func (f TimeToExpirationField) Tag() quickfix.Tag { return tag.TimeToExpiration } + +//NewTimeToExpiration returns a new TimeToExpirationField initialized with val +func NewTimeToExpiration(val float64) TimeToExpirationField { + return TimeToExpirationField{quickfix.FIXFloat(val)} +} + +//TimeUnitField is a STRING field +type TimeUnitField struct{ quickfix.FIXString } + +//Tag returns tag.TimeUnit (997) +func (f TimeUnitField) Tag() quickfix.Tag { return tag.TimeUnit } + +//NewTimeUnit returns a new TimeUnitField initialized with val +func NewTimeUnit(val string) TimeUnitField { + return TimeUnitField{quickfix.FIXString(val)} +} + +//TotNoAccQuotesField is a INT field +type TotNoAccQuotesField struct{ quickfix.FIXInt } + +//Tag returns tag.TotNoAccQuotes (1169) +func (f TotNoAccQuotesField) Tag() quickfix.Tag { return tag.TotNoAccQuotes } + +//NewTotNoAccQuotes returns a new TotNoAccQuotesField initialized with val +func NewTotNoAccQuotes(val int) TotNoAccQuotesField { + return TotNoAccQuotesField{quickfix.FIXInt(val)} +} + +//TotNoAllocsField is a INT field +type TotNoAllocsField struct{ quickfix.FIXInt } + +//Tag returns tag.TotNoAllocs (892) +func (f TotNoAllocsField) Tag() quickfix.Tag { return tag.TotNoAllocs } + +//NewTotNoAllocs returns a new TotNoAllocsField initialized with val +func NewTotNoAllocs(val int) TotNoAllocsField { + return TotNoAllocsField{quickfix.FIXInt(val)} +} + +//TotNoCxldQuotesField is a INT field +type TotNoCxldQuotesField struct{ quickfix.FIXInt } + +//Tag returns tag.TotNoCxldQuotes (1168) +func (f TotNoCxldQuotesField) Tag() quickfix.Tag { return tag.TotNoCxldQuotes } + +//NewTotNoCxldQuotes returns a new TotNoCxldQuotesField initialized with val +func NewTotNoCxldQuotes(val int) TotNoCxldQuotesField { + return TotNoCxldQuotesField{quickfix.FIXInt(val)} +} + +//TotNoFillsField is a INT field +type TotNoFillsField struct{ quickfix.FIXInt } + +//Tag returns tag.TotNoFills (1361) +func (f TotNoFillsField) Tag() quickfix.Tag { return tag.TotNoFills } + +//NewTotNoFills returns a new TotNoFillsField initialized with val +func NewTotNoFills(val int) TotNoFillsField { + return TotNoFillsField{quickfix.FIXInt(val)} +} + +//TotNoOrdersField is a INT field +type TotNoOrdersField struct{ quickfix.FIXInt } + +//Tag returns tag.TotNoOrders (68) +func (f TotNoOrdersField) Tag() quickfix.Tag { return tag.TotNoOrders } + +//NewTotNoOrders returns a new TotNoOrdersField initialized with val +func NewTotNoOrders(val int) TotNoOrdersField { + return TotNoOrdersField{quickfix.FIXInt(val)} +} + +//TotNoPartyListField is a INT field +type TotNoPartyListField struct{ quickfix.FIXInt } + +//Tag returns tag.TotNoPartyList (1512) +func (f TotNoPartyListField) Tag() quickfix.Tag { return tag.TotNoPartyList } + +//NewTotNoPartyList returns a new TotNoPartyListField initialized with val +func NewTotNoPartyList(val int) TotNoPartyListField { + return TotNoPartyListField{quickfix.FIXInt(val)} +} + +//TotNoQuoteEntriesField is a INT field +type TotNoQuoteEntriesField struct{ quickfix.FIXInt } + +//Tag returns tag.TotNoQuoteEntries (304) +func (f TotNoQuoteEntriesField) Tag() quickfix.Tag { return tag.TotNoQuoteEntries } + +//NewTotNoQuoteEntries returns a new TotNoQuoteEntriesField initialized with val +func NewTotNoQuoteEntries(val int) TotNoQuoteEntriesField { + return TotNoQuoteEntriesField{quickfix.FIXInt(val)} +} + +//TotNoRejQuotesField is a INT field +type TotNoRejQuotesField struct{ quickfix.FIXInt } + +//Tag returns tag.TotNoRejQuotes (1170) +func (f TotNoRejQuotesField) Tag() quickfix.Tag { return tag.TotNoRejQuotes } + +//NewTotNoRejQuotes returns a new TotNoRejQuotesField initialized with val +func NewTotNoRejQuotes(val int) TotNoRejQuotesField { + return TotNoRejQuotesField{quickfix.FIXInt(val)} +} + +//TotNoRelatedSymField is a INT field +type TotNoRelatedSymField struct{ quickfix.FIXInt } + +//Tag returns tag.TotNoRelatedSym (393) +func (f TotNoRelatedSymField) Tag() quickfix.Tag { return tag.TotNoRelatedSym } + +//NewTotNoRelatedSym returns a new TotNoRelatedSymField initialized with val +func NewTotNoRelatedSym(val int) TotNoRelatedSymField { + return TotNoRelatedSymField{quickfix.FIXInt(val)} +} + +//TotNoSecurityTypesField is a INT field +type TotNoSecurityTypesField struct{ quickfix.FIXInt } + +//Tag returns tag.TotNoSecurityTypes (557) +func (f TotNoSecurityTypesField) Tag() quickfix.Tag { return tag.TotNoSecurityTypes } + +//NewTotNoSecurityTypes returns a new TotNoSecurityTypesField initialized with val +func NewTotNoSecurityTypes(val int) TotNoSecurityTypesField { + return TotNoSecurityTypesField{quickfix.FIXInt(val)} +} + +//TotNoStrikesField is a INT field +type TotNoStrikesField struct{ quickfix.FIXInt } + +//Tag returns tag.TotNoStrikes (422) +func (f TotNoStrikesField) Tag() quickfix.Tag { return tag.TotNoStrikes } + +//NewTotNoStrikes returns a new TotNoStrikesField initialized with val +func NewTotNoStrikes(val int) TotNoStrikesField { + return TotNoStrikesField{quickfix.FIXInt(val)} +} + +//TotNumAssignmentReportsField is a INT field +type TotNumAssignmentReportsField struct{ quickfix.FIXInt } + +//Tag returns tag.TotNumAssignmentReports (832) +func (f TotNumAssignmentReportsField) Tag() quickfix.Tag { return tag.TotNumAssignmentReports } + +//NewTotNumAssignmentReports returns a new TotNumAssignmentReportsField initialized with val +func NewTotNumAssignmentReports(val int) TotNumAssignmentReportsField { + return TotNumAssignmentReportsField{quickfix.FIXInt(val)} +} + +//TotNumReportsField is a INT field +type TotNumReportsField struct{ quickfix.FIXInt } + +//Tag returns tag.TotNumReports (911) +func (f TotNumReportsField) Tag() quickfix.Tag { return tag.TotNumReports } + +//NewTotNumReports returns a new TotNumReportsField initialized with val +func NewTotNumReports(val int) TotNumReportsField { + return TotNumReportsField{quickfix.FIXInt(val)} +} + +//TotNumTradeReportsField is a INT field +type TotNumTradeReportsField struct{ quickfix.FIXInt } + +//Tag returns tag.TotNumTradeReports (748) +func (f TotNumTradeReportsField) Tag() quickfix.Tag { return tag.TotNumTradeReports } + +//NewTotNumTradeReports returns a new TotNumTradeReportsField initialized with val +func NewTotNumTradeReports(val int) TotNumTradeReportsField { + return TotNumTradeReportsField{quickfix.FIXInt(val)} +} + +//TotQuoteEntriesField is a INT field +type TotQuoteEntriesField struct{ quickfix.FIXInt } + +//Tag returns tag.TotQuoteEntries (304) +func (f TotQuoteEntriesField) Tag() quickfix.Tag { return tag.TotQuoteEntries } + +//NewTotQuoteEntries returns a new TotQuoteEntriesField initialized with val +func NewTotQuoteEntries(val int) TotQuoteEntriesField { + return TotQuoteEntriesField{quickfix.FIXInt(val)} +} + +//TotalAccruedInterestAmtField is a AMT field +type TotalAccruedInterestAmtField struct{ quickfix.FIXFloat } + +//Tag returns tag.TotalAccruedInterestAmt (540) +func (f TotalAccruedInterestAmtField) Tag() quickfix.Tag { return tag.TotalAccruedInterestAmt } + +//NewTotalAccruedInterestAmt returns a new TotalAccruedInterestAmtField initialized with val +func NewTotalAccruedInterestAmt(val float64) TotalAccruedInterestAmtField { + return TotalAccruedInterestAmtField{quickfix.FIXFloat(val)} +} + +//TotalAffectedOrdersField is a INT field +type TotalAffectedOrdersField struct{ quickfix.FIXInt } + +//Tag returns tag.TotalAffectedOrders (533) +func (f TotalAffectedOrdersField) Tag() quickfix.Tag { return tag.TotalAffectedOrders } + +//NewTotalAffectedOrders returns a new TotalAffectedOrdersField initialized with val +func NewTotalAffectedOrders(val int) TotalAffectedOrdersField { + return TotalAffectedOrdersField{quickfix.FIXInt(val)} +} + +//TotalNetValueField is a AMT field +type TotalNetValueField struct{ quickfix.FIXFloat } + +//Tag returns tag.TotalNetValue (900) +func (f TotalNetValueField) Tag() quickfix.Tag { return tag.TotalNetValue } + +//NewTotalNetValue returns a new TotalNetValueField initialized with val +func NewTotalNetValue(val float64) TotalNetValueField { + return TotalNetValueField{quickfix.FIXFloat(val)} +} + +//TotalNumPosReportsField is a INT field +type TotalNumPosReportsField struct{ quickfix.FIXInt } + +//Tag returns tag.TotalNumPosReports (727) +func (f TotalNumPosReportsField) Tag() quickfix.Tag { return tag.TotalNumPosReports } + +//NewTotalNumPosReports returns a new TotalNumPosReportsField initialized with val +func NewTotalNumPosReports(val int) TotalNumPosReportsField { + return TotalNumPosReportsField{quickfix.FIXInt(val)} +} + +//TotalNumSecuritiesField is a INT field +type TotalNumSecuritiesField struct{ quickfix.FIXInt } + +//Tag returns tag.TotalNumSecurities (393) +func (f TotalNumSecuritiesField) Tag() quickfix.Tag { return tag.TotalNumSecurities } + +//NewTotalNumSecurities returns a new TotalNumSecuritiesField initialized with val +func NewTotalNumSecurities(val int) TotalNumSecuritiesField { + return TotalNumSecuritiesField{quickfix.FIXInt(val)} +} + +//TotalNumSecurityTypesField is a INT field +type TotalNumSecurityTypesField struct{ quickfix.FIXInt } + +//Tag returns tag.TotalNumSecurityTypes (557) +func (f TotalNumSecurityTypesField) Tag() quickfix.Tag { return tag.TotalNumSecurityTypes } + +//NewTotalNumSecurityTypes returns a new TotalNumSecurityTypesField initialized with val +func NewTotalNumSecurityTypes(val int) TotalNumSecurityTypesField { + return TotalNumSecurityTypesField{quickfix.FIXInt(val)} +} + +//TotalTakedownField is a AMT field +type TotalTakedownField struct{ quickfix.FIXFloat } + +//Tag returns tag.TotalTakedown (237) +func (f TotalTakedownField) Tag() quickfix.Tag { return tag.TotalTakedown } + +//NewTotalTakedown returns a new TotalTakedownField initialized with val +func NewTotalTakedown(val float64) TotalTakedownField { + return TotalTakedownField{quickfix.FIXFloat(val)} +} + +//TotalVolumeTradedField is a QTY field +type TotalVolumeTradedField struct{ quickfix.FIXFloat } + +//Tag returns tag.TotalVolumeTraded (387) +func (f TotalVolumeTradedField) Tag() quickfix.Tag { return tag.TotalVolumeTraded } + +//NewTotalVolumeTraded returns a new TotalVolumeTradedField initialized with val +func NewTotalVolumeTraded(val float64) TotalVolumeTradedField { + return TotalVolumeTradedField{quickfix.FIXFloat(val)} +} + +//TotalVolumeTradedDateField is a UTCDATEONLY field +type TotalVolumeTradedDateField struct{ quickfix.FIXString } + +//Tag returns tag.TotalVolumeTradedDate (449) +func (f TotalVolumeTradedDateField) Tag() quickfix.Tag { return tag.TotalVolumeTradedDate } + +//NewTotalVolumeTradedDate returns a new TotalVolumeTradedDateField initialized with val +func NewTotalVolumeTradedDate(val string) TotalVolumeTradedDateField { + return TotalVolumeTradedDateField{quickfix.FIXString(val)} +} + +//TotalVolumeTradedTimeField is a UTCTIMEONLY field +type TotalVolumeTradedTimeField struct{ quickfix.FIXString } + +//Tag returns tag.TotalVolumeTradedTime (450) +func (f TotalVolumeTradedTimeField) Tag() quickfix.Tag { return tag.TotalVolumeTradedTime } + +//NewTotalVolumeTradedTime returns a new TotalVolumeTradedTimeField initialized with val +func NewTotalVolumeTradedTime(val string) TotalVolumeTradedTimeField { + return TotalVolumeTradedTimeField{quickfix.FIXString(val)} +} + +//TradSesCloseTimeField is a UTCTIMESTAMP field +type TradSesCloseTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.TradSesCloseTime (344) +func (f TradSesCloseTimeField) Tag() quickfix.Tag { return tag.TradSesCloseTime } + +//NewTradSesCloseTime returns a new TradSesCloseTimeField initialized with val +func NewTradSesCloseTime(val time.Time) TradSesCloseTimeField { + return TradSesCloseTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewTradSesCloseTimeNoMillis returns a new TradSesCloseTimeField initialized with val without millisecs +func NewTradSesCloseTimeNoMillis(val time.Time) TradSesCloseTimeField { + return TradSesCloseTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//TradSesEndTimeField is a UTCTIMESTAMP field +type TradSesEndTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.TradSesEndTime (345) +func (f TradSesEndTimeField) Tag() quickfix.Tag { return tag.TradSesEndTime } + +//NewTradSesEndTime returns a new TradSesEndTimeField initialized with val +func NewTradSesEndTime(val time.Time) TradSesEndTimeField { + return TradSesEndTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewTradSesEndTimeNoMillis returns a new TradSesEndTimeField initialized with val without millisecs +func NewTradSesEndTimeNoMillis(val time.Time) TradSesEndTimeField { + return TradSesEndTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//TradSesEventField is a INT field +type TradSesEventField struct{ quickfix.FIXInt } + +//Tag returns tag.TradSesEvent (1368) +func (f TradSesEventField) Tag() quickfix.Tag { return tag.TradSesEvent } + +//NewTradSesEvent returns a new TradSesEventField initialized with val +func NewTradSesEvent(val int) TradSesEventField { + return TradSesEventField{quickfix.FIXInt(val)} +} + +//TradSesMethodField is a INT field +type TradSesMethodField struct{ quickfix.FIXInt } + +//Tag returns tag.TradSesMethod (338) +func (f TradSesMethodField) Tag() quickfix.Tag { return tag.TradSesMethod } + +//NewTradSesMethod returns a new TradSesMethodField initialized with val +func NewTradSesMethod(val int) TradSesMethodField { + return TradSesMethodField{quickfix.FIXInt(val)} +} + +//TradSesModeField is a INT field +type TradSesModeField struct{ quickfix.FIXInt } + +//Tag returns tag.TradSesMode (339) +func (f TradSesModeField) Tag() quickfix.Tag { return tag.TradSesMode } + +//NewTradSesMode returns a new TradSesModeField initialized with val +func NewTradSesMode(val int) TradSesModeField { + return TradSesModeField{quickfix.FIXInt(val)} +} + +//TradSesOpenTimeField is a UTCTIMESTAMP field +type TradSesOpenTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.TradSesOpenTime (342) +func (f TradSesOpenTimeField) Tag() quickfix.Tag { return tag.TradSesOpenTime } + +//NewTradSesOpenTime returns a new TradSesOpenTimeField initialized with val +func NewTradSesOpenTime(val time.Time) TradSesOpenTimeField { + return TradSesOpenTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewTradSesOpenTimeNoMillis returns a new TradSesOpenTimeField initialized with val without millisecs +func NewTradSesOpenTimeNoMillis(val time.Time) TradSesOpenTimeField { + return TradSesOpenTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//TradSesPreCloseTimeField is a UTCTIMESTAMP field +type TradSesPreCloseTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.TradSesPreCloseTime (343) +func (f TradSesPreCloseTimeField) Tag() quickfix.Tag { return tag.TradSesPreCloseTime } + +//NewTradSesPreCloseTime returns a new TradSesPreCloseTimeField initialized with val +func NewTradSesPreCloseTime(val time.Time) TradSesPreCloseTimeField { + return TradSesPreCloseTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewTradSesPreCloseTimeNoMillis returns a new TradSesPreCloseTimeField initialized with val without millisecs +func NewTradSesPreCloseTimeNoMillis(val time.Time) TradSesPreCloseTimeField { + return TradSesPreCloseTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//TradSesReqIDField is a STRING field +type TradSesReqIDField struct{ quickfix.FIXString } + +//Tag returns tag.TradSesReqID (335) +func (f TradSesReqIDField) Tag() quickfix.Tag { return tag.TradSesReqID } + +//NewTradSesReqID returns a new TradSesReqIDField initialized with val +func NewTradSesReqID(val string) TradSesReqIDField { + return TradSesReqIDField{quickfix.FIXString(val)} +} + +//TradSesStartTimeField is a UTCTIMESTAMP field +type TradSesStartTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.TradSesStartTime (341) +func (f TradSesStartTimeField) Tag() quickfix.Tag { return tag.TradSesStartTime } + +//NewTradSesStartTime returns a new TradSesStartTimeField initialized with val +func NewTradSesStartTime(val time.Time) TradSesStartTimeField { + return TradSesStartTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewTradSesStartTimeNoMillis returns a new TradSesStartTimeField initialized with val without millisecs +func NewTradSesStartTimeNoMillis(val time.Time) TradSesStartTimeField { + return TradSesStartTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//TradSesStatusField is a INT field +type TradSesStatusField struct{ quickfix.FIXInt } + +//Tag returns tag.TradSesStatus (340) +func (f TradSesStatusField) Tag() quickfix.Tag { return tag.TradSesStatus } + +//NewTradSesStatus returns a new TradSesStatusField initialized with val +func NewTradSesStatus(val int) TradSesStatusField { + return TradSesStatusField{quickfix.FIXInt(val)} +} + +//TradSesStatusRejReasonField is a INT field +type TradSesStatusRejReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.TradSesStatusRejReason (567) +func (f TradSesStatusRejReasonField) Tag() quickfix.Tag { return tag.TradSesStatusRejReason } + +//NewTradSesStatusRejReason returns a new TradSesStatusRejReasonField initialized with val +func NewTradSesStatusRejReason(val int) TradSesStatusRejReasonField { + return TradSesStatusRejReasonField{quickfix.FIXInt(val)} +} + +//TradSesUpdateActionField is a CHAR field +type TradSesUpdateActionField struct{ quickfix.FIXString } + +//Tag returns tag.TradSesUpdateAction (1327) +func (f TradSesUpdateActionField) Tag() quickfix.Tag { return tag.TradSesUpdateAction } + +//NewTradSesUpdateAction returns a new TradSesUpdateActionField initialized with val +func NewTradSesUpdateAction(val string) TradSesUpdateActionField { + return TradSesUpdateActionField{quickfix.FIXString(val)} +} + +//TradeAllocIndicatorField is a INT field +type TradeAllocIndicatorField struct{ quickfix.FIXInt } + +//Tag returns tag.TradeAllocIndicator (826) +func (f TradeAllocIndicatorField) Tag() quickfix.Tag { return tag.TradeAllocIndicator } + +//NewTradeAllocIndicator returns a new TradeAllocIndicatorField initialized with val +func NewTradeAllocIndicator(val int) TradeAllocIndicatorField { + return TradeAllocIndicatorField{quickfix.FIXInt(val)} +} + +//TradeConditionField is a MULTIPLESTRINGVALUE field +type TradeConditionField struct{ quickfix.FIXString } + +//Tag returns tag.TradeCondition (277) +func (f TradeConditionField) Tag() quickfix.Tag { return tag.TradeCondition } + +//NewTradeCondition returns a new TradeConditionField initialized with val +func NewTradeCondition(val string) TradeConditionField { + return TradeConditionField{quickfix.FIXString(val)} +} + +//TradeDateField is a LOCALMKTDATE field +type TradeDateField struct{ quickfix.FIXString } + +//Tag returns tag.TradeDate (75) +func (f TradeDateField) Tag() quickfix.Tag { return tag.TradeDate } + +//NewTradeDate returns a new TradeDateField initialized with val +func NewTradeDate(val string) TradeDateField { + return TradeDateField{quickfix.FIXString(val)} +} + +//TradeHandlingInstrField is a CHAR field +type TradeHandlingInstrField struct{ quickfix.FIXString } + +//Tag returns tag.TradeHandlingInstr (1123) +func (f TradeHandlingInstrField) Tag() quickfix.Tag { return tag.TradeHandlingInstr } + +//NewTradeHandlingInstr returns a new TradeHandlingInstrField initialized with val +func NewTradeHandlingInstr(val string) TradeHandlingInstrField { + return TradeHandlingInstrField{quickfix.FIXString(val)} +} + +//TradeIDField is a STRING field +type TradeIDField struct{ quickfix.FIXString } + +//Tag returns tag.TradeID (1003) +func (f TradeIDField) Tag() quickfix.Tag { return tag.TradeID } + +//NewTradeID returns a new TradeIDField initialized with val +func NewTradeID(val string) TradeIDField { + return TradeIDField{quickfix.FIXString(val)} +} + +//TradeInputDeviceField is a STRING field +type TradeInputDeviceField struct{ quickfix.FIXString } + +//Tag returns tag.TradeInputDevice (579) +func (f TradeInputDeviceField) Tag() quickfix.Tag { return tag.TradeInputDevice } + +//NewTradeInputDevice returns a new TradeInputDeviceField initialized with val +func NewTradeInputDevice(val string) TradeInputDeviceField { + return TradeInputDeviceField{quickfix.FIXString(val)} +} + +//TradeInputSourceField is a STRING field +type TradeInputSourceField struct{ quickfix.FIXString } + +//Tag returns tag.TradeInputSource (578) +func (f TradeInputSourceField) Tag() quickfix.Tag { return tag.TradeInputSource } + +//NewTradeInputSource returns a new TradeInputSourceField initialized with val +func NewTradeInputSource(val string) TradeInputSourceField { + return TradeInputSourceField{quickfix.FIXString(val)} +} + +//TradeLegRefIDField is a STRING field +type TradeLegRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.TradeLegRefID (824) +func (f TradeLegRefIDField) Tag() quickfix.Tag { return tag.TradeLegRefID } + +//NewTradeLegRefID returns a new TradeLegRefIDField initialized with val +func NewTradeLegRefID(val string) TradeLegRefIDField { + return TradeLegRefIDField{quickfix.FIXString(val)} +} + +//TradeLinkIDField is a STRING field +type TradeLinkIDField struct{ quickfix.FIXString } + +//Tag returns tag.TradeLinkID (820) +func (f TradeLinkIDField) Tag() quickfix.Tag { return tag.TradeLinkID } + +//NewTradeLinkID returns a new TradeLinkIDField initialized with val +func NewTradeLinkID(val string) TradeLinkIDField { + return TradeLinkIDField{quickfix.FIXString(val)} +} + +//TradeOriginationDateField is a LOCALMKTDATE field +type TradeOriginationDateField struct{ quickfix.FIXString } + +//Tag returns tag.TradeOriginationDate (229) +func (f TradeOriginationDateField) Tag() quickfix.Tag { return tag.TradeOriginationDate } + +//NewTradeOriginationDate returns a new TradeOriginationDateField initialized with val +func NewTradeOriginationDate(val string) TradeOriginationDateField { + return TradeOriginationDateField{quickfix.FIXString(val)} +} + +//TradePublishIndicatorField is a INT field +type TradePublishIndicatorField struct{ quickfix.FIXInt } + +//Tag returns tag.TradePublishIndicator (1390) +func (f TradePublishIndicatorField) Tag() quickfix.Tag { return tag.TradePublishIndicator } + +//NewTradePublishIndicator returns a new TradePublishIndicatorField initialized with val +func NewTradePublishIndicator(val int) TradePublishIndicatorField { + return TradePublishIndicatorField{quickfix.FIXInt(val)} +} + +//TradeReportIDField is a STRING field +type TradeReportIDField struct{ quickfix.FIXString } + +//Tag returns tag.TradeReportID (571) +func (f TradeReportIDField) Tag() quickfix.Tag { return tag.TradeReportID } + +//NewTradeReportID returns a new TradeReportIDField initialized with val +func NewTradeReportID(val string) TradeReportIDField { + return TradeReportIDField{quickfix.FIXString(val)} +} + +//TradeReportRefIDField is a STRING field +type TradeReportRefIDField struct{ quickfix.FIXString } + +//Tag returns tag.TradeReportRefID (572) +func (f TradeReportRefIDField) Tag() quickfix.Tag { return tag.TradeReportRefID } + +//NewTradeReportRefID returns a new TradeReportRefIDField initialized with val +func NewTradeReportRefID(val string) TradeReportRefIDField { + return TradeReportRefIDField{quickfix.FIXString(val)} +} + +//TradeReportRejectReasonField is a INT field +type TradeReportRejectReasonField struct{ quickfix.FIXInt } + +//Tag returns tag.TradeReportRejectReason (751) +func (f TradeReportRejectReasonField) Tag() quickfix.Tag { return tag.TradeReportRejectReason } + +//NewTradeReportRejectReason returns a new TradeReportRejectReasonField initialized with val +func NewTradeReportRejectReason(val int) TradeReportRejectReasonField { + return TradeReportRejectReasonField{quickfix.FIXInt(val)} +} + +//TradeReportTransTypeField is a INT field +type TradeReportTransTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.TradeReportTransType (487) +func (f TradeReportTransTypeField) Tag() quickfix.Tag { return tag.TradeReportTransType } + +//NewTradeReportTransType returns a new TradeReportTransTypeField initialized with val +func NewTradeReportTransType(val int) TradeReportTransTypeField { + return TradeReportTransTypeField{quickfix.FIXInt(val)} +} + +//TradeReportTypeField is a INT field +type TradeReportTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.TradeReportType (856) +func (f TradeReportTypeField) Tag() quickfix.Tag { return tag.TradeReportType } + +//NewTradeReportType returns a new TradeReportTypeField initialized with val +func NewTradeReportType(val int) TradeReportTypeField { + return TradeReportTypeField{quickfix.FIXInt(val)} +} + +//TradeRequestIDField is a STRING field +type TradeRequestIDField struct{ quickfix.FIXString } + +//Tag returns tag.TradeRequestID (568) +func (f TradeRequestIDField) Tag() quickfix.Tag { return tag.TradeRequestID } + +//NewTradeRequestID returns a new TradeRequestIDField initialized with val +func NewTradeRequestID(val string) TradeRequestIDField { + return TradeRequestIDField{quickfix.FIXString(val)} +} + +//TradeRequestResultField is a INT field +type TradeRequestResultField struct{ quickfix.FIXInt } + +//Tag returns tag.TradeRequestResult (749) +func (f TradeRequestResultField) Tag() quickfix.Tag { return tag.TradeRequestResult } + +//NewTradeRequestResult returns a new TradeRequestResultField initialized with val +func NewTradeRequestResult(val int) TradeRequestResultField { + return TradeRequestResultField{quickfix.FIXInt(val)} +} + +//TradeRequestStatusField is a INT field +type TradeRequestStatusField struct{ quickfix.FIXInt } + +//Tag returns tag.TradeRequestStatus (750) +func (f TradeRequestStatusField) Tag() quickfix.Tag { return tag.TradeRequestStatus } + +//NewTradeRequestStatus returns a new TradeRequestStatusField initialized with val +func NewTradeRequestStatus(val int) TradeRequestStatusField { + return TradeRequestStatusField{quickfix.FIXInt(val)} +} + +//TradeRequestTypeField is a INT field +type TradeRequestTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.TradeRequestType (569) +func (f TradeRequestTypeField) Tag() quickfix.Tag { return tag.TradeRequestType } + +//NewTradeRequestType returns a new TradeRequestTypeField initialized with val +func NewTradeRequestType(val int) TradeRequestTypeField { + return TradeRequestTypeField{quickfix.FIXInt(val)} +} + +//TradeTypeField is a CHAR field +type TradeTypeField struct{ quickfix.FIXString } + +//Tag returns tag.TradeType (418) +func (f TradeTypeField) Tag() quickfix.Tag { return tag.TradeType } + +//NewTradeType returns a new TradeTypeField initialized with val +func NewTradeType(val string) TradeTypeField { + return TradeTypeField{quickfix.FIXString(val)} +} + +//TradeVolumeField is a QTY field +type TradeVolumeField struct{ quickfix.FIXFloat } + +//Tag returns tag.TradeVolume (1020) +func (f TradeVolumeField) Tag() quickfix.Tag { return tag.TradeVolume } + +//NewTradeVolume returns a new TradeVolumeField initialized with val +func NewTradeVolume(val float64) TradeVolumeField { + return TradeVolumeField{quickfix.FIXFloat(val)} +} + +//TradedFlatSwitchField is a BOOLEAN field +type TradedFlatSwitchField struct{ quickfix.FIXBoolean } + +//Tag returns tag.TradedFlatSwitch (258) +func (f TradedFlatSwitchField) Tag() quickfix.Tag { return tag.TradedFlatSwitch } + +//NewTradedFlatSwitch returns a new TradedFlatSwitchField initialized with val +func NewTradedFlatSwitch(val bool) TradedFlatSwitchField { + return TradedFlatSwitchField{quickfix.FIXBoolean(val)} +} + +//TradingCurrencyField is a CURRENCY field +type TradingCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.TradingCurrency (1245) +func (f TradingCurrencyField) Tag() quickfix.Tag { return tag.TradingCurrency } + +//NewTradingCurrency returns a new TradingCurrencyField initialized with val +func NewTradingCurrency(val string) TradingCurrencyField { + return TradingCurrencyField{quickfix.FIXString(val)} +} + +//TradingReferencePriceField is a PRICE field +type TradingReferencePriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.TradingReferencePrice (1150) +func (f TradingReferencePriceField) Tag() quickfix.Tag { return tag.TradingReferencePrice } + +//NewTradingReferencePrice returns a new TradingReferencePriceField initialized with val +func NewTradingReferencePrice(val float64) TradingReferencePriceField { + return TradingReferencePriceField{quickfix.FIXFloat(val)} +} + +//TradingSessionDescField is a STRING field +type TradingSessionDescField struct{ quickfix.FIXString } + +//Tag returns tag.TradingSessionDesc (1326) +func (f TradingSessionDescField) Tag() quickfix.Tag { return tag.TradingSessionDesc } + +//NewTradingSessionDesc returns a new TradingSessionDescField initialized with val +func NewTradingSessionDesc(val string) TradingSessionDescField { + return TradingSessionDescField{quickfix.FIXString(val)} +} + +//TradingSessionIDField is a STRING field +type TradingSessionIDField struct{ quickfix.FIXString } + +//Tag returns tag.TradingSessionID (336) +func (f TradingSessionIDField) Tag() quickfix.Tag { return tag.TradingSessionID } + +//NewTradingSessionID returns a new TradingSessionIDField initialized with val +func NewTradingSessionID(val string) TradingSessionIDField { + return TradingSessionIDField{quickfix.FIXString(val)} +} + +//TradingSessionSubIDField is a STRING field +type TradingSessionSubIDField struct{ quickfix.FIXString } + +//Tag returns tag.TradingSessionSubID (625) +func (f TradingSessionSubIDField) Tag() quickfix.Tag { return tag.TradingSessionSubID } + +//NewTradingSessionSubID returns a new TradingSessionSubIDField initialized with val +func NewTradingSessionSubID(val string) TradingSessionSubIDField { + return TradingSessionSubIDField{quickfix.FIXString(val)} +} + +//TransBkdTimeField is a UTCTIMESTAMP field +type TransBkdTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.TransBkdTime (483) +func (f TransBkdTimeField) Tag() quickfix.Tag { return tag.TransBkdTime } + +//NewTransBkdTime returns a new TransBkdTimeField initialized with val +func NewTransBkdTime(val time.Time) TransBkdTimeField { + return TransBkdTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewTransBkdTimeNoMillis returns a new TransBkdTimeField initialized with val without millisecs +func NewTransBkdTimeNoMillis(val time.Time) TransBkdTimeField { + return TransBkdTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//TransactTimeField is a UTCTIMESTAMP field +type TransactTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.TransactTime (60) +func (f TransactTimeField) Tag() quickfix.Tag { return tag.TransactTime } + +//NewTransactTime returns a new TransactTimeField initialized with val +func NewTransactTime(val time.Time) TransactTimeField { + return TransactTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewTransactTimeNoMillis returns a new TransactTimeField initialized with val without millisecs +func NewTransactTimeNoMillis(val time.Time) TransactTimeField { + return TransactTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//TransferReasonField is a STRING field +type TransferReasonField struct{ quickfix.FIXString } + +//Tag returns tag.TransferReason (830) +func (f TransferReasonField) Tag() quickfix.Tag { return tag.TransferReason } + +//NewTransferReason returns a new TransferReasonField initialized with val +func NewTransferReason(val string) TransferReasonField { + return TransferReasonField{quickfix.FIXString(val)} +} + +//TrdMatchIDField is a STRING field +type TrdMatchIDField struct{ quickfix.FIXString } + +//Tag returns tag.TrdMatchID (880) +func (f TrdMatchIDField) Tag() quickfix.Tag { return tag.TrdMatchID } + +//NewTrdMatchID returns a new TrdMatchIDField initialized with val +func NewTrdMatchID(val string) TrdMatchIDField { + return TrdMatchIDField{quickfix.FIXString(val)} +} + +//TrdRegTimestampField is a UTCTIMESTAMP field +type TrdRegTimestampField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.TrdRegTimestamp (769) +func (f TrdRegTimestampField) Tag() quickfix.Tag { return tag.TrdRegTimestamp } + +//NewTrdRegTimestamp returns a new TrdRegTimestampField initialized with val +func NewTrdRegTimestamp(val time.Time) TrdRegTimestampField { + return TrdRegTimestampField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewTrdRegTimestampNoMillis returns a new TrdRegTimestampField initialized with val without millisecs +func NewTrdRegTimestampNoMillis(val time.Time) TrdRegTimestampField { + return TrdRegTimestampField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//TrdRegTimestampOriginField is a STRING field +type TrdRegTimestampOriginField struct{ quickfix.FIXString } + +//Tag returns tag.TrdRegTimestampOrigin (771) +func (f TrdRegTimestampOriginField) Tag() quickfix.Tag { return tag.TrdRegTimestampOrigin } + +//NewTrdRegTimestampOrigin returns a new TrdRegTimestampOriginField initialized with val +func NewTrdRegTimestampOrigin(val string) TrdRegTimestampOriginField { + return TrdRegTimestampOriginField{quickfix.FIXString(val)} +} + +//TrdRegTimestampTypeField is a INT field +type TrdRegTimestampTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.TrdRegTimestampType (770) +func (f TrdRegTimestampTypeField) Tag() quickfix.Tag { return tag.TrdRegTimestampType } + +//NewTrdRegTimestampType returns a new TrdRegTimestampTypeField initialized with val +func NewTrdRegTimestampType(val int) TrdRegTimestampTypeField { + return TrdRegTimestampTypeField{quickfix.FIXInt(val)} +} + +//TrdRepIndicatorField is a BOOLEAN field +type TrdRepIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.TrdRepIndicator (1389) +func (f TrdRepIndicatorField) Tag() quickfix.Tag { return tag.TrdRepIndicator } + +//NewTrdRepIndicator returns a new TrdRepIndicatorField initialized with val +func NewTrdRepIndicator(val bool) TrdRepIndicatorField { + return TrdRepIndicatorField{quickfix.FIXBoolean(val)} +} + +//TrdRepPartyRoleField is a INT field +type TrdRepPartyRoleField struct{ quickfix.FIXInt } + +//Tag returns tag.TrdRepPartyRole (1388) +func (f TrdRepPartyRoleField) Tag() quickfix.Tag { return tag.TrdRepPartyRole } + +//NewTrdRepPartyRole returns a new TrdRepPartyRoleField initialized with val +func NewTrdRepPartyRole(val int) TrdRepPartyRoleField { + return TrdRepPartyRoleField{quickfix.FIXInt(val)} +} + +//TrdRptStatusField is a INT field +type TrdRptStatusField struct{ quickfix.FIXInt } + +//Tag returns tag.TrdRptStatus (939) +func (f TrdRptStatusField) Tag() quickfix.Tag { return tag.TrdRptStatus } + +//NewTrdRptStatus returns a new TrdRptStatusField initialized with val +func NewTrdRptStatus(val int) TrdRptStatusField { + return TrdRptStatusField{quickfix.FIXInt(val)} +} + +//TrdSubTypeField is a INT field +type TrdSubTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.TrdSubType (829) +func (f TrdSubTypeField) Tag() quickfix.Tag { return tag.TrdSubType } + +//NewTrdSubType returns a new TrdSubTypeField initialized with val +func NewTrdSubType(val int) TrdSubTypeField { + return TrdSubTypeField{quickfix.FIXInt(val)} +} + +//TrdTypeField is a INT field +type TrdTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.TrdType (828) +func (f TrdTypeField) Tag() quickfix.Tag { return tag.TrdType } + +//NewTrdType returns a new TrdTypeField initialized with val +func NewTrdType(val int) TrdTypeField { + return TrdTypeField{quickfix.FIXInt(val)} +} + +//TriggerActionField is a CHAR field +type TriggerActionField struct{ quickfix.FIXString } + +//Tag returns tag.TriggerAction (1101) +func (f TriggerActionField) Tag() quickfix.Tag { return tag.TriggerAction } + +//NewTriggerAction returns a new TriggerActionField initialized with val +func NewTriggerAction(val string) TriggerActionField { + return TriggerActionField{quickfix.FIXString(val)} +} + +//TriggerNewPriceField is a PRICE field +type TriggerNewPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.TriggerNewPrice (1110) +func (f TriggerNewPriceField) Tag() quickfix.Tag { return tag.TriggerNewPrice } + +//NewTriggerNewPrice returns a new TriggerNewPriceField initialized with val +func NewTriggerNewPrice(val float64) TriggerNewPriceField { + return TriggerNewPriceField{quickfix.FIXFloat(val)} +} + +//TriggerNewQtyField is a QTY field +type TriggerNewQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.TriggerNewQty (1112) +func (f TriggerNewQtyField) Tag() quickfix.Tag { return tag.TriggerNewQty } + +//NewTriggerNewQty returns a new TriggerNewQtyField initialized with val +func NewTriggerNewQty(val float64) TriggerNewQtyField { + return TriggerNewQtyField{quickfix.FIXFloat(val)} +} + +//TriggerOrderTypeField is a CHAR field +type TriggerOrderTypeField struct{ quickfix.FIXString } + +//Tag returns tag.TriggerOrderType (1111) +func (f TriggerOrderTypeField) Tag() quickfix.Tag { return tag.TriggerOrderType } + +//NewTriggerOrderType returns a new TriggerOrderTypeField initialized with val +func NewTriggerOrderType(val string) TriggerOrderTypeField { + return TriggerOrderTypeField{quickfix.FIXString(val)} +} + +//TriggerPriceField is a PRICE field +type TriggerPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.TriggerPrice (1102) +func (f TriggerPriceField) Tag() quickfix.Tag { return tag.TriggerPrice } + +//NewTriggerPrice returns a new TriggerPriceField initialized with val +func NewTriggerPrice(val float64) TriggerPriceField { + return TriggerPriceField{quickfix.FIXFloat(val)} +} + +//TriggerPriceDirectionField is a CHAR field +type TriggerPriceDirectionField struct{ quickfix.FIXString } + +//Tag returns tag.TriggerPriceDirection (1109) +func (f TriggerPriceDirectionField) Tag() quickfix.Tag { return tag.TriggerPriceDirection } + +//NewTriggerPriceDirection returns a new TriggerPriceDirectionField initialized with val +func NewTriggerPriceDirection(val string) TriggerPriceDirectionField { + return TriggerPriceDirectionField{quickfix.FIXString(val)} +} + +//TriggerPriceTypeField is a CHAR field +type TriggerPriceTypeField struct{ quickfix.FIXString } + +//Tag returns tag.TriggerPriceType (1107) +func (f TriggerPriceTypeField) Tag() quickfix.Tag { return tag.TriggerPriceType } + +//NewTriggerPriceType returns a new TriggerPriceTypeField initialized with val +func NewTriggerPriceType(val string) TriggerPriceTypeField { + return TriggerPriceTypeField{quickfix.FIXString(val)} +} + +//TriggerPriceTypeScopeField is a CHAR field +type TriggerPriceTypeScopeField struct{ quickfix.FIXString } + +//Tag returns tag.TriggerPriceTypeScope (1108) +func (f TriggerPriceTypeScopeField) Tag() quickfix.Tag { return tag.TriggerPriceTypeScope } + +//NewTriggerPriceTypeScope returns a new TriggerPriceTypeScopeField initialized with val +func NewTriggerPriceTypeScope(val string) TriggerPriceTypeScopeField { + return TriggerPriceTypeScopeField{quickfix.FIXString(val)} +} + +//TriggerSecurityDescField is a STRING field +type TriggerSecurityDescField struct{ quickfix.FIXString } + +//Tag returns tag.TriggerSecurityDesc (1106) +func (f TriggerSecurityDescField) Tag() quickfix.Tag { return tag.TriggerSecurityDesc } + +//NewTriggerSecurityDesc returns a new TriggerSecurityDescField initialized with val +func NewTriggerSecurityDesc(val string) TriggerSecurityDescField { + return TriggerSecurityDescField{quickfix.FIXString(val)} +} + +//TriggerSecurityIDField is a STRING field +type TriggerSecurityIDField struct{ quickfix.FIXString } + +//Tag returns tag.TriggerSecurityID (1104) +func (f TriggerSecurityIDField) Tag() quickfix.Tag { return tag.TriggerSecurityID } + +//NewTriggerSecurityID returns a new TriggerSecurityIDField initialized with val +func NewTriggerSecurityID(val string) TriggerSecurityIDField { + return TriggerSecurityIDField{quickfix.FIXString(val)} +} + +//TriggerSecurityIDSourceField is a STRING field +type TriggerSecurityIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.TriggerSecurityIDSource (1105) +func (f TriggerSecurityIDSourceField) Tag() quickfix.Tag { return tag.TriggerSecurityIDSource } + +//NewTriggerSecurityIDSource returns a new TriggerSecurityIDSourceField initialized with val +func NewTriggerSecurityIDSource(val string) TriggerSecurityIDSourceField { + return TriggerSecurityIDSourceField{quickfix.FIXString(val)} +} + +//TriggerSymbolField is a STRING field +type TriggerSymbolField struct{ quickfix.FIXString } + +//Tag returns tag.TriggerSymbol (1103) +func (f TriggerSymbolField) Tag() quickfix.Tag { return tag.TriggerSymbol } + +//NewTriggerSymbol returns a new TriggerSymbolField initialized with val +func NewTriggerSymbol(val string) TriggerSymbolField { + return TriggerSymbolField{quickfix.FIXString(val)} +} + +//TriggerTradingSessionIDField is a STRING field +type TriggerTradingSessionIDField struct{ quickfix.FIXString } + +//Tag returns tag.TriggerTradingSessionID (1113) +func (f TriggerTradingSessionIDField) Tag() quickfix.Tag { return tag.TriggerTradingSessionID } + +//NewTriggerTradingSessionID returns a new TriggerTradingSessionIDField initialized with val +func NewTriggerTradingSessionID(val string) TriggerTradingSessionIDField { + return TriggerTradingSessionIDField{quickfix.FIXString(val)} +} + +//TriggerTradingSessionSubIDField is a STRING field +type TriggerTradingSessionSubIDField struct{ quickfix.FIXString } + +//Tag returns tag.TriggerTradingSessionSubID (1114) +func (f TriggerTradingSessionSubIDField) Tag() quickfix.Tag { return tag.TriggerTradingSessionSubID } + +//NewTriggerTradingSessionSubID returns a new TriggerTradingSessionSubIDField initialized with val +func NewTriggerTradingSessionSubID(val string) TriggerTradingSessionSubIDField { + return TriggerTradingSessionSubIDField{quickfix.FIXString(val)} +} + +//TriggerTypeField is a CHAR field +type TriggerTypeField struct{ quickfix.FIXString } + +//Tag returns tag.TriggerType (1100) +func (f TriggerTypeField) Tag() quickfix.Tag { return tag.TriggerType } + +//NewTriggerType returns a new TriggerTypeField initialized with val +func NewTriggerType(val string) TriggerTypeField { + return TriggerTypeField{quickfix.FIXString(val)} +} + +//URLLinkField is a STRING field +type URLLinkField struct{ quickfix.FIXString } + +//Tag returns tag.URLLink (149) +func (f URLLinkField) Tag() quickfix.Tag { return tag.URLLink } + +//NewURLLink returns a new URLLinkField initialized with val +func NewURLLink(val string) URLLinkField { + return URLLinkField{quickfix.FIXString(val)} +} + +//UnderlyingAdjustedQuantityField is a QTY field +type UnderlyingAdjustedQuantityField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingAdjustedQuantity (1044) +func (f UnderlyingAdjustedQuantityField) Tag() quickfix.Tag { return tag.UnderlyingAdjustedQuantity } + +//NewUnderlyingAdjustedQuantity returns a new UnderlyingAdjustedQuantityField initialized with val +func NewUnderlyingAdjustedQuantity(val float64) UnderlyingAdjustedQuantityField { + return UnderlyingAdjustedQuantityField{quickfix.FIXFloat(val)} +} + +//UnderlyingAllocationPercentField is a PERCENTAGE field +type UnderlyingAllocationPercentField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingAllocationPercent (972) +func (f UnderlyingAllocationPercentField) Tag() quickfix.Tag { return tag.UnderlyingAllocationPercent } + +//NewUnderlyingAllocationPercent returns a new UnderlyingAllocationPercentField initialized with val +func NewUnderlyingAllocationPercent(val float64) UnderlyingAllocationPercentField { + return UnderlyingAllocationPercentField{quickfix.FIXFloat(val)} +} + +//UnderlyingAttachmentPointField is a PERCENTAGE field +type UnderlyingAttachmentPointField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingAttachmentPoint (1459) +func (f UnderlyingAttachmentPointField) Tag() quickfix.Tag { return tag.UnderlyingAttachmentPoint } + +//NewUnderlyingAttachmentPoint returns a new UnderlyingAttachmentPointField initialized with val +func NewUnderlyingAttachmentPoint(val float64) UnderlyingAttachmentPointField { + return UnderlyingAttachmentPointField{quickfix.FIXFloat(val)} +} + +//UnderlyingCFICodeField is a STRING field +type UnderlyingCFICodeField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingCFICode (463) +func (f UnderlyingCFICodeField) Tag() quickfix.Tag { return tag.UnderlyingCFICode } + +//NewUnderlyingCFICode returns a new UnderlyingCFICodeField initialized with val +func NewUnderlyingCFICode(val string) UnderlyingCFICodeField { + return UnderlyingCFICodeField{quickfix.FIXString(val)} +} + +//UnderlyingCPProgramField is a STRING field +type UnderlyingCPProgramField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingCPProgram (877) +func (f UnderlyingCPProgramField) Tag() quickfix.Tag { return tag.UnderlyingCPProgram } + +//NewUnderlyingCPProgram returns a new UnderlyingCPProgramField initialized with val +func NewUnderlyingCPProgram(val string) UnderlyingCPProgramField { + return UnderlyingCPProgramField{quickfix.FIXString(val)} +} + +//UnderlyingCPRegTypeField is a STRING field +type UnderlyingCPRegTypeField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingCPRegType (878) +func (f UnderlyingCPRegTypeField) Tag() quickfix.Tag { return tag.UnderlyingCPRegType } + +//NewUnderlyingCPRegType returns a new UnderlyingCPRegTypeField initialized with val +func NewUnderlyingCPRegType(val string) UnderlyingCPRegTypeField { + return UnderlyingCPRegTypeField{quickfix.FIXString(val)} +} + +//UnderlyingCapValueField is a AMT field +type UnderlyingCapValueField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingCapValue (1038) +func (f UnderlyingCapValueField) Tag() quickfix.Tag { return tag.UnderlyingCapValue } + +//NewUnderlyingCapValue returns a new UnderlyingCapValueField initialized with val +func NewUnderlyingCapValue(val float64) UnderlyingCapValueField { + return UnderlyingCapValueField{quickfix.FIXFloat(val)} +} + +//UnderlyingCashAmountField is a AMT field +type UnderlyingCashAmountField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingCashAmount (973) +func (f UnderlyingCashAmountField) Tag() quickfix.Tag { return tag.UnderlyingCashAmount } + +//NewUnderlyingCashAmount returns a new UnderlyingCashAmountField initialized with val +func NewUnderlyingCashAmount(val float64) UnderlyingCashAmountField { + return UnderlyingCashAmountField{quickfix.FIXFloat(val)} +} + +//UnderlyingCashTypeField is a STRING field +type UnderlyingCashTypeField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingCashType (974) +func (f UnderlyingCashTypeField) Tag() quickfix.Tag { return tag.UnderlyingCashType } + +//NewUnderlyingCashType returns a new UnderlyingCashTypeField initialized with val +func NewUnderlyingCashType(val string) UnderlyingCashTypeField { + return UnderlyingCashTypeField{quickfix.FIXString(val)} +} + +//UnderlyingCollectAmountField is a AMT field +type UnderlyingCollectAmountField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingCollectAmount (986) +func (f UnderlyingCollectAmountField) Tag() quickfix.Tag { return tag.UnderlyingCollectAmount } + +//NewUnderlyingCollectAmount returns a new UnderlyingCollectAmountField initialized with val +func NewUnderlyingCollectAmount(val float64) UnderlyingCollectAmountField { + return UnderlyingCollectAmountField{quickfix.FIXFloat(val)} +} + +//UnderlyingContractMultiplierField is a FLOAT field +type UnderlyingContractMultiplierField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingContractMultiplier (436) +func (f UnderlyingContractMultiplierField) Tag() quickfix.Tag { return tag.UnderlyingContractMultiplier } + +//NewUnderlyingContractMultiplier returns a new UnderlyingContractMultiplierField initialized with val +func NewUnderlyingContractMultiplier(val float64) UnderlyingContractMultiplierField { + return UnderlyingContractMultiplierField{quickfix.FIXFloat(val)} +} + +//UnderlyingContractMultiplierUnitField is a INT field +type UnderlyingContractMultiplierUnitField struct{ quickfix.FIXInt } + +//Tag returns tag.UnderlyingContractMultiplierUnit (1437) +func (f UnderlyingContractMultiplierUnitField) Tag() quickfix.Tag { + return tag.UnderlyingContractMultiplierUnit +} + +//NewUnderlyingContractMultiplierUnit returns a new UnderlyingContractMultiplierUnitField initialized with val +func NewUnderlyingContractMultiplierUnit(val int) UnderlyingContractMultiplierUnitField { + return UnderlyingContractMultiplierUnitField{quickfix.FIXInt(val)} +} + +//UnderlyingCountryOfIssueField is a COUNTRY field +type UnderlyingCountryOfIssueField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingCountryOfIssue (592) +func (f UnderlyingCountryOfIssueField) Tag() quickfix.Tag { return tag.UnderlyingCountryOfIssue } + +//NewUnderlyingCountryOfIssue returns a new UnderlyingCountryOfIssueField initialized with val +func NewUnderlyingCountryOfIssue(val string) UnderlyingCountryOfIssueField { + return UnderlyingCountryOfIssueField{quickfix.FIXString(val)} +} + +//UnderlyingCouponPaymentDateField is a LOCALMKTDATE field +type UnderlyingCouponPaymentDateField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingCouponPaymentDate (241) +func (f UnderlyingCouponPaymentDateField) Tag() quickfix.Tag { return tag.UnderlyingCouponPaymentDate } + +//NewUnderlyingCouponPaymentDate returns a new UnderlyingCouponPaymentDateField initialized with val +func NewUnderlyingCouponPaymentDate(val string) UnderlyingCouponPaymentDateField { + return UnderlyingCouponPaymentDateField{quickfix.FIXString(val)} +} + +//UnderlyingCouponRateField is a PERCENTAGE field +type UnderlyingCouponRateField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingCouponRate (435) +func (f UnderlyingCouponRateField) Tag() quickfix.Tag { return tag.UnderlyingCouponRate } + +//NewUnderlyingCouponRate returns a new UnderlyingCouponRateField initialized with val +func NewUnderlyingCouponRate(val float64) UnderlyingCouponRateField { + return UnderlyingCouponRateField{quickfix.FIXFloat(val)} +} + +//UnderlyingCreditRatingField is a STRING field +type UnderlyingCreditRatingField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingCreditRating (256) +func (f UnderlyingCreditRatingField) Tag() quickfix.Tag { return tag.UnderlyingCreditRating } + +//NewUnderlyingCreditRating returns a new UnderlyingCreditRatingField initialized with val +func NewUnderlyingCreditRating(val string) UnderlyingCreditRatingField { + return UnderlyingCreditRatingField{quickfix.FIXString(val)} +} + +//UnderlyingCurrencyField is a CURRENCY field +type UnderlyingCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingCurrency (318) +func (f UnderlyingCurrencyField) Tag() quickfix.Tag { return tag.UnderlyingCurrency } + +//NewUnderlyingCurrency returns a new UnderlyingCurrencyField initialized with val +func NewUnderlyingCurrency(val string) UnderlyingCurrencyField { + return UnderlyingCurrencyField{quickfix.FIXString(val)} +} + +//UnderlyingCurrentValueField is a AMT field +type UnderlyingCurrentValueField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingCurrentValue (885) +func (f UnderlyingCurrentValueField) Tag() quickfix.Tag { return tag.UnderlyingCurrentValue } + +//NewUnderlyingCurrentValue returns a new UnderlyingCurrentValueField initialized with val +func NewUnderlyingCurrentValue(val float64) UnderlyingCurrentValueField { + return UnderlyingCurrentValueField{quickfix.FIXFloat(val)} +} + +//UnderlyingDeliveryAmountField is a AMT field +type UnderlyingDeliveryAmountField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingDeliveryAmount (1037) +func (f UnderlyingDeliveryAmountField) Tag() quickfix.Tag { return tag.UnderlyingDeliveryAmount } + +//NewUnderlyingDeliveryAmount returns a new UnderlyingDeliveryAmountField initialized with val +func NewUnderlyingDeliveryAmount(val float64) UnderlyingDeliveryAmountField { + return UnderlyingDeliveryAmountField{quickfix.FIXFloat(val)} +} + +//UnderlyingDetachmentPointField is a PERCENTAGE field +type UnderlyingDetachmentPointField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingDetachmentPoint (1460) +func (f UnderlyingDetachmentPointField) Tag() quickfix.Tag { return tag.UnderlyingDetachmentPoint } + +//NewUnderlyingDetachmentPoint returns a new UnderlyingDetachmentPointField initialized with val +func NewUnderlyingDetachmentPoint(val float64) UnderlyingDetachmentPointField { + return UnderlyingDetachmentPointField{quickfix.FIXFloat(val)} +} + +//UnderlyingDirtyPriceField is a PRICE field +type UnderlyingDirtyPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingDirtyPrice (882) +func (f UnderlyingDirtyPriceField) Tag() quickfix.Tag { return tag.UnderlyingDirtyPrice } + +//NewUnderlyingDirtyPrice returns a new UnderlyingDirtyPriceField initialized with val +func NewUnderlyingDirtyPrice(val float64) UnderlyingDirtyPriceField { + return UnderlyingDirtyPriceField{quickfix.FIXFloat(val)} +} + +//UnderlyingEndPriceField is a PRICE field +type UnderlyingEndPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingEndPrice (883) +func (f UnderlyingEndPriceField) Tag() quickfix.Tag { return tag.UnderlyingEndPrice } + +//NewUnderlyingEndPrice returns a new UnderlyingEndPriceField initialized with val +func NewUnderlyingEndPrice(val float64) UnderlyingEndPriceField { + return UnderlyingEndPriceField{quickfix.FIXFloat(val)} +} + +//UnderlyingEndValueField is a AMT field +type UnderlyingEndValueField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingEndValue (886) +func (f UnderlyingEndValueField) Tag() quickfix.Tag { return tag.UnderlyingEndValue } + +//NewUnderlyingEndValue returns a new UnderlyingEndValueField initialized with val +func NewUnderlyingEndValue(val float64) UnderlyingEndValueField { + return UnderlyingEndValueField{quickfix.FIXFloat(val)} +} + +//UnderlyingExerciseStyleField is a INT field +type UnderlyingExerciseStyleField struct{ quickfix.FIXInt } + +//Tag returns tag.UnderlyingExerciseStyle (1419) +func (f UnderlyingExerciseStyleField) Tag() quickfix.Tag { return tag.UnderlyingExerciseStyle } + +//NewUnderlyingExerciseStyle returns a new UnderlyingExerciseStyleField initialized with val +func NewUnderlyingExerciseStyle(val int) UnderlyingExerciseStyleField { + return UnderlyingExerciseStyleField{quickfix.FIXInt(val)} +} + +//UnderlyingFXRateField is a FLOAT field +type UnderlyingFXRateField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingFXRate (1045) +func (f UnderlyingFXRateField) Tag() quickfix.Tag { return tag.UnderlyingFXRate } + +//NewUnderlyingFXRate returns a new UnderlyingFXRateField initialized with val +func NewUnderlyingFXRate(val float64) UnderlyingFXRateField { + return UnderlyingFXRateField{quickfix.FIXFloat(val)} +} + +//UnderlyingFXRateCalcField is a CHAR field +type UnderlyingFXRateCalcField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingFXRateCalc (1046) +func (f UnderlyingFXRateCalcField) Tag() quickfix.Tag { return tag.UnderlyingFXRateCalc } + +//NewUnderlyingFXRateCalc returns a new UnderlyingFXRateCalcField initialized with val +func NewUnderlyingFXRateCalc(val string) UnderlyingFXRateCalcField { + return UnderlyingFXRateCalcField{quickfix.FIXString(val)} +} + +//UnderlyingFactorField is a FLOAT field +type UnderlyingFactorField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingFactor (246) +func (f UnderlyingFactorField) Tag() quickfix.Tag { return tag.UnderlyingFactor } + +//NewUnderlyingFactor returns a new UnderlyingFactorField initialized with val +func NewUnderlyingFactor(val float64) UnderlyingFactorField { + return UnderlyingFactorField{quickfix.FIXFloat(val)} +} + +//UnderlyingFlowScheduleTypeField is a INT field +type UnderlyingFlowScheduleTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.UnderlyingFlowScheduleType (1441) +func (f UnderlyingFlowScheduleTypeField) Tag() quickfix.Tag { return tag.UnderlyingFlowScheduleType } + +//NewUnderlyingFlowScheduleType returns a new UnderlyingFlowScheduleTypeField initialized with val +func NewUnderlyingFlowScheduleType(val int) UnderlyingFlowScheduleTypeField { + return UnderlyingFlowScheduleTypeField{quickfix.FIXInt(val)} +} + +//UnderlyingIDSourceField is a STRING field +type UnderlyingIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingIDSource (305) +func (f UnderlyingIDSourceField) Tag() quickfix.Tag { return tag.UnderlyingIDSource } + +//NewUnderlyingIDSource returns a new UnderlyingIDSourceField initialized with val +func NewUnderlyingIDSource(val string) UnderlyingIDSourceField { + return UnderlyingIDSourceField{quickfix.FIXString(val)} +} + +//UnderlyingInstrRegistryField is a STRING field +type UnderlyingInstrRegistryField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingInstrRegistry (595) +func (f UnderlyingInstrRegistryField) Tag() quickfix.Tag { return tag.UnderlyingInstrRegistry } + +//NewUnderlyingInstrRegistry returns a new UnderlyingInstrRegistryField initialized with val +func NewUnderlyingInstrRegistry(val string) UnderlyingInstrRegistryField { + return UnderlyingInstrRegistryField{quickfix.FIXString(val)} +} + +//UnderlyingInstrumentPartyIDField is a STRING field +type UnderlyingInstrumentPartyIDField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingInstrumentPartyID (1059) +func (f UnderlyingInstrumentPartyIDField) Tag() quickfix.Tag { return tag.UnderlyingInstrumentPartyID } + +//NewUnderlyingInstrumentPartyID returns a new UnderlyingInstrumentPartyIDField initialized with val +func NewUnderlyingInstrumentPartyID(val string) UnderlyingInstrumentPartyIDField { + return UnderlyingInstrumentPartyIDField{quickfix.FIXString(val)} +} + +//UnderlyingInstrumentPartyIDSourceField is a CHAR field +type UnderlyingInstrumentPartyIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingInstrumentPartyIDSource (1060) +func (f UnderlyingInstrumentPartyIDSourceField) Tag() quickfix.Tag { + return tag.UnderlyingInstrumentPartyIDSource +} + +//NewUnderlyingInstrumentPartyIDSource returns a new UnderlyingInstrumentPartyIDSourceField initialized with val +func NewUnderlyingInstrumentPartyIDSource(val string) UnderlyingInstrumentPartyIDSourceField { + return UnderlyingInstrumentPartyIDSourceField{quickfix.FIXString(val)} +} + +//UnderlyingInstrumentPartyRoleField is a INT field +type UnderlyingInstrumentPartyRoleField struct{ quickfix.FIXInt } + +//Tag returns tag.UnderlyingInstrumentPartyRole (1061) +func (f UnderlyingInstrumentPartyRoleField) Tag() quickfix.Tag { + return tag.UnderlyingInstrumentPartyRole +} + +//NewUnderlyingInstrumentPartyRole returns a new UnderlyingInstrumentPartyRoleField initialized with val +func NewUnderlyingInstrumentPartyRole(val int) UnderlyingInstrumentPartyRoleField { + return UnderlyingInstrumentPartyRoleField{quickfix.FIXInt(val)} +} + +//UnderlyingInstrumentPartySubIDField is a STRING field +type UnderlyingInstrumentPartySubIDField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingInstrumentPartySubID (1063) +func (f UnderlyingInstrumentPartySubIDField) Tag() quickfix.Tag { + return tag.UnderlyingInstrumentPartySubID +} + +//NewUnderlyingInstrumentPartySubID returns a new UnderlyingInstrumentPartySubIDField initialized with val +func NewUnderlyingInstrumentPartySubID(val string) UnderlyingInstrumentPartySubIDField { + return UnderlyingInstrumentPartySubIDField{quickfix.FIXString(val)} +} + +//UnderlyingInstrumentPartySubIDTypeField is a INT field +type UnderlyingInstrumentPartySubIDTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.UnderlyingInstrumentPartySubIDType (1064) +func (f UnderlyingInstrumentPartySubIDTypeField) Tag() quickfix.Tag { + return tag.UnderlyingInstrumentPartySubIDType +} + +//NewUnderlyingInstrumentPartySubIDType returns a new UnderlyingInstrumentPartySubIDTypeField initialized with val +func NewUnderlyingInstrumentPartySubIDType(val int) UnderlyingInstrumentPartySubIDTypeField { + return UnderlyingInstrumentPartySubIDTypeField{quickfix.FIXInt(val)} +} + +//UnderlyingIssueDateField is a LOCALMKTDATE field +type UnderlyingIssueDateField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingIssueDate (242) +func (f UnderlyingIssueDateField) Tag() quickfix.Tag { return tag.UnderlyingIssueDate } + +//NewUnderlyingIssueDate returns a new UnderlyingIssueDateField initialized with val +func NewUnderlyingIssueDate(val string) UnderlyingIssueDateField { + return UnderlyingIssueDateField{quickfix.FIXString(val)} +} + +//UnderlyingIssuerField is a STRING field +type UnderlyingIssuerField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingIssuer (306) +func (f UnderlyingIssuerField) Tag() quickfix.Tag { return tag.UnderlyingIssuer } + +//NewUnderlyingIssuer returns a new UnderlyingIssuerField initialized with val +func NewUnderlyingIssuer(val string) UnderlyingIssuerField { + return UnderlyingIssuerField{quickfix.FIXString(val)} +} + +//UnderlyingLastPxField is a PRICE field +type UnderlyingLastPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingLastPx (651) +func (f UnderlyingLastPxField) Tag() quickfix.Tag { return tag.UnderlyingLastPx } + +//NewUnderlyingLastPx returns a new UnderlyingLastPxField initialized with val +func NewUnderlyingLastPx(val float64) UnderlyingLastPxField { + return UnderlyingLastPxField{quickfix.FIXFloat(val)} +} + +//UnderlyingLastQtyField is a QTY field +type UnderlyingLastQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingLastQty (652) +func (f UnderlyingLastQtyField) Tag() quickfix.Tag { return tag.UnderlyingLastQty } + +//NewUnderlyingLastQty returns a new UnderlyingLastQtyField initialized with val +func NewUnderlyingLastQty(val float64) UnderlyingLastQtyField { + return UnderlyingLastQtyField{quickfix.FIXFloat(val)} +} + +//UnderlyingLegCFICodeField is a STRING field +type UnderlyingLegCFICodeField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingLegCFICode (1344) +func (f UnderlyingLegCFICodeField) Tag() quickfix.Tag { return tag.UnderlyingLegCFICode } + +//NewUnderlyingLegCFICode returns a new UnderlyingLegCFICodeField initialized with val +func NewUnderlyingLegCFICode(val string) UnderlyingLegCFICodeField { + return UnderlyingLegCFICodeField{quickfix.FIXString(val)} +} + +//UnderlyingLegMaturityDateField is a LOCALMKTDATE field +type UnderlyingLegMaturityDateField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingLegMaturityDate (1345) +func (f UnderlyingLegMaturityDateField) Tag() quickfix.Tag { return tag.UnderlyingLegMaturityDate } + +//NewUnderlyingLegMaturityDate returns a new UnderlyingLegMaturityDateField initialized with val +func NewUnderlyingLegMaturityDate(val string) UnderlyingLegMaturityDateField { + return UnderlyingLegMaturityDateField{quickfix.FIXString(val)} +} + +//UnderlyingLegMaturityMonthYearField is a MONTHYEAR field +type UnderlyingLegMaturityMonthYearField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingLegMaturityMonthYear (1339) +func (f UnderlyingLegMaturityMonthYearField) Tag() quickfix.Tag { + return tag.UnderlyingLegMaturityMonthYear +} + +//NewUnderlyingLegMaturityMonthYear returns a new UnderlyingLegMaturityMonthYearField initialized with val +func NewUnderlyingLegMaturityMonthYear(val string) UnderlyingLegMaturityMonthYearField { + return UnderlyingLegMaturityMonthYearField{quickfix.FIXString(val)} +} + +//UnderlyingLegMaturityTimeField is a TZTIMEONLY field +type UnderlyingLegMaturityTimeField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingLegMaturityTime (1405) +func (f UnderlyingLegMaturityTimeField) Tag() quickfix.Tag { return tag.UnderlyingLegMaturityTime } + +//NewUnderlyingLegMaturityTime returns a new UnderlyingLegMaturityTimeField initialized with val +func NewUnderlyingLegMaturityTime(val string) UnderlyingLegMaturityTimeField { + return UnderlyingLegMaturityTimeField{quickfix.FIXString(val)} +} + +//UnderlyingLegOptAttributeField is a CHAR field +type UnderlyingLegOptAttributeField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingLegOptAttribute (1391) +func (f UnderlyingLegOptAttributeField) Tag() quickfix.Tag { return tag.UnderlyingLegOptAttribute } + +//NewUnderlyingLegOptAttribute returns a new UnderlyingLegOptAttributeField initialized with val +func NewUnderlyingLegOptAttribute(val string) UnderlyingLegOptAttributeField { + return UnderlyingLegOptAttributeField{quickfix.FIXString(val)} +} + +//UnderlyingLegPutOrCallField is a INT field +type UnderlyingLegPutOrCallField struct{ quickfix.FIXInt } + +//Tag returns tag.UnderlyingLegPutOrCall (1343) +func (f UnderlyingLegPutOrCallField) Tag() quickfix.Tag { return tag.UnderlyingLegPutOrCall } + +//NewUnderlyingLegPutOrCall returns a new UnderlyingLegPutOrCallField initialized with val +func NewUnderlyingLegPutOrCall(val int) UnderlyingLegPutOrCallField { + return UnderlyingLegPutOrCallField{quickfix.FIXInt(val)} +} + +//UnderlyingLegSecurityAltIDField is a STRING field +type UnderlyingLegSecurityAltIDField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingLegSecurityAltID (1335) +func (f UnderlyingLegSecurityAltIDField) Tag() quickfix.Tag { return tag.UnderlyingLegSecurityAltID } + +//NewUnderlyingLegSecurityAltID returns a new UnderlyingLegSecurityAltIDField initialized with val +func NewUnderlyingLegSecurityAltID(val string) UnderlyingLegSecurityAltIDField { + return UnderlyingLegSecurityAltIDField{quickfix.FIXString(val)} +} + +//UnderlyingLegSecurityAltIDSourceField is a STRING field +type UnderlyingLegSecurityAltIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingLegSecurityAltIDSource (1336) +func (f UnderlyingLegSecurityAltIDSourceField) Tag() quickfix.Tag { + return tag.UnderlyingLegSecurityAltIDSource +} + +//NewUnderlyingLegSecurityAltIDSource returns a new UnderlyingLegSecurityAltIDSourceField initialized with val +func NewUnderlyingLegSecurityAltIDSource(val string) UnderlyingLegSecurityAltIDSourceField { + return UnderlyingLegSecurityAltIDSourceField{quickfix.FIXString(val)} +} + +//UnderlyingLegSecurityDescField is a STRING field +type UnderlyingLegSecurityDescField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingLegSecurityDesc (1392) +func (f UnderlyingLegSecurityDescField) Tag() quickfix.Tag { return tag.UnderlyingLegSecurityDesc } + +//NewUnderlyingLegSecurityDesc returns a new UnderlyingLegSecurityDescField initialized with val +func NewUnderlyingLegSecurityDesc(val string) UnderlyingLegSecurityDescField { + return UnderlyingLegSecurityDescField{quickfix.FIXString(val)} +} + +//UnderlyingLegSecurityExchangeField is a STRING field +type UnderlyingLegSecurityExchangeField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingLegSecurityExchange (1341) +func (f UnderlyingLegSecurityExchangeField) Tag() quickfix.Tag { + return tag.UnderlyingLegSecurityExchange +} + +//NewUnderlyingLegSecurityExchange returns a new UnderlyingLegSecurityExchangeField initialized with val +func NewUnderlyingLegSecurityExchange(val string) UnderlyingLegSecurityExchangeField { + return UnderlyingLegSecurityExchangeField{quickfix.FIXString(val)} +} + +//UnderlyingLegSecurityIDField is a STRING field +type UnderlyingLegSecurityIDField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingLegSecurityID (1332) +func (f UnderlyingLegSecurityIDField) Tag() quickfix.Tag { return tag.UnderlyingLegSecurityID } + +//NewUnderlyingLegSecurityID returns a new UnderlyingLegSecurityIDField initialized with val +func NewUnderlyingLegSecurityID(val string) UnderlyingLegSecurityIDField { + return UnderlyingLegSecurityIDField{quickfix.FIXString(val)} +} + +//UnderlyingLegSecurityIDSourceField is a STRING field +type UnderlyingLegSecurityIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingLegSecurityIDSource (1333) +func (f UnderlyingLegSecurityIDSourceField) Tag() quickfix.Tag { + return tag.UnderlyingLegSecurityIDSource +} + +//NewUnderlyingLegSecurityIDSource returns a new UnderlyingLegSecurityIDSourceField initialized with val +func NewUnderlyingLegSecurityIDSource(val string) UnderlyingLegSecurityIDSourceField { + return UnderlyingLegSecurityIDSourceField{quickfix.FIXString(val)} +} + +//UnderlyingLegSecuritySubTypeField is a STRING field +type UnderlyingLegSecuritySubTypeField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingLegSecuritySubType (1338) +func (f UnderlyingLegSecuritySubTypeField) Tag() quickfix.Tag { return tag.UnderlyingLegSecuritySubType } + +//NewUnderlyingLegSecuritySubType returns a new UnderlyingLegSecuritySubTypeField initialized with val +func NewUnderlyingLegSecuritySubType(val string) UnderlyingLegSecuritySubTypeField { + return UnderlyingLegSecuritySubTypeField{quickfix.FIXString(val)} +} + +//UnderlyingLegSecurityTypeField is a STRING field +type UnderlyingLegSecurityTypeField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingLegSecurityType (1337) +func (f UnderlyingLegSecurityTypeField) Tag() quickfix.Tag { return tag.UnderlyingLegSecurityType } + +//NewUnderlyingLegSecurityType returns a new UnderlyingLegSecurityTypeField initialized with val +func NewUnderlyingLegSecurityType(val string) UnderlyingLegSecurityTypeField { + return UnderlyingLegSecurityTypeField{quickfix.FIXString(val)} +} + +//UnderlyingLegStrikePriceField is a PRICE field +type UnderlyingLegStrikePriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingLegStrikePrice (1340) +func (f UnderlyingLegStrikePriceField) Tag() quickfix.Tag { return tag.UnderlyingLegStrikePrice } + +//NewUnderlyingLegStrikePrice returns a new UnderlyingLegStrikePriceField initialized with val +func NewUnderlyingLegStrikePrice(val float64) UnderlyingLegStrikePriceField { + return UnderlyingLegStrikePriceField{quickfix.FIXFloat(val)} +} + +//UnderlyingLegSymbolField is a STRING field +type UnderlyingLegSymbolField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingLegSymbol (1330) +func (f UnderlyingLegSymbolField) Tag() quickfix.Tag { return tag.UnderlyingLegSymbol } + +//NewUnderlyingLegSymbol returns a new UnderlyingLegSymbolField initialized with val +func NewUnderlyingLegSymbol(val string) UnderlyingLegSymbolField { + return UnderlyingLegSymbolField{quickfix.FIXString(val)} +} + +//UnderlyingLegSymbolSfxField is a STRING field +type UnderlyingLegSymbolSfxField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingLegSymbolSfx (1331) +func (f UnderlyingLegSymbolSfxField) Tag() quickfix.Tag { return tag.UnderlyingLegSymbolSfx } + +//NewUnderlyingLegSymbolSfx returns a new UnderlyingLegSymbolSfxField initialized with val +func NewUnderlyingLegSymbolSfx(val string) UnderlyingLegSymbolSfxField { + return UnderlyingLegSymbolSfxField{quickfix.FIXString(val)} +} + +//UnderlyingLocaleOfIssueField is a STRING field +type UnderlyingLocaleOfIssueField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingLocaleOfIssue (594) +func (f UnderlyingLocaleOfIssueField) Tag() quickfix.Tag { return tag.UnderlyingLocaleOfIssue } + +//NewUnderlyingLocaleOfIssue returns a new UnderlyingLocaleOfIssueField initialized with val +func NewUnderlyingLocaleOfIssue(val string) UnderlyingLocaleOfIssueField { + return UnderlyingLocaleOfIssueField{quickfix.FIXString(val)} +} + +//UnderlyingMaturityDateField is a LOCALMKTDATE field +type UnderlyingMaturityDateField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingMaturityDate (542) +func (f UnderlyingMaturityDateField) Tag() quickfix.Tag { return tag.UnderlyingMaturityDate } + +//NewUnderlyingMaturityDate returns a new UnderlyingMaturityDateField initialized with val +func NewUnderlyingMaturityDate(val string) UnderlyingMaturityDateField { + return UnderlyingMaturityDateField{quickfix.FIXString(val)} +} + +//UnderlyingMaturityDayField is a DAYOFMONTH field +type UnderlyingMaturityDayField struct{ quickfix.FIXInt } + +//Tag returns tag.UnderlyingMaturityDay (314) +func (f UnderlyingMaturityDayField) Tag() quickfix.Tag { return tag.UnderlyingMaturityDay } + +//NewUnderlyingMaturityDay returns a new UnderlyingMaturityDayField initialized with val +func NewUnderlyingMaturityDay(val int) UnderlyingMaturityDayField { + return UnderlyingMaturityDayField{quickfix.FIXInt(val)} +} + +//UnderlyingMaturityMonthYearField is a MONTHYEAR field +type UnderlyingMaturityMonthYearField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingMaturityMonthYear (313) +func (f UnderlyingMaturityMonthYearField) Tag() quickfix.Tag { return tag.UnderlyingMaturityMonthYear } + +//NewUnderlyingMaturityMonthYear returns a new UnderlyingMaturityMonthYearField initialized with val +func NewUnderlyingMaturityMonthYear(val string) UnderlyingMaturityMonthYearField { + return UnderlyingMaturityMonthYearField{quickfix.FIXString(val)} +} + +//UnderlyingMaturityTimeField is a TZTIMEONLY field +type UnderlyingMaturityTimeField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingMaturityTime (1213) +func (f UnderlyingMaturityTimeField) Tag() quickfix.Tag { return tag.UnderlyingMaturityTime } + +//NewUnderlyingMaturityTime returns a new UnderlyingMaturityTimeField initialized with val +func NewUnderlyingMaturityTime(val string) UnderlyingMaturityTimeField { + return UnderlyingMaturityTimeField{quickfix.FIXString(val)} +} + +//UnderlyingNotionalPercentageOutstandingField is a PERCENTAGE field +type UnderlyingNotionalPercentageOutstandingField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingNotionalPercentageOutstanding (1455) +func (f UnderlyingNotionalPercentageOutstandingField) Tag() quickfix.Tag { + return tag.UnderlyingNotionalPercentageOutstanding +} + +//NewUnderlyingNotionalPercentageOutstanding returns a new UnderlyingNotionalPercentageOutstandingField initialized with val +func NewUnderlyingNotionalPercentageOutstanding(val float64) UnderlyingNotionalPercentageOutstandingField { + return UnderlyingNotionalPercentageOutstandingField{quickfix.FIXFloat(val)} +} + +//UnderlyingOptAttributeField is a CHAR field +type UnderlyingOptAttributeField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingOptAttribute (317) +func (f UnderlyingOptAttributeField) Tag() quickfix.Tag { return tag.UnderlyingOptAttribute } + +//NewUnderlyingOptAttribute returns a new UnderlyingOptAttributeField initialized with val +func NewUnderlyingOptAttribute(val string) UnderlyingOptAttributeField { + return UnderlyingOptAttributeField{quickfix.FIXString(val)} +} + +//UnderlyingOriginalNotionalPercentageOutstandingField is a PERCENTAGE field +type UnderlyingOriginalNotionalPercentageOutstandingField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingOriginalNotionalPercentageOutstanding (1456) +func (f UnderlyingOriginalNotionalPercentageOutstandingField) Tag() quickfix.Tag { + return tag.UnderlyingOriginalNotionalPercentageOutstanding +} + +//NewUnderlyingOriginalNotionalPercentageOutstanding returns a new UnderlyingOriginalNotionalPercentageOutstandingField initialized with val +func NewUnderlyingOriginalNotionalPercentageOutstanding(val float64) UnderlyingOriginalNotionalPercentageOutstandingField { + return UnderlyingOriginalNotionalPercentageOutstandingField{quickfix.FIXFloat(val)} +} + +//UnderlyingPayAmountField is a AMT field +type UnderlyingPayAmountField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingPayAmount (985) +func (f UnderlyingPayAmountField) Tag() quickfix.Tag { return tag.UnderlyingPayAmount } + +//NewUnderlyingPayAmount returns a new UnderlyingPayAmountField initialized with val +func NewUnderlyingPayAmount(val float64) UnderlyingPayAmountField { + return UnderlyingPayAmountField{quickfix.FIXFloat(val)} +} + +//UnderlyingPriceDeterminationMethodField is a INT field +type UnderlyingPriceDeterminationMethodField struct{ quickfix.FIXInt } + +//Tag returns tag.UnderlyingPriceDeterminationMethod (1481) +func (f UnderlyingPriceDeterminationMethodField) Tag() quickfix.Tag { + return tag.UnderlyingPriceDeterminationMethod +} + +//NewUnderlyingPriceDeterminationMethod returns a new UnderlyingPriceDeterminationMethodField initialized with val +func NewUnderlyingPriceDeterminationMethod(val int) UnderlyingPriceDeterminationMethodField { + return UnderlyingPriceDeterminationMethodField{quickfix.FIXInt(val)} +} + +//UnderlyingPriceUnitOfMeasureField is a STRING field +type UnderlyingPriceUnitOfMeasureField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingPriceUnitOfMeasure (1424) +func (f UnderlyingPriceUnitOfMeasureField) Tag() quickfix.Tag { return tag.UnderlyingPriceUnitOfMeasure } + +//NewUnderlyingPriceUnitOfMeasure returns a new UnderlyingPriceUnitOfMeasureField initialized with val +func NewUnderlyingPriceUnitOfMeasure(val string) UnderlyingPriceUnitOfMeasureField { + return UnderlyingPriceUnitOfMeasureField{quickfix.FIXString(val)} +} + +//UnderlyingPriceUnitOfMeasureQtyField is a QTY field +type UnderlyingPriceUnitOfMeasureQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingPriceUnitOfMeasureQty (1425) +func (f UnderlyingPriceUnitOfMeasureQtyField) Tag() quickfix.Tag { + return tag.UnderlyingPriceUnitOfMeasureQty +} + +//NewUnderlyingPriceUnitOfMeasureQty returns a new UnderlyingPriceUnitOfMeasureQtyField initialized with val +func NewUnderlyingPriceUnitOfMeasureQty(val float64) UnderlyingPriceUnitOfMeasureQtyField { + return UnderlyingPriceUnitOfMeasureQtyField{quickfix.FIXFloat(val)} +} + +//UnderlyingProductField is a INT field +type UnderlyingProductField struct{ quickfix.FIXInt } + +//Tag returns tag.UnderlyingProduct (462) +func (f UnderlyingProductField) Tag() quickfix.Tag { return tag.UnderlyingProduct } + +//NewUnderlyingProduct returns a new UnderlyingProductField initialized with val +func NewUnderlyingProduct(val int) UnderlyingProductField { + return UnderlyingProductField{quickfix.FIXInt(val)} +} + +//UnderlyingPutOrCallField is a INT field +type UnderlyingPutOrCallField struct{ quickfix.FIXInt } + +//Tag returns tag.UnderlyingPutOrCall (315) +func (f UnderlyingPutOrCallField) Tag() quickfix.Tag { return tag.UnderlyingPutOrCall } + +//NewUnderlyingPutOrCall returns a new UnderlyingPutOrCallField initialized with val +func NewUnderlyingPutOrCall(val int) UnderlyingPutOrCallField { + return UnderlyingPutOrCallField{quickfix.FIXInt(val)} +} + +//UnderlyingPxField is a PRICE field +type UnderlyingPxField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingPx (810) +func (f UnderlyingPxField) Tag() quickfix.Tag { return tag.UnderlyingPx } + +//NewUnderlyingPx returns a new UnderlyingPxField initialized with val +func NewUnderlyingPx(val float64) UnderlyingPxField { + return UnderlyingPxField{quickfix.FIXFloat(val)} +} + +//UnderlyingQtyField is a QTY field +type UnderlyingQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingQty (879) +func (f UnderlyingQtyField) Tag() quickfix.Tag { return tag.UnderlyingQty } + +//NewUnderlyingQty returns a new UnderlyingQtyField initialized with val +func NewUnderlyingQty(val float64) UnderlyingQtyField { + return UnderlyingQtyField{quickfix.FIXFloat(val)} +} + +//UnderlyingRedemptionDateField is a LOCALMKTDATE field +type UnderlyingRedemptionDateField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingRedemptionDate (247) +func (f UnderlyingRedemptionDateField) Tag() quickfix.Tag { return tag.UnderlyingRedemptionDate } + +//NewUnderlyingRedemptionDate returns a new UnderlyingRedemptionDateField initialized with val +func NewUnderlyingRedemptionDate(val string) UnderlyingRedemptionDateField { + return UnderlyingRedemptionDateField{quickfix.FIXString(val)} +} + +//UnderlyingRepoCollateralSecurityTypeField is a INT field +type UnderlyingRepoCollateralSecurityTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.UnderlyingRepoCollateralSecurityType (243) +func (f UnderlyingRepoCollateralSecurityTypeField) Tag() quickfix.Tag { + return tag.UnderlyingRepoCollateralSecurityType +} + +//NewUnderlyingRepoCollateralSecurityType returns a new UnderlyingRepoCollateralSecurityTypeField initialized with val +func NewUnderlyingRepoCollateralSecurityType(val int) UnderlyingRepoCollateralSecurityTypeField { + return UnderlyingRepoCollateralSecurityTypeField{quickfix.FIXInt(val)} +} + +//UnderlyingRepurchaseRateField is a PERCENTAGE field +type UnderlyingRepurchaseRateField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingRepurchaseRate (245) +func (f UnderlyingRepurchaseRateField) Tag() quickfix.Tag { return tag.UnderlyingRepurchaseRate } + +//NewUnderlyingRepurchaseRate returns a new UnderlyingRepurchaseRateField initialized with val +func NewUnderlyingRepurchaseRate(val float64) UnderlyingRepurchaseRateField { + return UnderlyingRepurchaseRateField{quickfix.FIXFloat(val)} +} + +//UnderlyingRepurchaseTermField is a INT field +type UnderlyingRepurchaseTermField struct{ quickfix.FIXInt } + +//Tag returns tag.UnderlyingRepurchaseTerm (244) +func (f UnderlyingRepurchaseTermField) Tag() quickfix.Tag { return tag.UnderlyingRepurchaseTerm } + +//NewUnderlyingRepurchaseTerm returns a new UnderlyingRepurchaseTermField initialized with val +func NewUnderlyingRepurchaseTerm(val int) UnderlyingRepurchaseTermField { + return UnderlyingRepurchaseTermField{quickfix.FIXInt(val)} +} + +//UnderlyingRestructuringTypeField is a STRING field +type UnderlyingRestructuringTypeField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingRestructuringType (1453) +func (f UnderlyingRestructuringTypeField) Tag() quickfix.Tag { return tag.UnderlyingRestructuringType } + +//NewUnderlyingRestructuringType returns a new UnderlyingRestructuringTypeField initialized with val +func NewUnderlyingRestructuringType(val string) UnderlyingRestructuringTypeField { + return UnderlyingRestructuringTypeField{quickfix.FIXString(val)} +} + +//UnderlyingSecurityAltIDField is a STRING field +type UnderlyingSecurityAltIDField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingSecurityAltID (458) +func (f UnderlyingSecurityAltIDField) Tag() quickfix.Tag { return tag.UnderlyingSecurityAltID } + +//NewUnderlyingSecurityAltID returns a new UnderlyingSecurityAltIDField initialized with val +func NewUnderlyingSecurityAltID(val string) UnderlyingSecurityAltIDField { + return UnderlyingSecurityAltIDField{quickfix.FIXString(val)} +} + +//UnderlyingSecurityAltIDSourceField is a STRING field +type UnderlyingSecurityAltIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingSecurityAltIDSource (459) +func (f UnderlyingSecurityAltIDSourceField) Tag() quickfix.Tag { + return tag.UnderlyingSecurityAltIDSource +} + +//NewUnderlyingSecurityAltIDSource returns a new UnderlyingSecurityAltIDSourceField initialized with val +func NewUnderlyingSecurityAltIDSource(val string) UnderlyingSecurityAltIDSourceField { + return UnderlyingSecurityAltIDSourceField{quickfix.FIXString(val)} +} + +//UnderlyingSecurityDescField is a STRING field +type UnderlyingSecurityDescField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingSecurityDesc (307) +func (f UnderlyingSecurityDescField) Tag() quickfix.Tag { return tag.UnderlyingSecurityDesc } + +//NewUnderlyingSecurityDesc returns a new UnderlyingSecurityDescField initialized with val +func NewUnderlyingSecurityDesc(val string) UnderlyingSecurityDescField { + return UnderlyingSecurityDescField{quickfix.FIXString(val)} +} + +//UnderlyingSecurityExchangeField is a EXCHANGE field +type UnderlyingSecurityExchangeField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingSecurityExchange (308) +func (f UnderlyingSecurityExchangeField) Tag() quickfix.Tag { return tag.UnderlyingSecurityExchange } + +//NewUnderlyingSecurityExchange returns a new UnderlyingSecurityExchangeField initialized with val +func NewUnderlyingSecurityExchange(val string) UnderlyingSecurityExchangeField { + return UnderlyingSecurityExchangeField{quickfix.FIXString(val)} +} + +//UnderlyingSecurityIDField is a STRING field +type UnderlyingSecurityIDField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingSecurityID (309) +func (f UnderlyingSecurityIDField) Tag() quickfix.Tag { return tag.UnderlyingSecurityID } + +//NewUnderlyingSecurityID returns a new UnderlyingSecurityIDField initialized with val +func NewUnderlyingSecurityID(val string) UnderlyingSecurityIDField { + return UnderlyingSecurityIDField{quickfix.FIXString(val)} +} + +//UnderlyingSecurityIDSourceField is a STRING field +type UnderlyingSecurityIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingSecurityIDSource (305) +func (f UnderlyingSecurityIDSourceField) Tag() quickfix.Tag { return tag.UnderlyingSecurityIDSource } + +//NewUnderlyingSecurityIDSource returns a new UnderlyingSecurityIDSourceField initialized with val +func NewUnderlyingSecurityIDSource(val string) UnderlyingSecurityIDSourceField { + return UnderlyingSecurityIDSourceField{quickfix.FIXString(val)} +} + +//UnderlyingSecuritySubTypeField is a STRING field +type UnderlyingSecuritySubTypeField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingSecuritySubType (763) +func (f UnderlyingSecuritySubTypeField) Tag() quickfix.Tag { return tag.UnderlyingSecuritySubType } + +//NewUnderlyingSecuritySubType returns a new UnderlyingSecuritySubTypeField initialized with val +func NewUnderlyingSecuritySubType(val string) UnderlyingSecuritySubTypeField { + return UnderlyingSecuritySubTypeField{quickfix.FIXString(val)} +} + +//UnderlyingSecurityTypeField is a STRING field +type UnderlyingSecurityTypeField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingSecurityType (310) +func (f UnderlyingSecurityTypeField) Tag() quickfix.Tag { return tag.UnderlyingSecurityType } + +//NewUnderlyingSecurityType returns a new UnderlyingSecurityTypeField initialized with val +func NewUnderlyingSecurityType(val string) UnderlyingSecurityTypeField { + return UnderlyingSecurityTypeField{quickfix.FIXString(val)} +} + +//UnderlyingSeniorityField is a STRING field +type UnderlyingSeniorityField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingSeniority (1454) +func (f UnderlyingSeniorityField) Tag() quickfix.Tag { return tag.UnderlyingSeniority } + +//NewUnderlyingSeniority returns a new UnderlyingSeniorityField initialized with val +func NewUnderlyingSeniority(val string) UnderlyingSeniorityField { + return UnderlyingSeniorityField{quickfix.FIXString(val)} +} + +//UnderlyingSettlMethodField is a STRING field +type UnderlyingSettlMethodField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingSettlMethod (1039) +func (f UnderlyingSettlMethodField) Tag() quickfix.Tag { return tag.UnderlyingSettlMethod } + +//NewUnderlyingSettlMethod returns a new UnderlyingSettlMethodField initialized with val +func NewUnderlyingSettlMethod(val string) UnderlyingSettlMethodField { + return UnderlyingSettlMethodField{quickfix.FIXString(val)} +} + +//UnderlyingSettlPriceField is a PRICE field +type UnderlyingSettlPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingSettlPrice (732) +func (f UnderlyingSettlPriceField) Tag() quickfix.Tag { return tag.UnderlyingSettlPrice } + +//NewUnderlyingSettlPrice returns a new UnderlyingSettlPriceField initialized with val +func NewUnderlyingSettlPrice(val float64) UnderlyingSettlPriceField { + return UnderlyingSettlPriceField{quickfix.FIXFloat(val)} +} + +//UnderlyingSettlPriceTypeField is a INT field +type UnderlyingSettlPriceTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.UnderlyingSettlPriceType (733) +func (f UnderlyingSettlPriceTypeField) Tag() quickfix.Tag { return tag.UnderlyingSettlPriceType } + +//NewUnderlyingSettlPriceType returns a new UnderlyingSettlPriceTypeField initialized with val +func NewUnderlyingSettlPriceType(val int) UnderlyingSettlPriceTypeField { + return UnderlyingSettlPriceTypeField{quickfix.FIXInt(val)} +} + +//UnderlyingSettlementDateField is a LOCALMKTDATE field +type UnderlyingSettlementDateField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingSettlementDate (987) +func (f UnderlyingSettlementDateField) Tag() quickfix.Tag { return tag.UnderlyingSettlementDate } + +//NewUnderlyingSettlementDate returns a new UnderlyingSettlementDateField initialized with val +func NewUnderlyingSettlementDate(val string) UnderlyingSettlementDateField { + return UnderlyingSettlementDateField{quickfix.FIXString(val)} +} + +//UnderlyingSettlementStatusField is a STRING field +type UnderlyingSettlementStatusField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingSettlementStatus (988) +func (f UnderlyingSettlementStatusField) Tag() quickfix.Tag { return tag.UnderlyingSettlementStatus } + +//NewUnderlyingSettlementStatus returns a new UnderlyingSettlementStatusField initialized with val +func NewUnderlyingSettlementStatus(val string) UnderlyingSettlementStatusField { + return UnderlyingSettlementStatusField{quickfix.FIXString(val)} +} + +//UnderlyingSettlementTypeField is a INT field +type UnderlyingSettlementTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.UnderlyingSettlementType (975) +func (f UnderlyingSettlementTypeField) Tag() quickfix.Tag { return tag.UnderlyingSettlementType } + +//NewUnderlyingSettlementType returns a new UnderlyingSettlementTypeField initialized with val +func NewUnderlyingSettlementType(val int) UnderlyingSettlementTypeField { + return UnderlyingSettlementTypeField{quickfix.FIXInt(val)} +} + +//UnderlyingStartValueField is a AMT field +type UnderlyingStartValueField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingStartValue (884) +func (f UnderlyingStartValueField) Tag() quickfix.Tag { return tag.UnderlyingStartValue } + +//NewUnderlyingStartValue returns a new UnderlyingStartValueField initialized with val +func NewUnderlyingStartValue(val float64) UnderlyingStartValueField { + return UnderlyingStartValueField{quickfix.FIXFloat(val)} +} + +//UnderlyingStateOrProvinceOfIssueField is a STRING field +type UnderlyingStateOrProvinceOfIssueField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingStateOrProvinceOfIssue (593) +func (f UnderlyingStateOrProvinceOfIssueField) Tag() quickfix.Tag { + return tag.UnderlyingStateOrProvinceOfIssue +} + +//NewUnderlyingStateOrProvinceOfIssue returns a new UnderlyingStateOrProvinceOfIssueField initialized with val +func NewUnderlyingStateOrProvinceOfIssue(val string) UnderlyingStateOrProvinceOfIssueField { + return UnderlyingStateOrProvinceOfIssueField{quickfix.FIXString(val)} +} + +//UnderlyingStipTypeField is a STRING field +type UnderlyingStipTypeField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingStipType (888) +func (f UnderlyingStipTypeField) Tag() quickfix.Tag { return tag.UnderlyingStipType } + +//NewUnderlyingStipType returns a new UnderlyingStipTypeField initialized with val +func NewUnderlyingStipType(val string) UnderlyingStipTypeField { + return UnderlyingStipTypeField{quickfix.FIXString(val)} +} + +//UnderlyingStipValueField is a STRING field +type UnderlyingStipValueField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingStipValue (889) +func (f UnderlyingStipValueField) Tag() quickfix.Tag { return tag.UnderlyingStipValue } + +//NewUnderlyingStipValue returns a new UnderlyingStipValueField initialized with val +func NewUnderlyingStipValue(val string) UnderlyingStipValueField { + return UnderlyingStipValueField{quickfix.FIXString(val)} +} + +//UnderlyingStrikeCurrencyField is a CURRENCY field +type UnderlyingStrikeCurrencyField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingStrikeCurrency (941) +func (f UnderlyingStrikeCurrencyField) Tag() quickfix.Tag { return tag.UnderlyingStrikeCurrency } + +//NewUnderlyingStrikeCurrency returns a new UnderlyingStrikeCurrencyField initialized with val +func NewUnderlyingStrikeCurrency(val string) UnderlyingStrikeCurrencyField { + return UnderlyingStrikeCurrencyField{quickfix.FIXString(val)} +} + +//UnderlyingStrikePriceField is a PRICE field +type UnderlyingStrikePriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingStrikePrice (316) +func (f UnderlyingStrikePriceField) Tag() quickfix.Tag { return tag.UnderlyingStrikePrice } + +//NewUnderlyingStrikePrice returns a new UnderlyingStrikePriceField initialized with val +func NewUnderlyingStrikePrice(val float64) UnderlyingStrikePriceField { + return UnderlyingStrikePriceField{quickfix.FIXFloat(val)} +} + +//UnderlyingSymbolField is a STRING field +type UnderlyingSymbolField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingSymbol (311) +func (f UnderlyingSymbolField) Tag() quickfix.Tag { return tag.UnderlyingSymbol } + +//NewUnderlyingSymbol returns a new UnderlyingSymbolField initialized with val +func NewUnderlyingSymbol(val string) UnderlyingSymbolField { + return UnderlyingSymbolField{quickfix.FIXString(val)} +} + +//UnderlyingSymbolSfxField is a STRING field +type UnderlyingSymbolSfxField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingSymbolSfx (312) +func (f UnderlyingSymbolSfxField) Tag() quickfix.Tag { return tag.UnderlyingSymbolSfx } + +//NewUnderlyingSymbolSfx returns a new UnderlyingSymbolSfxField initialized with val +func NewUnderlyingSymbolSfx(val string) UnderlyingSymbolSfxField { + return UnderlyingSymbolSfxField{quickfix.FIXString(val)} +} + +//UnderlyingTimeUnitField is a STRING field +type UnderlyingTimeUnitField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingTimeUnit (1000) +func (f UnderlyingTimeUnitField) Tag() quickfix.Tag { return tag.UnderlyingTimeUnit } + +//NewUnderlyingTimeUnit returns a new UnderlyingTimeUnitField initialized with val +func NewUnderlyingTimeUnit(val string) UnderlyingTimeUnitField { + return UnderlyingTimeUnitField{quickfix.FIXString(val)} +} + +//UnderlyingTradingSessionIDField is a STRING field +type UnderlyingTradingSessionIDField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingTradingSessionID (822) +func (f UnderlyingTradingSessionIDField) Tag() quickfix.Tag { return tag.UnderlyingTradingSessionID } + +//NewUnderlyingTradingSessionID returns a new UnderlyingTradingSessionIDField initialized with val +func NewUnderlyingTradingSessionID(val string) UnderlyingTradingSessionIDField { + return UnderlyingTradingSessionIDField{quickfix.FIXString(val)} +} + +//UnderlyingTradingSessionSubIDField is a STRING field +type UnderlyingTradingSessionSubIDField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingTradingSessionSubID (823) +func (f UnderlyingTradingSessionSubIDField) Tag() quickfix.Tag { + return tag.UnderlyingTradingSessionSubID +} + +//NewUnderlyingTradingSessionSubID returns a new UnderlyingTradingSessionSubIDField initialized with val +func NewUnderlyingTradingSessionSubID(val string) UnderlyingTradingSessionSubIDField { + return UnderlyingTradingSessionSubIDField{quickfix.FIXString(val)} +} + +//UnderlyingUnitOfMeasureField is a STRING field +type UnderlyingUnitOfMeasureField struct{ quickfix.FIXString } + +//Tag returns tag.UnderlyingUnitOfMeasure (998) +func (f UnderlyingUnitOfMeasureField) Tag() quickfix.Tag { return tag.UnderlyingUnitOfMeasure } + +//NewUnderlyingUnitOfMeasure returns a new UnderlyingUnitOfMeasureField initialized with val +func NewUnderlyingUnitOfMeasure(val string) UnderlyingUnitOfMeasureField { + return UnderlyingUnitOfMeasureField{quickfix.FIXString(val)} +} + +//UnderlyingUnitOfMeasureQtyField is a QTY field +type UnderlyingUnitOfMeasureQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnderlyingUnitOfMeasureQty (1423) +func (f UnderlyingUnitOfMeasureQtyField) Tag() quickfix.Tag { return tag.UnderlyingUnitOfMeasureQty } + +//NewUnderlyingUnitOfMeasureQty returns a new UnderlyingUnitOfMeasureQtyField initialized with val +func NewUnderlyingUnitOfMeasureQty(val float64) UnderlyingUnitOfMeasureQtyField { + return UnderlyingUnitOfMeasureQtyField{quickfix.FIXFloat(val)} +} + +//UndlyInstrumentPartyIDField is a STRING field +type UndlyInstrumentPartyIDField struct{ quickfix.FIXString } + +//Tag returns tag.UndlyInstrumentPartyID (1059) +func (f UndlyInstrumentPartyIDField) Tag() quickfix.Tag { return tag.UndlyInstrumentPartyID } + +//NewUndlyInstrumentPartyID returns a new UndlyInstrumentPartyIDField initialized with val +func NewUndlyInstrumentPartyID(val string) UndlyInstrumentPartyIDField { + return UndlyInstrumentPartyIDField{quickfix.FIXString(val)} +} + +//UndlyInstrumentPartyIDSourceField is a CHAR field +type UndlyInstrumentPartyIDSourceField struct{ quickfix.FIXString } + +//Tag returns tag.UndlyInstrumentPartyIDSource (1060) +func (f UndlyInstrumentPartyIDSourceField) Tag() quickfix.Tag { return tag.UndlyInstrumentPartyIDSource } + +//NewUndlyInstrumentPartyIDSource returns a new UndlyInstrumentPartyIDSourceField initialized with val +func NewUndlyInstrumentPartyIDSource(val string) UndlyInstrumentPartyIDSourceField { + return UndlyInstrumentPartyIDSourceField{quickfix.FIXString(val)} +} + +//UndlyInstrumentPartyRoleField is a INT field +type UndlyInstrumentPartyRoleField struct{ quickfix.FIXInt } + +//Tag returns tag.UndlyInstrumentPartyRole (1061) +func (f UndlyInstrumentPartyRoleField) Tag() quickfix.Tag { return tag.UndlyInstrumentPartyRole } + +//NewUndlyInstrumentPartyRole returns a new UndlyInstrumentPartyRoleField initialized with val +func NewUndlyInstrumentPartyRole(val int) UndlyInstrumentPartyRoleField { + return UndlyInstrumentPartyRoleField{quickfix.FIXInt(val)} +} + +//UndlyInstrumentPartySubIDField is a STRING field +type UndlyInstrumentPartySubIDField struct{ quickfix.FIXString } + +//Tag returns tag.UndlyInstrumentPartySubID (1063) +func (f UndlyInstrumentPartySubIDField) Tag() quickfix.Tag { return tag.UndlyInstrumentPartySubID } + +//NewUndlyInstrumentPartySubID returns a new UndlyInstrumentPartySubIDField initialized with val +func NewUndlyInstrumentPartySubID(val string) UndlyInstrumentPartySubIDField { + return UndlyInstrumentPartySubIDField{quickfix.FIXString(val)} +} + +//UndlyInstrumentPartySubIDTypeField is a INT field +type UndlyInstrumentPartySubIDTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.UndlyInstrumentPartySubIDType (1064) +func (f UndlyInstrumentPartySubIDTypeField) Tag() quickfix.Tag { + return tag.UndlyInstrumentPartySubIDType +} + +//NewUndlyInstrumentPartySubIDType returns a new UndlyInstrumentPartySubIDTypeField initialized with val +func NewUndlyInstrumentPartySubIDType(val int) UndlyInstrumentPartySubIDTypeField { + return UndlyInstrumentPartySubIDTypeField{quickfix.FIXInt(val)} +} + +//UnitOfMeasureField is a STRING field +type UnitOfMeasureField struct{ quickfix.FIXString } + +//Tag returns tag.UnitOfMeasure (996) +func (f UnitOfMeasureField) Tag() quickfix.Tag { return tag.UnitOfMeasure } + +//NewUnitOfMeasure returns a new UnitOfMeasureField initialized with val +func NewUnitOfMeasure(val string) UnitOfMeasureField { + return UnitOfMeasureField{quickfix.FIXString(val)} +} + +//UnitOfMeasureQtyField is a QTY field +type UnitOfMeasureQtyField struct{ quickfix.FIXFloat } + +//Tag returns tag.UnitOfMeasureQty (1147) +func (f UnitOfMeasureQtyField) Tag() quickfix.Tag { return tag.UnitOfMeasureQty } + +//NewUnitOfMeasureQty returns a new UnitOfMeasureQtyField initialized with val +func NewUnitOfMeasureQty(val float64) UnitOfMeasureQtyField { + return UnitOfMeasureQtyField{quickfix.FIXFloat(val)} +} + +//UnsolicitedIndicatorField is a BOOLEAN field +type UnsolicitedIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.UnsolicitedIndicator (325) +func (f UnsolicitedIndicatorField) Tag() quickfix.Tag { return tag.UnsolicitedIndicator } + +//NewUnsolicitedIndicator returns a new UnsolicitedIndicatorField initialized with val +func NewUnsolicitedIndicator(val bool) UnsolicitedIndicatorField { + return UnsolicitedIndicatorField{quickfix.FIXBoolean(val)} +} + +//UrgencyField is a CHAR field +type UrgencyField struct{ quickfix.FIXString } + +//Tag returns tag.Urgency (61) +func (f UrgencyField) Tag() quickfix.Tag { return tag.Urgency } + +//NewUrgency returns a new UrgencyField initialized with val +func NewUrgency(val string) UrgencyField { + return UrgencyField{quickfix.FIXString(val)} +} + +//UserRequestIDField is a STRING field +type UserRequestIDField struct{ quickfix.FIXString } + +//Tag returns tag.UserRequestID (923) +func (f UserRequestIDField) Tag() quickfix.Tag { return tag.UserRequestID } + +//NewUserRequestID returns a new UserRequestIDField initialized with val +func NewUserRequestID(val string) UserRequestIDField { + return UserRequestIDField{quickfix.FIXString(val)} +} + +//UserRequestTypeField is a INT field +type UserRequestTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.UserRequestType (924) +func (f UserRequestTypeField) Tag() quickfix.Tag { return tag.UserRequestType } + +//NewUserRequestType returns a new UserRequestTypeField initialized with val +func NewUserRequestType(val int) UserRequestTypeField { + return UserRequestTypeField{quickfix.FIXInt(val)} +} + +//UserStatusField is a INT field +type UserStatusField struct{ quickfix.FIXInt } + +//Tag returns tag.UserStatus (926) +func (f UserStatusField) Tag() quickfix.Tag { return tag.UserStatus } + +//NewUserStatus returns a new UserStatusField initialized with val +func NewUserStatus(val int) UserStatusField { + return UserStatusField{quickfix.FIXInt(val)} +} + +//UserStatusTextField is a STRING field +type UserStatusTextField struct{ quickfix.FIXString } + +//Tag returns tag.UserStatusText (927) +func (f UserStatusTextField) Tag() quickfix.Tag { return tag.UserStatusText } + +//NewUserStatusText returns a new UserStatusTextField initialized with val +func NewUserStatusText(val string) UserStatusTextField { + return UserStatusTextField{quickfix.FIXString(val)} +} + +//UsernameField is a STRING field +type UsernameField struct{ quickfix.FIXString } + +//Tag returns tag.Username (553) +func (f UsernameField) Tag() quickfix.Tag { return tag.Username } + +//NewUsername returns a new UsernameField initialized with val +func NewUsername(val string) UsernameField { + return UsernameField{quickfix.FIXString(val)} +} + +//ValidUntilTimeField is a UTCTIMESTAMP field +type ValidUntilTimeField struct{ quickfix.FIXUTCTimestamp } + +//Tag returns tag.ValidUntilTime (62) +func (f ValidUntilTimeField) Tag() quickfix.Tag { return tag.ValidUntilTime } + +//NewValidUntilTime returns a new ValidUntilTimeField initialized with val +func NewValidUntilTime(val time.Time) ValidUntilTimeField { + return ValidUntilTimeField{quickfix.FIXUTCTimestamp{Time: val}} +} + +//NewValidUntilTimeNoMillis returns a new ValidUntilTimeField initialized with val without millisecs +func NewValidUntilTimeNoMillis(val time.Time) ValidUntilTimeField { + return ValidUntilTimeField{quickfix.FIXUTCTimestamp{Time: val, NoMillis: true}} +} + +//ValuationMethodField is a STRING field +type ValuationMethodField struct{ quickfix.FIXString } + +//Tag returns tag.ValuationMethod (1197) +func (f ValuationMethodField) Tag() quickfix.Tag { return tag.ValuationMethod } + +//NewValuationMethod returns a new ValuationMethodField initialized with val +func NewValuationMethod(val string) ValuationMethodField { + return ValuationMethodField{quickfix.FIXString(val)} +} + +//ValueOfFuturesField is a AMT field +type ValueOfFuturesField struct{ quickfix.FIXFloat } + +//Tag returns tag.ValueOfFutures (408) +func (f ValueOfFuturesField) Tag() quickfix.Tag { return tag.ValueOfFutures } + +//NewValueOfFutures returns a new ValueOfFuturesField initialized with val +func NewValueOfFutures(val float64) ValueOfFuturesField { + return ValueOfFuturesField{quickfix.FIXFloat(val)} +} + +//VenueTypeField is a CHAR field +type VenueTypeField struct{ quickfix.FIXString } + +//Tag returns tag.VenueType (1430) +func (f VenueTypeField) Tag() quickfix.Tag { return tag.VenueType } + +//NewVenueType returns a new VenueTypeField initialized with val +func NewVenueType(val string) VenueTypeField { + return VenueTypeField{quickfix.FIXString(val)} +} + +//VolatilityField is a FLOAT field +type VolatilityField struct{ quickfix.FIXFloat } + +//Tag returns tag.Volatility (1188) +func (f VolatilityField) Tag() quickfix.Tag { return tag.Volatility } + +//NewVolatility returns a new VolatilityField initialized with val +func NewVolatility(val float64) VolatilityField { + return VolatilityField{quickfix.FIXFloat(val)} +} + +//WaveNoField is a STRING field +type WaveNoField struct{ quickfix.FIXString } + +//Tag returns tag.WaveNo (105) +func (f WaveNoField) Tag() quickfix.Tag { return tag.WaveNo } + +//NewWaveNo returns a new WaveNoField initialized with val +func NewWaveNo(val string) WaveNoField { + return WaveNoField{quickfix.FIXString(val)} +} + +//WorkingIndicatorField is a BOOLEAN field +type WorkingIndicatorField struct{ quickfix.FIXBoolean } + +//Tag returns tag.WorkingIndicator (636) +func (f WorkingIndicatorField) Tag() quickfix.Tag { return tag.WorkingIndicator } + +//NewWorkingIndicator returns a new WorkingIndicatorField initialized with val +func NewWorkingIndicator(val bool) WorkingIndicatorField { + return WorkingIndicatorField{quickfix.FIXBoolean(val)} +} + +//WtAverageLiquidityField is a PERCENTAGE field +type WtAverageLiquidityField struct{ quickfix.FIXFloat } + +//Tag returns tag.WtAverageLiquidity (410) +func (f WtAverageLiquidityField) Tag() quickfix.Tag { return tag.WtAverageLiquidity } + +//NewWtAverageLiquidity returns a new WtAverageLiquidityField initialized with val +func NewWtAverageLiquidity(val float64) WtAverageLiquidityField { + return WtAverageLiquidityField{quickfix.FIXFloat(val)} +} + +//XmlDataField is a DATA field +type XmlDataField struct{ quickfix.FIXString } + +//Tag returns tag.XmlData (213) +func (f XmlDataField) Tag() quickfix.Tag { return tag.XmlData } + +//NewXmlData returns a new XmlDataField initialized with val +func NewXmlData(val string) XmlDataField { + return XmlDataField{quickfix.FIXString(val)} +} + +//XmlDataLenField is a LENGTH field +type XmlDataLenField struct{ quickfix.FIXInt } + +//Tag returns tag.XmlDataLen (212) +func (f XmlDataLenField) Tag() quickfix.Tag { return tag.XmlDataLen } + +//NewXmlDataLen returns a new XmlDataLenField initialized with val +func NewXmlDataLen(val int) XmlDataLenField { + return XmlDataLenField{quickfix.FIXInt(val)} +} + +//YieldField is a PERCENTAGE field +type YieldField struct{ quickfix.FIXFloat } + +//Tag returns tag.Yield (236) +func (f YieldField) Tag() quickfix.Tag { return tag.Yield } + +//NewYield returns a new YieldField initialized with val +func NewYield(val float64) YieldField { + return YieldField{quickfix.FIXFloat(val)} +} + +//YieldCalcDateField is a LOCALMKTDATE field +type YieldCalcDateField struct{ quickfix.FIXString } + +//Tag returns tag.YieldCalcDate (701) +func (f YieldCalcDateField) Tag() quickfix.Tag { return tag.YieldCalcDate } + +//NewYieldCalcDate returns a new YieldCalcDateField initialized with val +func NewYieldCalcDate(val string) YieldCalcDateField { + return YieldCalcDateField{quickfix.FIXString(val)} +} + +//YieldRedemptionDateField is a LOCALMKTDATE field +type YieldRedemptionDateField struct{ quickfix.FIXString } + +//Tag returns tag.YieldRedemptionDate (696) +func (f YieldRedemptionDateField) Tag() quickfix.Tag { return tag.YieldRedemptionDate } + +//NewYieldRedemptionDate returns a new YieldRedemptionDateField initialized with val +func NewYieldRedemptionDate(val string) YieldRedemptionDateField { + return YieldRedemptionDateField{quickfix.FIXString(val)} +} + +//YieldRedemptionPriceField is a PRICE field +type YieldRedemptionPriceField struct{ quickfix.FIXFloat } + +//Tag returns tag.YieldRedemptionPrice (697) +func (f YieldRedemptionPriceField) Tag() quickfix.Tag { return tag.YieldRedemptionPrice } + +//NewYieldRedemptionPrice returns a new YieldRedemptionPriceField initialized with val +func NewYieldRedemptionPrice(val float64) YieldRedemptionPriceField { + return YieldRedemptionPriceField{quickfix.FIXFloat(val)} +} + +//YieldRedemptionPriceTypeField is a INT field +type YieldRedemptionPriceTypeField struct{ quickfix.FIXInt } + +//Tag returns tag.YieldRedemptionPriceType (698) +func (f YieldRedemptionPriceTypeField) Tag() quickfix.Tag { return tag.YieldRedemptionPriceType } + +//NewYieldRedemptionPriceType returns a new YieldRedemptionPriceTypeField initialized with val +func NewYieldRedemptionPriceType(val int) YieldRedemptionPriceTypeField { + return YieldRedemptionPriceTypeField{quickfix.FIXInt(val)} +} + +//YieldTypeField is a STRING field +type YieldTypeField struct{ quickfix.FIXString } + +//Tag returns tag.YieldType (235) +func (f YieldTypeField) Tag() quickfix.Tag { return tag.YieldType } + +//NewYieldType returns a new YieldTypeField initialized with val +func NewYieldType(val string) YieldTypeField { + return YieldTypeField{quickfix.FIXString(val)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/field_map.go b/vendor/github.com/quickfixgo/quickfix/field_map.go new file mode 100644 index 0000000..0a95f2b --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/field_map.go @@ -0,0 +1,185 @@ +package quickfix + +import ( + "bytes" + "sort" +) + +//FieldMap is a collection of fix fields that make up a fix message. +type FieldMap struct { + tagLookup map[Tag]TagValues + tagOrder +} + +// tagOrder true if tag i should occur before tag j +type tagOrder func(i, j Tag) bool + +type tagSort struct { + tags []Tag + compare tagOrder +} + +func (t tagSort) Len() int { return len(t.tags) } +func (t tagSort) Swap(i, j int) { t.tags[i], t.tags[j] = t.tags[j], t.tags[i] } +func (t tagSort) Less(i, j int) bool { return t.compare(t.tags[i], t.tags[j]) } + +// ascending tags +func normalFieldOrder(i, j Tag) bool { return i < j } + +func (m *FieldMap) init() { + m.initWithOrdering(normalFieldOrder) +} + +func (m *FieldMap) initWithOrdering(ordering tagOrder) { + m.tagLookup = make(map[Tag]TagValues) + m.tagOrder = ordering +} + +//Tags returns all of the Field Tags in this FieldMap +func (m FieldMap) Tags() []Tag { + tags := make([]Tag, 0, len(m.tagLookup)) + for t := range m.tagLookup { + tags = append(tags, t) + } + + return tags +} + +//Get parses out a field in this FieldMap. Returned reject may indicate the field is not present, or the field value is invalid. +func (m FieldMap) Get(parser Field) MessageRejectError { + return m.GetField(parser.Tag(), parser) +} + +//Has returns true if the Tag is present in this FieldMap +func (m FieldMap) Has(tag Tag) bool { + _, ok := m.tagLookup[tag] + return ok +} + +//GetField parses of a field with Tag tag. Returned reject may indicate the field is not present, or the field value is invalid. +func (m FieldMap) GetField(tag Tag, parser FieldValueReader) MessageRejectError { + tagValues, ok := m.tagLookup[tag] + if !ok { + return ConditionallyRequiredFieldMissing(tag) + } + + if err := parser.Read(tagValues[0].value); err != nil { + return IncorrectDataFormatForValue(tag) + } + + return nil +} + +//GetInt is a GetField wrapper for int fields +func (m FieldMap) GetInt(tag Tag) (int, MessageRejectError) { + var val FIXInt + if err := m.GetField(tag, &val); err != nil { + return 0, err + } + return int(val), nil +} + +//GetString is a GetField wrapper for string fields +func (m FieldMap) GetString(tag Tag) (string, MessageRejectError) { + var val FIXString + if err := m.GetField(tag, &val); err != nil { + return "", err + } + return string(val), nil +} + +//GetGroup is a Get function specific to Group Fields. +func (m FieldMap) GetGroup(parser FieldGroupReader) MessageRejectError { + tagValues, ok := m.tagLookup[parser.Tag()] + if !ok { + return ConditionallyRequiredFieldMissing(parser.Tag()) + } + + if _, err := parser.Read(tagValues); err != nil { + if msgRejErr, ok := err.(MessageRejectError); ok { + return msgRejErr + } + return IncorrectDataFormatForValue(parser.Tag()) + } + + return nil +} + +//SetField sets the field with Tag tag +func (m FieldMap) SetField(tag Tag, field FieldValueWriter) FieldMap { + tValues := make(TagValues, 1) + tValues[0].init(tag, field.Write()) + m.tagLookup[tag] = tValues + return m +} + +//Clear purges all fields from field map +func (m *FieldMap) Clear() { + m.tagLookup = make(map[Tag]TagValues) +} + +//Set is a setter for fields +func (m FieldMap) Set(field FieldWriter) FieldMap { + tValues := make(TagValues, 1) + tValues[0].init(field.Tag(), field.Write()) + m.tagLookup[field.Tag()] = tValues + return m +} + +//SetGroup is a setter specific to group fields +func (m FieldMap) SetGroup(field FieldGroupWriter) FieldMap { + m.tagLookup[field.Tag()] = field.Write() + return m +} + +func (m FieldMap) sortedTags() []Tag { + sortedTags := make([]Tag, len(m.tagLookup)) + for tag := range m.tagLookup { + sortedTags = append(sortedTags, tag) + } + + sort.Sort(tagSort{sortedTags, m.tagOrder}) + return sortedTags +} + +func (m FieldMap) write(buffer *bytes.Buffer) { + tags := m.sortedTags() + + for _, tag := range tags { + if fields, ok := m.tagLookup[tag]; ok { + for _, tv := range fields { + buffer.Write(tv.bytes) + } + } + } +} + +func (m FieldMap) total() int { + total := 0 + for _, fields := range m.tagLookup { + for _, tv := range fields { + switch tv.tag { + case tagCheckSum: //tag does not contribute to total + default: + total += tv.total() + } + } + } + + return total +} + +func (m FieldMap) length() int { + length := 0 + for _, fields := range m.tagLookup { + for _, tv := range fields { + switch tv.tag { + case tagBeginString, tagBodyLength, tagCheckSum: //tags do not contribute to length + default: + length += tv.length() + } + } + } + + return length +} diff --git a/vendor/github.com/quickfixgo/quickfix/file_log.go b/vendor/github.com/quickfixgo/quickfix/file_log.go new file mode 100644 index 0000000..536792a --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/file_log.go @@ -0,0 +1,102 @@ +package quickfix + +import ( + "fmt" + "log" + "os" + "path" + + "github.com/quickfixgo/quickfix/config" +) + +type fileLog struct { + eventLogger *log.Logger + messageLogger *log.Logger +} + +func (l fileLog) OnIncoming(msg string) { + l.messageLogger.Print(msg) +} + +func (l fileLog) OnOutgoing(msg string) { + l.messageLogger.Print(msg) +} + +func (l fileLog) OnEvent(msg string) { + l.eventLogger.Print(msg) +} + +func (l fileLog) OnEventf(format string, v ...interface{}) { + l.eventLogger.Printf(format, v...) +} + +type fileLogFactory struct { + globalLogPath string + sessionLogPaths map[SessionID]string +} + +//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 NewFileLogFactory(settings *Settings) (LogFactory, error) { + logFactory := fileLogFactory{} + + var err error + if logFactory.globalLogPath, err = settings.GlobalSettings().Setting(config.FileLogPath); err != nil { + return logFactory, err + } + + logFactory.sessionLogPaths = make(map[SessionID]string) + + for sid, sessionSettings := range settings.SessionSettings() { + logPath, err := sessionSettings.Setting(config.FileLogPath) + if err != nil { + return logFactory, err + } + logFactory.sessionLogPaths[sid] = logPath + } + + return logFactory, nil +} + +func newFileLog(prefix string, logPath string) (fileLog, error) { + l := fileLog{} + + eventLogName := path.Join(logPath, prefix+".event.current.log") + messageLogName := path.Join(logPath, prefix+".messages.current.log") + + if err := os.MkdirAll(logPath, os.ModePerm); err != nil { + return l, err + } + + fileFlags := os.O_RDWR | os.O_CREATE | os.O_APPEND + eventFile, err := os.OpenFile(eventLogName, fileFlags, os.ModePerm) + if err != nil { + return l, err + } + + messageFile, err := os.OpenFile(messageLogName, fileFlags, os.ModePerm) + if err != nil { + return l, err + } + + logFlag := log.Ldate | log.Ltime | log.Lmicroseconds | log.LUTC + l.eventLogger = log.New(eventFile, "", logFlag) + l.messageLogger = log.New(messageFile, "", logFlag) + + return l, nil +} + +func (f fileLogFactory) Create() (Log, error) { + return newFileLog("GLOBAL", f.globalLogPath) +} + +func (f fileLogFactory) CreateSessionLog(sessionID SessionID) (Log, error) { + logPath, ok := f.sessionLogPaths[sessionID] + + if !ok { + return nil, fmt.Errorf("logger not defined for %v", sessionID) + } + + prefix := sessionIDFilenamePrefix(sessionID) + return newFileLog(prefix, logPath) +} diff --git a/vendor/github.com/quickfixgo/quickfix/filestore.go b/vendor/github.com/quickfixgo/quickfix/filestore.go new file mode 100644 index 0000000..aa2f7cd --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/filestore.go @@ -0,0 +1,331 @@ +package quickfix + +import ( + "fmt" + "io/ioutil" + "os" + "path" + "strconv" + "time" + + "github.com/quickfixgo/quickfix/config" +) + +type msgDef struct { + offset int64 + size int +} + +type fileStoreFactory struct { + settings *Settings +} + +type fileStore struct { + sessionID SessionID + cache *memoryStore + offsets map[int]msgDef + bodyFname string + headerFname string + sessionFname string + senderSeqNumsFname string + targetSeqNumsFname string + bodyFile *os.File + headerFile *os.File + sessionFile *os.File + senderSeqNumsFile *os.File + targetSeqNumsFile *os.File +} + +// NewFileStoreFactory returns a file-based implementation of MessageStoreFactory +func NewFileStoreFactory(settings *Settings) MessageStoreFactory { + return fileStoreFactory{settings: settings} +} + +// Create creates a new FileStore implementation of the MessageStore interface +func (f fileStoreFactory) Create(sessionID SessionID) (msgStore MessageStore, err error) { + sessionSettings, ok := f.settings.SessionSettings()[sessionID] + if !ok { + return nil, fmt.Errorf("unknown session: %v", sessionID) + } + dirname, err := sessionSettings.Setting(config.FileStorePath) + if err != nil { + return nil, err + } + return newFileStore(sessionID, dirname) +} + +func newFileStore(sessionID SessionID, dirname string) (*fileStore, error) { + if err := os.MkdirAll(dirname, os.ModePerm); err != nil { + return nil, err + } + + sessionPrefix := sessionIDFilenamePrefix(sessionID) + + store := &fileStore{ + sessionID: sessionID, + cache: &memoryStore{}, + offsets: make(map[int]msgDef), + bodyFname: path.Join(dirname, fmt.Sprintf("%s.%s", sessionPrefix, "body")), + headerFname: path.Join(dirname, fmt.Sprintf("%s.%s", sessionPrefix, "header")), + sessionFname: path.Join(dirname, fmt.Sprintf("%s.%s", sessionPrefix, "session")), + senderSeqNumsFname: path.Join(dirname, fmt.Sprintf("%s.%s", sessionPrefix, "senderseqnums")), + targetSeqNumsFname: path.Join(dirname, fmt.Sprintf("%s.%s", sessionPrefix, "targetseqnums")), + } + + if err := store.Refresh(); err != nil { + return nil, err + } + + return store, nil +} + +// Reset deletes the store files and sets the seqnums back to 1 +func (store *fileStore) Reset() error { + store.cache.Reset() + if err := store.Close(); err != nil { + return err + } + if err := removeFile(store.bodyFname); err != nil { + return err + } + if err := removeFile(store.headerFname); err != nil { + return err + } + if err := removeFile(store.sessionFname); err != nil { + return err + } + if err := removeFile(store.senderSeqNumsFname); err != nil { + return err + } + if err := removeFile(store.targetSeqNumsFname); err != nil { + return err + } + return store.Refresh() +} + +// Refresh closes the store files and then reloads from them +func (store *fileStore) Refresh() (err error) { + store.cache.Reset() + + if err = store.Close(); err != nil { + return err + } + + creationTimePopulated, err := store.populateCache() + if err != nil { + return err + } + + if store.bodyFile, err = openOrCreateFile(store.bodyFname, 0660); err != nil { + return err + } + if store.headerFile, err = openOrCreateFile(store.headerFname, 0660); err != nil { + return err + } + if store.sessionFile, err = openOrCreateFile(store.sessionFname, 0660); err != nil { + return err + } + if store.senderSeqNumsFile, err = openOrCreateFile(store.senderSeqNumsFname, 0660); err != nil { + return err + } + if store.targetSeqNumsFile, err = openOrCreateFile(store.targetSeqNumsFname, 0660); err != nil { + return err + } + + if !creationTimePopulated { + if err := store.setSession(); err != nil { + return err + } + } + + store.SetNextSenderMsgSeqNum(store.NextSenderMsgSeqNum()) + store.SetNextTargetMsgSeqNum(store.NextTargetMsgSeqNum()) + return nil +} + +func (store *fileStore) populateCache() (creationTimePopulated bool, err error) { + if tmpHeaderFile, err := os.Open(store.headerFname); err == nil { + defer tmpHeaderFile.Close() + for { + var seqNum, size int + var offset int64 + if cnt, err := fmt.Fscanf(tmpHeaderFile, "%d,%d,%d\n", &seqNum, &offset, &size); err != nil || cnt != 3 { + break + } + store.offsets[seqNum] = msgDef{offset: offset, size: size} + } + } + + if timeBytes, err := ioutil.ReadFile(store.sessionFname); err == nil { + var ctime time.Time + if err := ctime.UnmarshalText(timeBytes); err == nil { + store.cache.creationTime = ctime + creationTimePopulated = true + } + } + + if senderSeqNumBytes, err := ioutil.ReadFile(store.senderSeqNumsFname); err == nil { + if senderSeqNum, err := strconv.Atoi(string(senderSeqNumBytes)); err == nil { + store.cache.SetNextSenderMsgSeqNum(senderSeqNum) + } + } + + if targetSeqNumBytes, err := ioutil.ReadFile(store.targetSeqNumsFname); err == nil { + if targetSeqNum, err := strconv.Atoi(string(targetSeqNumBytes)); err == nil { + store.cache.SetNextTargetMsgSeqNum(targetSeqNum) + } + } + + return creationTimePopulated, nil +} + +func (store *fileStore) setSession() error { + if _, err := store.sessionFile.Seek(0, os.SEEK_SET); err != nil { + return fmt.Errorf("unable to rewind file: %s: %s", store.sessionFname, err.Error()) + } + + data, err := store.cache.CreationTime().MarshalText() + if err != nil { + return fmt.Errorf("unable to marshal session time to file: %s: %s", store.sessionFname, err.Error()) + } + if _, err := store.sessionFile.Write(data); err != nil { + return fmt.Errorf("unable to write to file: %s: %s", store.sessionFname, err.Error()) + } + if err := store.sessionFile.Sync(); err != nil { + return fmt.Errorf("unable to flush file: %s: %s", store.sessionFname, err.Error()) + } + return nil +} + +func (store *fileStore) setSeqNum(f *os.File, seqNum int) error { + if _, err := f.Seek(0, os.SEEK_SET); err != nil { + return fmt.Errorf("unable to rewind file: %s: %s", f.Name(), err.Error()) + } + if _, err := fmt.Fprintf(f, "%019d", seqNum); err != nil { + return fmt.Errorf("unable to write to file: %s: %s", f.Name(), err.Error()) + } + if err := f.Sync(); err != nil { + return fmt.Errorf("unable to flush file: %s: %s", f.Name(), err.Error()) + } + return nil +} + +// NextSenderMsgSeqNum returns the next MsgSeqNum that will be sent +func (store *fileStore) NextSenderMsgSeqNum() int { + return store.cache.NextSenderMsgSeqNum() +} + +// NextTargetMsgSeqNum returns the next MsgSeqNum that should be received +func (store *fileStore) NextTargetMsgSeqNum() int { + return store.cache.NextTargetMsgSeqNum() +} + +// SetNextSenderMsgSeqNum sets the next MsgSeqNum that will be sent +func (store *fileStore) SetNextSenderMsgSeqNum(next int) error { + store.cache.SetNextSenderMsgSeqNum(next) + return store.setSeqNum(store.senderSeqNumsFile, next) +} + +// SetNextTargetMsgSeqNum sets the next MsgSeqNum that should be received +func (store *fileStore) SetNextTargetMsgSeqNum(next int) error { + store.cache.SetNextTargetMsgSeqNum(next) + return store.setSeqNum(store.targetSeqNumsFile, next) +} + +// IncrNextSenderMsgSeqNum increments the next MsgSeqNum that will be sent +func (store *fileStore) IncrNextSenderMsgSeqNum() error { + store.cache.IncrNextSenderMsgSeqNum() + return store.setSeqNum(store.senderSeqNumsFile, store.cache.NextSenderMsgSeqNum()) +} + +// IncrNextTargetMsgSeqNum increments the next MsgSeqNum that should be received +func (store *fileStore) IncrNextTargetMsgSeqNum() error { + store.cache.IncrNextTargetMsgSeqNum() + return store.setSeqNum(store.targetSeqNumsFile, store.cache.NextTargetMsgSeqNum()) +} + +// CreationTime returns the creation time of the store +func (store *fileStore) CreationTime() time.Time { + return store.cache.CreationTime() +} + +func (store *fileStore) SaveMessage(seqNum int, msg []byte) error { + offset, err := store.bodyFile.Seek(0, os.SEEK_END) + if err != nil { + return fmt.Errorf("unable to seek to end of file: %s: %s", store.bodyFname, err.Error()) + } + if _, err := store.headerFile.Seek(0, os.SEEK_END); err != nil { + return fmt.Errorf("unable to seek to end of file: %s: %s", store.headerFname, err.Error()) + } + if _, err := fmt.Fprintf(store.headerFile, "%d,%d,%d\n", seqNum, offset, len(msg)); err != nil { + return fmt.Errorf("unable to write to file: %s: %s", store.headerFname, err.Error()) + } + + store.offsets[seqNum] = msgDef{offset: offset, size: len(msg)} + + if _, err := store.bodyFile.Write(msg); err != nil { + return fmt.Errorf("unable to write to file: %s: %s", store.bodyFname, err.Error()) + } + if err := store.bodyFile.Sync(); err != nil { + return fmt.Errorf("unable to flush file: %s: %s", store.bodyFname, err.Error()) + } + if err := store.headerFile.Sync(); err != nil { + return fmt.Errorf("unable to flush file: %s: %s", store.headerFname, err.Error()) + } + return nil +} + +func (store *fileStore) getMessage(seqNum int) (msg []byte, found bool, err error) { + msgInfo, found := store.offsets[seqNum] + if !found { + return + } + + msg = make([]byte, msgInfo.size) + if _, err = store.bodyFile.ReadAt(msg, msgInfo.offset); err != nil { + return nil, true, fmt.Errorf("unable to read from file: %s: %s", store.bodyFname, err.Error()) + } + + return msg, true, nil +} + +func (store *fileStore) GetMessages(beginSeqNum, endSeqNum int) ([][]byte, error) { + var msgs [][]byte + for seqNum := beginSeqNum; seqNum <= endSeqNum; seqNum++ { + m, found, err := store.getMessage(seqNum) + if err != nil { + return nil, err + } + if found { + msgs = append(msgs, m) + } + } + return msgs, nil +} + +// Close closes the store's files +func (store *fileStore) Close() error { + if err := closeFile(store.bodyFile); err != nil { + return err + } + if err := closeFile(store.headerFile); err != nil { + return err + } + if err := closeFile(store.sessionFile); err != nil { + return err + } + if err := closeFile(store.senderSeqNumsFile); err != nil { + return err + } + if err := closeFile(store.targetSeqNumsFile); err != nil { + return err + } + + store.bodyFile = nil + store.headerFile = nil + store.sessionFile = nil + store.senderSeqNumsFile = nil + store.targetSeqNumsFile = nil + + return nil +} diff --git a/vendor/github.com/quickfixgo/quickfix/fileutil.go b/vendor/github.com/quickfixgo/quickfix/fileutil.go new file mode 100644 index 0000000..9fa11c9 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fileutil.go @@ -0,0 +1,62 @@ +package quickfix + +import ( + "fmt" + "os" + "strings" +) + +func sessionIDFilenamePrefix(s SessionID) string { + sender := []string{s.SenderCompID} + if s.SenderSubID != "" { + sender = append(sender, s.SenderSubID) + } + if s.SenderLocationID != "" { + sender = append(sender, s.SenderLocationID) + } + + target := []string{s.TargetCompID} + if s.TargetSubID != "" { + target = append(target, s.TargetSubID) + } + if s.TargetLocationID != "" { + target = append(target, s.TargetLocationID) + } + + fname := []string{s.BeginString, strings.Join(sender, "_"), strings.Join(target, "_")} + if s.Qualifier != "" { + fname = append(fname, s.Qualifier) + } + return strings.Join(fname, "-") +} + +// closeFile behaves like Close, except that no error is returned if the file does not exist +func closeFile(f *os.File) error { + if f != nil { + if err := f.Close(); err != nil { + if !os.IsNotExist(err) { + return err + } + } + } + return nil +} + +// removeFile behaves like os.Remove, except that no error is returned if the file does not exist +func removeFile(fname string) error { + err := os.Remove(fname) + if (err != nil) && !os.IsNotExist(err) { + return err + } + return nil +} + +// openOrCreateFile opens a file for reading and writing, creating it if necessary +func openOrCreateFile(fname string, perm os.FileMode) (f *os.File, err error) { + if f, err = os.OpenFile(fname, os.O_RDWR, perm); err != nil { + if f, err = os.OpenFile(fname, os.O_RDWR|os.O_CREATE, perm); err != nil { + return nil, fmt.Errorf("error opening or creating file: %s: %s", fname, err.Error()) + } + } + return f, nil +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix40/executionreport/ExecutionReport.generated.go b/vendor/github.com/quickfixgo/quickfix/fix40/executionreport/ExecutionReport.generated.go new file mode 100644 index 0000000..7f0e54d --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix40/executionreport/ExecutionReport.generated.go @@ -0,0 +1,869 @@ +package executionreport + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fix40" + "github.com/quickfixgo/quickfix/tag" +) + +//ExecutionReport is the fix40 ExecutionReport type, MsgType = 8 +type ExecutionReport struct { + fix40.Header + quickfix.Body + fix40.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a ExecutionReport from a quickfix.Message instance +func FromMessage(m quickfix.Message) ExecutionReport { + return ExecutionReport{ + Header: fix40.Header{Header: m.Header}, + Body: m.Body, + Trailer: fix40.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m ExecutionReport) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a ExecutionReport initialized with the required fields for ExecutionReport +func New(orderid field.OrderIDField, execid field.ExecIDField, exectranstype field.ExecTransTypeField, ordstatus field.OrdStatusField, symbol field.SymbolField, side field.SideField, orderqty field.OrderQtyField, lastshares field.LastSharesField, lastpx field.LastPxField, cumqty field.CumQtyField, avgpx field.AvgPxField) (m ExecutionReport) { + m.Header = fix40.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("8")) + m.Set(orderid) + m.Set(execid) + m.Set(exectranstype) + m.Set(ordstatus) + m.Set(symbol) + m.Set(side) + m.Set(orderqty) + m.Set(lastshares) + m.Set(lastpx) + m.Set(cumqty) + m.Set(avgpx) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg ExecutionReport, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "FIX.4.0", "8", r +} + +//SetAccount sets Account, Tag 1 +func (m ExecutionReport) SetAccount(v string) { + m.Set(field.NewAccount(v)) +} + +//SetAvgPx sets AvgPx, Tag 6 +func (m ExecutionReport) SetAvgPx(v float64) { + m.Set(field.NewAvgPx(v)) +} + +//SetClOrdID sets ClOrdID, Tag 11 +func (m ExecutionReport) SetClOrdID(v string) { + m.Set(field.NewClOrdID(v)) +} + +//SetCommission sets Commission, Tag 12 +func (m ExecutionReport) SetCommission(v float64) { + m.Set(field.NewCommission(v)) +} + +//SetCommType sets CommType, Tag 13 +func (m ExecutionReport) SetCommType(v string) { + m.Set(field.NewCommType(v)) +} + +//SetCumQty sets CumQty, Tag 14 +func (m ExecutionReport) SetCumQty(v float64) { + m.Set(field.NewCumQty(v)) +} + +//SetCurrency sets Currency, Tag 15 +func (m ExecutionReport) SetCurrency(v string) { + m.Set(field.NewCurrency(v)) +} + +//SetExecID sets ExecID, Tag 17 +func (m ExecutionReport) SetExecID(v string) { + m.Set(field.NewExecID(v)) +} + +//SetExecInst sets ExecInst, Tag 18 +func (m ExecutionReport) SetExecInst(v string) { + m.Set(field.NewExecInst(v)) +} + +//SetExecRefID sets ExecRefID, Tag 19 +func (m ExecutionReport) SetExecRefID(v string) { + m.Set(field.NewExecRefID(v)) +} + +//SetExecTransType sets ExecTransType, Tag 20 +func (m ExecutionReport) SetExecTransType(v string) { + m.Set(field.NewExecTransType(v)) +} + +//SetIDSource sets IDSource, Tag 22 +func (m ExecutionReport) SetIDSource(v string) { + m.Set(field.NewIDSource(v)) +} + +//SetLastCapacity sets LastCapacity, Tag 29 +func (m ExecutionReport) SetLastCapacity(v string) { + m.Set(field.NewLastCapacity(v)) +} + +//SetLastMkt sets LastMkt, Tag 30 +func (m ExecutionReport) SetLastMkt(v string) { + m.Set(field.NewLastMkt(v)) +} + +//SetLastPx sets LastPx, Tag 31 +func (m ExecutionReport) SetLastPx(v float64) { + m.Set(field.NewLastPx(v)) +} + +//SetLastShares sets LastShares, Tag 32 +func (m ExecutionReport) SetLastShares(v float64) { + m.Set(field.NewLastShares(v)) +} + +//SetOrderID sets OrderID, Tag 37 +func (m ExecutionReport) SetOrderID(v string) { + m.Set(field.NewOrderID(v)) +} + +//SetOrderQty sets OrderQty, Tag 38 +func (m ExecutionReport) SetOrderQty(v float64) { + m.Set(field.NewOrderQty(v)) +} + +//SetOrdStatus sets OrdStatus, Tag 39 +func (m ExecutionReport) SetOrdStatus(v string) { + m.Set(field.NewOrdStatus(v)) +} + +//SetOrdType sets OrdType, Tag 40 +func (m ExecutionReport) SetOrdType(v string) { + m.Set(field.NewOrdType(v)) +} + +//SetPrice sets Price, Tag 44 +func (m ExecutionReport) SetPrice(v float64) { + m.Set(field.NewPrice(v)) +} + +//SetRule80A sets Rule80A, Tag 47 +func (m ExecutionReport) SetRule80A(v string) { + m.Set(field.NewRule80A(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m ExecutionReport) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSide sets Side, Tag 54 +func (m ExecutionReport) SetSide(v string) { + m.Set(field.NewSide(v)) +} + +//SetSymbol sets Symbol, Tag 55 +func (m ExecutionReport) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetText sets Text, Tag 58 +func (m ExecutionReport) SetText(v string) { + m.Set(field.NewText(v)) +} + +//SetTimeInForce sets TimeInForce, Tag 59 +func (m ExecutionReport) SetTimeInForce(v string) { + m.Set(field.NewTimeInForce(v)) +} + +//SetTransactTime sets TransactTime, Tag 60 +func (m ExecutionReport) SetTransactTime(v time.Time) { + m.Set(field.NewTransactTime(v)) +} + +//SetSettlmntTyp sets SettlmntTyp, Tag 63 +func (m ExecutionReport) SetSettlmntTyp(v string) { + m.Set(field.NewSettlmntTyp(v)) +} + +//SetFutSettDate sets FutSettDate, Tag 64 +func (m ExecutionReport) SetFutSettDate(v string) { + m.Set(field.NewFutSettDate(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m ExecutionReport) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetListID sets ListID, Tag 66 +func (m ExecutionReport) SetListID(v string) { + m.Set(field.NewListID(v)) +} + +//SetTradeDate sets TradeDate, Tag 75 +func (m ExecutionReport) SetTradeDate(v string) { + m.Set(field.NewTradeDate(v)) +} + +//SetExecBroker sets ExecBroker, Tag 76 +func (m ExecutionReport) SetExecBroker(v string) { + m.Set(field.NewExecBroker(v)) +} + +//SetStopPx sets StopPx, Tag 99 +func (m ExecutionReport) SetStopPx(v float64) { + m.Set(field.NewStopPx(v)) +} + +//SetOrdRejReason sets OrdRejReason, Tag 103 +func (m ExecutionReport) SetOrdRejReason(v int) { + m.Set(field.NewOrdRejReason(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m ExecutionReport) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m ExecutionReport) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetClientID sets ClientID, Tag 109 +func (m ExecutionReport) SetClientID(v string) { + m.Set(field.NewClientID(v)) +} + +//SetReportToExch sets ReportToExch, Tag 113 +func (m ExecutionReport) SetReportToExch(v bool) { + m.Set(field.NewReportToExch(v)) +} + +//SetNetMoney sets NetMoney, Tag 118 +func (m ExecutionReport) SetNetMoney(v float64) { + m.Set(field.NewNetMoney(v)) +} + +//SetSettlCurrAmt sets SettlCurrAmt, Tag 119 +func (m ExecutionReport) SetSettlCurrAmt(v float64) { + m.Set(field.NewSettlCurrAmt(v)) +} + +//SetSettlCurrency sets SettlCurrency, Tag 120 +func (m ExecutionReport) SetSettlCurrency(v string) { + m.Set(field.NewSettlCurrency(v)) +} + +//SetExpireTime sets ExpireTime, Tag 126 +func (m ExecutionReport) SetExpireTime(v time.Time) { + m.Set(field.NewExpireTime(v)) +} + +//SetNoMiscFees sets NoMiscFees, Tag 136 +func (m ExecutionReport) SetNoMiscFees(f NoMiscFeesRepeatingGroup) { + m.SetGroup(f) +} + +//GetAccount gets Account, Tag 1 +func (m ExecutionReport) GetAccount() (f field.AccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAvgPx gets AvgPx, Tag 6 +func (m ExecutionReport) GetAvgPx() (f field.AvgPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdID gets ClOrdID, Tag 11 +func (m ExecutionReport) GetClOrdID() (f field.ClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommission gets Commission, Tag 12 +func (m ExecutionReport) GetCommission() (f field.CommissionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommType gets CommType, Tag 13 +func (m ExecutionReport) GetCommType() (f field.CommTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCumQty gets CumQty, Tag 14 +func (m ExecutionReport) GetCumQty() (f field.CumQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCurrency gets Currency, Tag 15 +func (m ExecutionReport) GetCurrency() (f field.CurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecID gets ExecID, Tag 17 +func (m ExecutionReport) GetExecID() (f field.ExecIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecInst gets ExecInst, Tag 18 +func (m ExecutionReport) GetExecInst() (f field.ExecInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecRefID gets ExecRefID, Tag 19 +func (m ExecutionReport) GetExecRefID() (f field.ExecRefIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecTransType gets ExecTransType, Tag 20 +func (m ExecutionReport) GetExecTransType() (f field.ExecTransTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIDSource gets IDSource, Tag 22 +func (m ExecutionReport) GetIDSource() (f field.IDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastCapacity gets LastCapacity, Tag 29 +func (m ExecutionReport) GetLastCapacity() (f field.LastCapacityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastMkt gets LastMkt, Tag 30 +func (m ExecutionReport) GetLastMkt() (f field.LastMktField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastPx gets LastPx, Tag 31 +func (m ExecutionReport) GetLastPx() (f field.LastPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastShares gets LastShares, Tag 32 +func (m ExecutionReport) GetLastShares() (f field.LastSharesField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderID gets OrderID, Tag 37 +func (m ExecutionReport) GetOrderID() (f field.OrderIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty gets OrderQty, Tag 38 +func (m ExecutionReport) GetOrderQty() (f field.OrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdStatus gets OrdStatus, Tag 39 +func (m ExecutionReport) GetOrdStatus() (f field.OrdStatusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdType gets OrdType, Tag 40 +func (m ExecutionReport) GetOrdType() (f field.OrdTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrice gets Price, Tag 44 +func (m ExecutionReport) GetPrice() (f field.PriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRule80A gets Rule80A, Tag 47 +func (m ExecutionReport) GetRule80A() (f field.Rule80AField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m ExecutionReport) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSide gets Side, Tag 54 +func (m ExecutionReport) GetSide() (f field.SideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbol gets Symbol, Tag 55 +func (m ExecutionReport) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetText gets Text, Tag 58 +func (m ExecutionReport) GetText() (f field.TextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTimeInForce gets TimeInForce, Tag 59 +func (m ExecutionReport) GetTimeInForce() (f field.TimeInForceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTransactTime gets TransactTime, Tag 60 +func (m ExecutionReport) GetTransactTime() (f field.TransactTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlmntTyp gets SettlmntTyp, Tag 63 +func (m ExecutionReport) GetSettlmntTyp() (f field.SettlmntTypField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFutSettDate gets FutSettDate, Tag 64 +func (m ExecutionReport) GetFutSettDate() (f field.FutSettDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m ExecutionReport) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetListID gets ListID, Tag 66 +func (m ExecutionReport) GetListID() (f field.ListIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradeDate gets TradeDate, Tag 75 +func (m ExecutionReport) GetTradeDate() (f field.TradeDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecBroker gets ExecBroker, Tag 76 +func (m ExecutionReport) GetExecBroker() (f field.ExecBrokerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStopPx gets StopPx, Tag 99 +func (m ExecutionReport) GetStopPx() (f field.StopPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdRejReason gets OrdRejReason, Tag 103 +func (m ExecutionReport) GetOrdRejReason() (f field.OrdRejReasonField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m ExecutionReport) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m ExecutionReport) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClientID gets ClientID, Tag 109 +func (m ExecutionReport) GetClientID() (f field.ClientIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetReportToExch gets ReportToExch, Tag 113 +func (m ExecutionReport) GetReportToExch() (f field.ReportToExchField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNetMoney gets NetMoney, Tag 118 +func (m ExecutionReport) GetNetMoney() (f field.NetMoneyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrAmt gets SettlCurrAmt, Tag 119 +func (m ExecutionReport) GetSettlCurrAmt() (f field.SettlCurrAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrency gets SettlCurrency, Tag 120 +func (m ExecutionReport) GetSettlCurrency() (f field.SettlCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireTime gets ExpireTime, Tag 126 +func (m ExecutionReport) GetExpireTime() (f field.ExpireTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoMiscFees gets NoMiscFees, Tag 136 +func (m ExecutionReport) GetNoMiscFees() (NoMiscFeesRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoMiscFeesRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasAccount returns true if Account is present, Tag 1 +func (m ExecutionReport) HasAccount() bool { + return m.Has(tag.Account) +} + +//HasAvgPx returns true if AvgPx is present, Tag 6 +func (m ExecutionReport) HasAvgPx() bool { + return m.Has(tag.AvgPx) +} + +//HasClOrdID returns true if ClOrdID is present, Tag 11 +func (m ExecutionReport) HasClOrdID() bool { + return m.Has(tag.ClOrdID) +} + +//HasCommission returns true if Commission is present, Tag 12 +func (m ExecutionReport) HasCommission() bool { + return m.Has(tag.Commission) +} + +//HasCommType returns true if CommType is present, Tag 13 +func (m ExecutionReport) HasCommType() bool { + return m.Has(tag.CommType) +} + +//HasCumQty returns true if CumQty is present, Tag 14 +func (m ExecutionReport) HasCumQty() bool { + return m.Has(tag.CumQty) +} + +//HasCurrency returns true if Currency is present, Tag 15 +func (m ExecutionReport) HasCurrency() bool { + return m.Has(tag.Currency) +} + +//HasExecID returns true if ExecID is present, Tag 17 +func (m ExecutionReport) HasExecID() bool { + return m.Has(tag.ExecID) +} + +//HasExecInst returns true if ExecInst is present, Tag 18 +func (m ExecutionReport) HasExecInst() bool { + return m.Has(tag.ExecInst) +} + +//HasExecRefID returns true if ExecRefID is present, Tag 19 +func (m ExecutionReport) HasExecRefID() bool { + return m.Has(tag.ExecRefID) +} + +//HasExecTransType returns true if ExecTransType is present, Tag 20 +func (m ExecutionReport) HasExecTransType() bool { + return m.Has(tag.ExecTransType) +} + +//HasIDSource returns true if IDSource is present, Tag 22 +func (m ExecutionReport) HasIDSource() bool { + return m.Has(tag.IDSource) +} + +//HasLastCapacity returns true if LastCapacity is present, Tag 29 +func (m ExecutionReport) HasLastCapacity() bool { + return m.Has(tag.LastCapacity) +} + +//HasLastMkt returns true if LastMkt is present, Tag 30 +func (m ExecutionReport) HasLastMkt() bool { + return m.Has(tag.LastMkt) +} + +//HasLastPx returns true if LastPx is present, Tag 31 +func (m ExecutionReport) HasLastPx() bool { + return m.Has(tag.LastPx) +} + +//HasLastShares returns true if LastShares is present, Tag 32 +func (m ExecutionReport) HasLastShares() bool { + return m.Has(tag.LastShares) +} + +//HasOrderID returns true if OrderID is present, Tag 37 +func (m ExecutionReport) HasOrderID() bool { + return m.Has(tag.OrderID) +} + +//HasOrderQty returns true if OrderQty is present, Tag 38 +func (m ExecutionReport) HasOrderQty() bool { + return m.Has(tag.OrderQty) +} + +//HasOrdStatus returns true if OrdStatus is present, Tag 39 +func (m ExecutionReport) HasOrdStatus() bool { + return m.Has(tag.OrdStatus) +} + +//HasOrdType returns true if OrdType is present, Tag 40 +func (m ExecutionReport) HasOrdType() bool { + return m.Has(tag.OrdType) +} + +//HasPrice returns true if Price is present, Tag 44 +func (m ExecutionReport) HasPrice() bool { + return m.Has(tag.Price) +} + +//HasRule80A returns true if Rule80A is present, Tag 47 +func (m ExecutionReport) HasRule80A() bool { + return m.Has(tag.Rule80A) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m ExecutionReport) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSide returns true if Side is present, Tag 54 +func (m ExecutionReport) HasSide() bool { + return m.Has(tag.Side) +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m ExecutionReport) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasText returns true if Text is present, Tag 58 +func (m ExecutionReport) HasText() bool { + return m.Has(tag.Text) +} + +//HasTimeInForce returns true if TimeInForce is present, Tag 59 +func (m ExecutionReport) HasTimeInForce() bool { + return m.Has(tag.TimeInForce) +} + +//HasTransactTime returns true if TransactTime is present, Tag 60 +func (m ExecutionReport) HasTransactTime() bool { + return m.Has(tag.TransactTime) +} + +//HasSettlmntTyp returns true if SettlmntTyp is present, Tag 63 +func (m ExecutionReport) HasSettlmntTyp() bool { + return m.Has(tag.SettlmntTyp) +} + +//HasFutSettDate returns true if FutSettDate is present, Tag 64 +func (m ExecutionReport) HasFutSettDate() bool { + return m.Has(tag.FutSettDate) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m ExecutionReport) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasListID returns true if ListID is present, Tag 66 +func (m ExecutionReport) HasListID() bool { + return m.Has(tag.ListID) +} + +//HasTradeDate returns true if TradeDate is present, Tag 75 +func (m ExecutionReport) HasTradeDate() bool { + return m.Has(tag.TradeDate) +} + +//HasExecBroker returns true if ExecBroker is present, Tag 76 +func (m ExecutionReport) HasExecBroker() bool { + return m.Has(tag.ExecBroker) +} + +//HasStopPx returns true if StopPx is present, Tag 99 +func (m ExecutionReport) HasStopPx() bool { + return m.Has(tag.StopPx) +} + +//HasOrdRejReason returns true if OrdRejReason is present, Tag 103 +func (m ExecutionReport) HasOrdRejReason() bool { + return m.Has(tag.OrdRejReason) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m ExecutionReport) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m ExecutionReport) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasClientID returns true if ClientID is present, Tag 109 +func (m ExecutionReport) HasClientID() bool { + return m.Has(tag.ClientID) +} + +//HasReportToExch returns true if ReportToExch is present, Tag 113 +func (m ExecutionReport) HasReportToExch() bool { + return m.Has(tag.ReportToExch) +} + +//HasNetMoney returns true if NetMoney is present, Tag 118 +func (m ExecutionReport) HasNetMoney() bool { + return m.Has(tag.NetMoney) +} + +//HasSettlCurrAmt returns true if SettlCurrAmt is present, Tag 119 +func (m ExecutionReport) HasSettlCurrAmt() bool { + return m.Has(tag.SettlCurrAmt) +} + +//HasSettlCurrency returns true if SettlCurrency is present, Tag 120 +func (m ExecutionReport) HasSettlCurrency() bool { + return m.Has(tag.SettlCurrency) +} + +//HasExpireTime returns true if ExpireTime is present, Tag 126 +func (m ExecutionReport) HasExpireTime() bool { + return m.Has(tag.ExpireTime) +} + +//HasNoMiscFees returns true if NoMiscFees is present, Tag 136 +func (m ExecutionReport) HasNoMiscFees() bool { + return m.Has(tag.NoMiscFees) +} + +//NoMiscFees is a repeating group element, Tag 136 +type NoMiscFees struct { + quickfix.Group +} + +//SetMiscFeeAmt sets MiscFeeAmt, Tag 137 +func (m NoMiscFees) SetMiscFeeAmt(v float64) { + m.Set(field.NewMiscFeeAmt(v)) +} + +//SetMiscFeeCurr sets MiscFeeCurr, Tag 138 +func (m NoMiscFees) SetMiscFeeCurr(v string) { + m.Set(field.NewMiscFeeCurr(v)) +} + +//SetMiscFeeType sets MiscFeeType, Tag 139 +func (m NoMiscFees) SetMiscFeeType(v string) { + m.Set(field.NewMiscFeeType(v)) +} + +//GetMiscFeeAmt gets MiscFeeAmt, Tag 137 +func (m NoMiscFees) GetMiscFeeAmt() (f field.MiscFeeAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMiscFeeCurr gets MiscFeeCurr, Tag 138 +func (m NoMiscFees) GetMiscFeeCurr() (f field.MiscFeeCurrField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMiscFeeType gets MiscFeeType, Tag 139 +func (m NoMiscFees) GetMiscFeeType() (f field.MiscFeeTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasMiscFeeAmt returns true if MiscFeeAmt is present, Tag 137 +func (m NoMiscFees) HasMiscFeeAmt() bool { + return m.Has(tag.MiscFeeAmt) +} + +//HasMiscFeeCurr returns true if MiscFeeCurr is present, Tag 138 +func (m NoMiscFees) HasMiscFeeCurr() bool { + return m.Has(tag.MiscFeeCurr) +} + +//HasMiscFeeType returns true if MiscFeeType is present, Tag 139 +func (m NoMiscFees) HasMiscFeeType() bool { + return m.Has(tag.MiscFeeType) +} + +//NoMiscFeesRepeatingGroup is a repeating group, Tag 136 +type NoMiscFeesRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoMiscFeesRepeatingGroup returns an initialized, NoMiscFeesRepeatingGroup +func NewNoMiscFeesRepeatingGroup() NoMiscFeesRepeatingGroup { + return NoMiscFeesRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoMiscFees, + quickfix.GroupTemplate{quickfix.GroupElement(tag.MiscFeeAmt), quickfix.GroupElement(tag.MiscFeeCurr), quickfix.GroupElement(tag.MiscFeeType)})} +} + +//Add create and append a new NoMiscFees to this group +func (m NoMiscFeesRepeatingGroup) Add() NoMiscFees { + g := m.RepeatingGroup.Add() + return NoMiscFees{g} +} + +//Get returns the ith NoMiscFees in the NoMiscFeesRepeatinGroup +func (m NoMiscFeesRepeatingGroup) Get(i int) NoMiscFees { + return NoMiscFees{m.RepeatingGroup.Get(i)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix40/header.generated.go b/vendor/github.com/quickfixgo/quickfix/fix40/header.generated.go new file mode 100644 index 0000000..736a23a --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix40/header.generated.go @@ -0,0 +1,309 @@ +package fix40 + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/tag" +) + +//Header is the fix40 Header type +type Header struct { + quickfix.Header +} + +//NewHeader returns a new, initialized Header instance +func NewHeader() (h Header) { + h.Init() + h.SetBeginString("FIX.4.0") + return +} + +//SetBeginString sets BeginString, Tag 8 +func (h Header) SetBeginString(v string) { + h.Set(field.NewBeginString(v)) +} + +//SetBodyLength sets BodyLength, Tag 9 +func (h Header) SetBodyLength(v int) { + h.Set(field.NewBodyLength(v)) +} + +//SetMsgSeqNum sets MsgSeqNum, Tag 34 +func (h Header) SetMsgSeqNum(v int) { + h.Set(field.NewMsgSeqNum(v)) +} + +//SetMsgType sets MsgType, Tag 35 +func (h Header) SetMsgType(v string) { + h.Set(field.NewMsgType(v)) +} + +//SetPossDupFlag sets PossDupFlag, Tag 43 +func (h Header) SetPossDupFlag(v bool) { + h.Set(field.NewPossDupFlag(v)) +} + +//SetSenderCompID sets SenderCompID, Tag 49 +func (h Header) SetSenderCompID(v string) { + h.Set(field.NewSenderCompID(v)) +} + +//SetSenderSubID sets SenderSubID, Tag 50 +func (h Header) SetSenderSubID(v string) { + h.Set(field.NewSenderSubID(v)) +} + +//SetSendingTime sets SendingTime, Tag 52 +func (h Header) SetSendingTime(v time.Time) { + h.Set(field.NewSendingTime(v)) +} + +//SetTargetCompID sets TargetCompID, Tag 56 +func (h Header) SetTargetCompID(v string) { + h.Set(field.NewTargetCompID(v)) +} + +//SetTargetSubID sets TargetSubID, Tag 57 +func (h Header) SetTargetSubID(v string) { + h.Set(field.NewTargetSubID(v)) +} + +//SetSecureDataLen sets SecureDataLen, Tag 90 +func (h Header) SetSecureDataLen(v int) { + h.Set(field.NewSecureDataLen(v)) +} + +//SetSecureData sets SecureData, Tag 91 +func (h Header) SetSecureData(v string) { + h.Set(field.NewSecureData(v)) +} + +//SetPossResend sets PossResend, Tag 97 +func (h Header) SetPossResend(v bool) { + h.Set(field.NewPossResend(v)) +} + +//SetOnBehalfOfCompID sets OnBehalfOfCompID, Tag 115 +func (h Header) SetOnBehalfOfCompID(v string) { + h.Set(field.NewOnBehalfOfCompID(v)) +} + +//SetOnBehalfOfSubID sets OnBehalfOfSubID, Tag 116 +func (h Header) SetOnBehalfOfSubID(v string) { + h.Set(field.NewOnBehalfOfSubID(v)) +} + +//SetOrigSendingTime sets OrigSendingTime, Tag 122 +func (h Header) SetOrigSendingTime(v time.Time) { + h.Set(field.NewOrigSendingTime(v)) +} + +//SetDeliverToCompID sets DeliverToCompID, Tag 128 +func (h Header) SetDeliverToCompID(v string) { + h.Set(field.NewDeliverToCompID(v)) +} + +//SetDeliverToSubID sets DeliverToSubID, Tag 129 +func (h Header) SetDeliverToSubID(v string) { + h.Set(field.NewDeliverToSubID(v)) +} + +//GetBeginString gets BeginString, Tag 8 +func (h Header) GetBeginString() (f field.BeginStringField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetBodyLength gets BodyLength, Tag 9 +func (h Header) GetBodyLength() (f field.BodyLengthField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetMsgSeqNum gets MsgSeqNum, Tag 34 +func (h Header) GetMsgSeqNum() (f field.MsgSeqNumField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetMsgType gets MsgType, Tag 35 +func (h Header) GetMsgType() (f field.MsgTypeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetPossDupFlag gets PossDupFlag, Tag 43 +func (h Header) GetPossDupFlag() (f field.PossDupFlagField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSenderCompID gets SenderCompID, Tag 49 +func (h Header) GetSenderCompID() (f field.SenderCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSenderSubID gets SenderSubID, Tag 50 +func (h Header) GetSenderSubID() (f field.SenderSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSendingTime gets SendingTime, Tag 52 +func (h Header) GetSendingTime() (f field.SendingTimeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetTargetCompID gets TargetCompID, Tag 56 +func (h Header) GetTargetCompID() (f field.TargetCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetTargetSubID gets TargetSubID, Tag 57 +func (h Header) GetTargetSubID() (f field.TargetSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSecureDataLen gets SecureDataLen, Tag 90 +func (h Header) GetSecureDataLen() (f field.SecureDataLenField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSecureData gets SecureData, Tag 91 +func (h Header) GetSecureData() (f field.SecureDataField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetPossResend gets PossResend, Tag 97 +func (h Header) GetPossResend() (f field.PossResendField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOnBehalfOfCompID gets OnBehalfOfCompID, Tag 115 +func (h Header) GetOnBehalfOfCompID() (f field.OnBehalfOfCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOnBehalfOfSubID gets OnBehalfOfSubID, Tag 116 +func (h Header) GetOnBehalfOfSubID() (f field.OnBehalfOfSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOrigSendingTime gets OrigSendingTime, Tag 122 +func (h Header) GetOrigSendingTime() (f field.OrigSendingTimeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetDeliverToCompID gets DeliverToCompID, Tag 128 +func (h Header) GetDeliverToCompID() (f field.DeliverToCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetDeliverToSubID gets DeliverToSubID, Tag 129 +func (h Header) GetDeliverToSubID() (f field.DeliverToSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//HasBeginString returns true if BeginString is present, Tag 8 +func (h Header) HasBeginString() bool { + return h.Has(tag.BeginString) +} + +//HasBodyLength returns true if BodyLength is present, Tag 9 +func (h Header) HasBodyLength() bool { + return h.Has(tag.BodyLength) +} + +//HasMsgSeqNum returns true if MsgSeqNum is present, Tag 34 +func (h Header) HasMsgSeqNum() bool { + return h.Has(tag.MsgSeqNum) +} + +//HasMsgType returns true if MsgType is present, Tag 35 +func (h Header) HasMsgType() bool { + return h.Has(tag.MsgType) +} + +//HasPossDupFlag returns true if PossDupFlag is present, Tag 43 +func (h Header) HasPossDupFlag() bool { + return h.Has(tag.PossDupFlag) +} + +//HasSenderCompID returns true if SenderCompID is present, Tag 49 +func (h Header) HasSenderCompID() bool { + return h.Has(tag.SenderCompID) +} + +//HasSenderSubID returns true if SenderSubID is present, Tag 50 +func (h Header) HasSenderSubID() bool { + return h.Has(tag.SenderSubID) +} + +//HasSendingTime returns true if SendingTime is present, Tag 52 +func (h Header) HasSendingTime() bool { + return h.Has(tag.SendingTime) +} + +//HasTargetCompID returns true if TargetCompID is present, Tag 56 +func (h Header) HasTargetCompID() bool { + return h.Has(tag.TargetCompID) +} + +//HasTargetSubID returns true if TargetSubID is present, Tag 57 +func (h Header) HasTargetSubID() bool { + return h.Has(tag.TargetSubID) +} + +//HasSecureDataLen returns true if SecureDataLen is present, Tag 90 +func (h Header) HasSecureDataLen() bool { + return h.Has(tag.SecureDataLen) +} + +//HasSecureData returns true if SecureData is present, Tag 91 +func (h Header) HasSecureData() bool { + return h.Has(tag.SecureData) +} + +//HasPossResend returns true if PossResend is present, Tag 97 +func (h Header) HasPossResend() bool { + return h.Has(tag.PossResend) +} + +//HasOnBehalfOfCompID returns true if OnBehalfOfCompID is present, Tag 115 +func (h Header) HasOnBehalfOfCompID() bool { + return h.Has(tag.OnBehalfOfCompID) +} + +//HasOnBehalfOfSubID returns true if OnBehalfOfSubID is present, Tag 116 +func (h Header) HasOnBehalfOfSubID() bool { + return h.Has(tag.OnBehalfOfSubID) +} + +//HasOrigSendingTime returns true if OrigSendingTime is present, Tag 122 +func (h Header) HasOrigSendingTime() bool { + return h.Has(tag.OrigSendingTime) +} + +//HasDeliverToCompID returns true if DeliverToCompID is present, Tag 128 +func (h Header) HasDeliverToCompID() bool { + return h.Has(tag.DeliverToCompID) +} + +//HasDeliverToSubID returns true if DeliverToSubID is present, Tag 129 +func (h Header) HasDeliverToSubID() bool { + return h.Has(tag.DeliverToSubID) +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix40/newordersingle/NewOrderSingle.generated.go b/vendor/github.com/quickfixgo/quickfix/fix40/newordersingle/NewOrderSingle.generated.go new file mode 100644 index 0000000..cdc56a0 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix40/newordersingle/NewOrderSingle.generated.go @@ -0,0 +1,643 @@ +package newordersingle + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fix40" + "github.com/quickfixgo/quickfix/tag" +) + +//NewOrderSingle is the fix40 NewOrderSingle type, MsgType = D +type NewOrderSingle struct { + fix40.Header + quickfix.Body + fix40.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a NewOrderSingle from a quickfix.Message instance +func FromMessage(m quickfix.Message) NewOrderSingle { + return NewOrderSingle{ + Header: fix40.Header{Header: m.Header}, + Body: m.Body, + Trailer: fix40.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m NewOrderSingle) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a NewOrderSingle initialized with the required fields for NewOrderSingle +func New(clordid field.ClOrdIDField, handlinst field.HandlInstField, symbol field.SymbolField, side field.SideField, orderqty field.OrderQtyField, ordtype field.OrdTypeField) (m NewOrderSingle) { + m.Header = fix40.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("D")) + m.Set(clordid) + m.Set(handlinst) + m.Set(symbol) + m.Set(side) + m.Set(orderqty) + m.Set(ordtype) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg NewOrderSingle, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "FIX.4.0", "D", r +} + +//SetAccount sets Account, Tag 1 +func (m NewOrderSingle) SetAccount(v string) { + m.Set(field.NewAccount(v)) +} + +//SetClOrdID sets ClOrdID, Tag 11 +func (m NewOrderSingle) SetClOrdID(v string) { + m.Set(field.NewClOrdID(v)) +} + +//SetCommission sets Commission, Tag 12 +func (m NewOrderSingle) SetCommission(v float64) { + m.Set(field.NewCommission(v)) +} + +//SetCommType sets CommType, Tag 13 +func (m NewOrderSingle) SetCommType(v string) { + m.Set(field.NewCommType(v)) +} + +//SetCurrency sets Currency, Tag 15 +func (m NewOrderSingle) SetCurrency(v string) { + m.Set(field.NewCurrency(v)) +} + +//SetExecInst sets ExecInst, Tag 18 +func (m NewOrderSingle) SetExecInst(v string) { + m.Set(field.NewExecInst(v)) +} + +//SetHandlInst sets HandlInst, Tag 21 +func (m NewOrderSingle) SetHandlInst(v string) { + m.Set(field.NewHandlInst(v)) +} + +//SetIDSource sets IDSource, Tag 22 +func (m NewOrderSingle) SetIDSource(v string) { + m.Set(field.NewIDSource(v)) +} + +//SetIOIid sets IOIid, Tag 23 +func (m NewOrderSingle) SetIOIid(v string) { + m.Set(field.NewIOIid(v)) +} + +//SetOrderQty sets OrderQty, Tag 38 +func (m NewOrderSingle) SetOrderQty(v float64) { + m.Set(field.NewOrderQty(v)) +} + +//SetOrdType sets OrdType, Tag 40 +func (m NewOrderSingle) SetOrdType(v string) { + m.Set(field.NewOrdType(v)) +} + +//SetPrice sets Price, Tag 44 +func (m NewOrderSingle) SetPrice(v float64) { + m.Set(field.NewPrice(v)) +} + +//SetRule80A sets Rule80A, Tag 47 +func (m NewOrderSingle) SetRule80A(v string) { + m.Set(field.NewRule80A(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m NewOrderSingle) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSide sets Side, Tag 54 +func (m NewOrderSingle) SetSide(v string) { + m.Set(field.NewSide(v)) +} + +//SetSymbol sets Symbol, Tag 55 +func (m NewOrderSingle) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetText sets Text, Tag 58 +func (m NewOrderSingle) SetText(v string) { + m.Set(field.NewText(v)) +} + +//SetTimeInForce sets TimeInForce, Tag 59 +func (m NewOrderSingle) SetTimeInForce(v string) { + m.Set(field.NewTimeInForce(v)) +} + +//SetSettlmntTyp sets SettlmntTyp, Tag 63 +func (m NewOrderSingle) SetSettlmntTyp(v string) { + m.Set(field.NewSettlmntTyp(v)) +} + +//SetFutSettDate sets FutSettDate, Tag 64 +func (m NewOrderSingle) SetFutSettDate(v string) { + m.Set(field.NewFutSettDate(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m NewOrderSingle) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetExecBroker sets ExecBroker, Tag 76 +func (m NewOrderSingle) SetExecBroker(v string) { + m.Set(field.NewExecBroker(v)) +} + +//SetProcessCode sets ProcessCode, Tag 81 +func (m NewOrderSingle) SetProcessCode(v string) { + m.Set(field.NewProcessCode(v)) +} + +//SetStopPx sets StopPx, Tag 99 +func (m NewOrderSingle) SetStopPx(v float64) { + m.Set(field.NewStopPx(v)) +} + +//SetExDestination sets ExDestination, Tag 100 +func (m NewOrderSingle) SetExDestination(v string) { + m.Set(field.NewExDestination(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m NewOrderSingle) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m NewOrderSingle) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetClientID sets ClientID, Tag 109 +func (m NewOrderSingle) SetClientID(v string) { + m.Set(field.NewClientID(v)) +} + +//SetMinQty sets MinQty, Tag 110 +func (m NewOrderSingle) SetMinQty(v float64) { + m.Set(field.NewMinQty(v)) +} + +//SetMaxFloor sets MaxFloor, Tag 111 +func (m NewOrderSingle) SetMaxFloor(v float64) { + m.Set(field.NewMaxFloor(v)) +} + +//SetLocateReqd sets LocateReqd, Tag 114 +func (m NewOrderSingle) SetLocateReqd(v bool) { + m.Set(field.NewLocateReqd(v)) +} + +//SetQuoteID sets QuoteID, Tag 117 +func (m NewOrderSingle) SetQuoteID(v string) { + m.Set(field.NewQuoteID(v)) +} + +//SetSettlCurrency sets SettlCurrency, Tag 120 +func (m NewOrderSingle) SetSettlCurrency(v string) { + m.Set(field.NewSettlCurrency(v)) +} + +//SetForexReq sets ForexReq, Tag 121 +func (m NewOrderSingle) SetForexReq(v bool) { + m.Set(field.NewForexReq(v)) +} + +//SetExpireTime sets ExpireTime, Tag 126 +func (m NewOrderSingle) SetExpireTime(v time.Time) { + m.Set(field.NewExpireTime(v)) +} + +//SetPrevClosePx sets PrevClosePx, Tag 140 +func (m NewOrderSingle) SetPrevClosePx(v float64) { + m.Set(field.NewPrevClosePx(v)) +} + +//GetAccount gets Account, Tag 1 +func (m NewOrderSingle) GetAccount() (f field.AccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdID gets ClOrdID, Tag 11 +func (m NewOrderSingle) GetClOrdID() (f field.ClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommission gets Commission, Tag 12 +func (m NewOrderSingle) GetCommission() (f field.CommissionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommType gets CommType, Tag 13 +func (m NewOrderSingle) GetCommType() (f field.CommTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCurrency gets Currency, Tag 15 +func (m NewOrderSingle) GetCurrency() (f field.CurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecInst gets ExecInst, Tag 18 +func (m NewOrderSingle) GetExecInst() (f field.ExecInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetHandlInst gets HandlInst, Tag 21 +func (m NewOrderSingle) GetHandlInst() (f field.HandlInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIDSource gets IDSource, Tag 22 +func (m NewOrderSingle) GetIDSource() (f field.IDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIOIid gets IOIid, Tag 23 +func (m NewOrderSingle) GetIOIid() (f field.IOIidField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty gets OrderQty, Tag 38 +func (m NewOrderSingle) GetOrderQty() (f field.OrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdType gets OrdType, Tag 40 +func (m NewOrderSingle) GetOrdType() (f field.OrdTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrice gets Price, Tag 44 +func (m NewOrderSingle) GetPrice() (f field.PriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRule80A gets Rule80A, Tag 47 +func (m NewOrderSingle) GetRule80A() (f field.Rule80AField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m NewOrderSingle) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSide gets Side, Tag 54 +func (m NewOrderSingle) GetSide() (f field.SideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbol gets Symbol, Tag 55 +func (m NewOrderSingle) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetText gets Text, Tag 58 +func (m NewOrderSingle) GetText() (f field.TextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTimeInForce gets TimeInForce, Tag 59 +func (m NewOrderSingle) GetTimeInForce() (f field.TimeInForceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlmntTyp gets SettlmntTyp, Tag 63 +func (m NewOrderSingle) GetSettlmntTyp() (f field.SettlmntTypField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFutSettDate gets FutSettDate, Tag 64 +func (m NewOrderSingle) GetFutSettDate() (f field.FutSettDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m NewOrderSingle) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecBroker gets ExecBroker, Tag 76 +func (m NewOrderSingle) GetExecBroker() (f field.ExecBrokerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetProcessCode gets ProcessCode, Tag 81 +func (m NewOrderSingle) GetProcessCode() (f field.ProcessCodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStopPx gets StopPx, Tag 99 +func (m NewOrderSingle) GetStopPx() (f field.StopPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExDestination gets ExDestination, Tag 100 +func (m NewOrderSingle) GetExDestination() (f field.ExDestinationField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m NewOrderSingle) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m NewOrderSingle) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClientID gets ClientID, Tag 109 +func (m NewOrderSingle) GetClientID() (f field.ClientIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMinQty gets MinQty, Tag 110 +func (m NewOrderSingle) GetMinQty() (f field.MinQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxFloor gets MaxFloor, Tag 111 +func (m NewOrderSingle) GetMaxFloor() (f field.MaxFloorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLocateReqd gets LocateReqd, Tag 114 +func (m NewOrderSingle) GetLocateReqd() (f field.LocateReqdField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetQuoteID gets QuoteID, Tag 117 +func (m NewOrderSingle) GetQuoteID() (f field.QuoteIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrency gets SettlCurrency, Tag 120 +func (m NewOrderSingle) GetSettlCurrency() (f field.SettlCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetForexReq gets ForexReq, Tag 121 +func (m NewOrderSingle) GetForexReq() (f field.ForexReqField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireTime gets ExpireTime, Tag 126 +func (m NewOrderSingle) GetExpireTime() (f field.ExpireTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrevClosePx gets PrevClosePx, Tag 140 +func (m NewOrderSingle) GetPrevClosePx() (f field.PrevClosePxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasAccount returns true if Account is present, Tag 1 +func (m NewOrderSingle) HasAccount() bool { + return m.Has(tag.Account) +} + +//HasClOrdID returns true if ClOrdID is present, Tag 11 +func (m NewOrderSingle) HasClOrdID() bool { + return m.Has(tag.ClOrdID) +} + +//HasCommission returns true if Commission is present, Tag 12 +func (m NewOrderSingle) HasCommission() bool { + return m.Has(tag.Commission) +} + +//HasCommType returns true if CommType is present, Tag 13 +func (m NewOrderSingle) HasCommType() bool { + return m.Has(tag.CommType) +} + +//HasCurrency returns true if Currency is present, Tag 15 +func (m NewOrderSingle) HasCurrency() bool { + return m.Has(tag.Currency) +} + +//HasExecInst returns true if ExecInst is present, Tag 18 +func (m NewOrderSingle) HasExecInst() bool { + return m.Has(tag.ExecInst) +} + +//HasHandlInst returns true if HandlInst is present, Tag 21 +func (m NewOrderSingle) HasHandlInst() bool { + return m.Has(tag.HandlInst) +} + +//HasIDSource returns true if IDSource is present, Tag 22 +func (m NewOrderSingle) HasIDSource() bool { + return m.Has(tag.IDSource) +} + +//HasIOIid returns true if IOIid is present, Tag 23 +func (m NewOrderSingle) HasIOIid() bool { + return m.Has(tag.IOIid) +} + +//HasOrderQty returns true if OrderQty is present, Tag 38 +func (m NewOrderSingle) HasOrderQty() bool { + return m.Has(tag.OrderQty) +} + +//HasOrdType returns true if OrdType is present, Tag 40 +func (m NewOrderSingle) HasOrdType() bool { + return m.Has(tag.OrdType) +} + +//HasPrice returns true if Price is present, Tag 44 +func (m NewOrderSingle) HasPrice() bool { + return m.Has(tag.Price) +} + +//HasRule80A returns true if Rule80A is present, Tag 47 +func (m NewOrderSingle) HasRule80A() bool { + return m.Has(tag.Rule80A) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m NewOrderSingle) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSide returns true if Side is present, Tag 54 +func (m NewOrderSingle) HasSide() bool { + return m.Has(tag.Side) +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m NewOrderSingle) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasText returns true if Text is present, Tag 58 +func (m NewOrderSingle) HasText() bool { + return m.Has(tag.Text) +} + +//HasTimeInForce returns true if TimeInForce is present, Tag 59 +func (m NewOrderSingle) HasTimeInForce() bool { + return m.Has(tag.TimeInForce) +} + +//HasSettlmntTyp returns true if SettlmntTyp is present, Tag 63 +func (m NewOrderSingle) HasSettlmntTyp() bool { + return m.Has(tag.SettlmntTyp) +} + +//HasFutSettDate returns true if FutSettDate is present, Tag 64 +func (m NewOrderSingle) HasFutSettDate() bool { + return m.Has(tag.FutSettDate) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m NewOrderSingle) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasExecBroker returns true if ExecBroker is present, Tag 76 +func (m NewOrderSingle) HasExecBroker() bool { + return m.Has(tag.ExecBroker) +} + +//HasProcessCode returns true if ProcessCode is present, Tag 81 +func (m NewOrderSingle) HasProcessCode() bool { + return m.Has(tag.ProcessCode) +} + +//HasStopPx returns true if StopPx is present, Tag 99 +func (m NewOrderSingle) HasStopPx() bool { + return m.Has(tag.StopPx) +} + +//HasExDestination returns true if ExDestination is present, Tag 100 +func (m NewOrderSingle) HasExDestination() bool { + return m.Has(tag.ExDestination) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m NewOrderSingle) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m NewOrderSingle) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasClientID returns true if ClientID is present, Tag 109 +func (m NewOrderSingle) HasClientID() bool { + return m.Has(tag.ClientID) +} + +//HasMinQty returns true if MinQty is present, Tag 110 +func (m NewOrderSingle) HasMinQty() bool { + return m.Has(tag.MinQty) +} + +//HasMaxFloor returns true if MaxFloor is present, Tag 111 +func (m NewOrderSingle) HasMaxFloor() bool { + return m.Has(tag.MaxFloor) +} + +//HasLocateReqd returns true if LocateReqd is present, Tag 114 +func (m NewOrderSingle) HasLocateReqd() bool { + return m.Has(tag.LocateReqd) +} + +//HasQuoteID returns true if QuoteID is present, Tag 117 +func (m NewOrderSingle) HasQuoteID() bool { + return m.Has(tag.QuoteID) +} + +//HasSettlCurrency returns true if SettlCurrency is present, Tag 120 +func (m NewOrderSingle) HasSettlCurrency() bool { + return m.Has(tag.SettlCurrency) +} + +//HasForexReq returns true if ForexReq is present, Tag 121 +func (m NewOrderSingle) HasForexReq() bool { + return m.Has(tag.ForexReq) +} + +//HasExpireTime returns true if ExpireTime is present, Tag 126 +func (m NewOrderSingle) HasExpireTime() bool { + return m.Has(tag.ExpireTime) +} + +//HasPrevClosePx returns true if PrevClosePx is present, Tag 140 +func (m NewOrderSingle) HasPrevClosePx() bool { + return m.Has(tag.PrevClosePx) +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix40/ordercancelrequest/OrderCancelRequest.generated.go b/vendor/github.com/quickfixgo/quickfix/fix40/ordercancelrequest/OrderCancelRequest.generated.go new file mode 100644 index 0000000..6112b4f --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix40/ordercancelrequest/OrderCancelRequest.generated.go @@ -0,0 +1,323 @@ +package ordercancelrequest + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fix40" + "github.com/quickfixgo/quickfix/tag" +) + +//OrderCancelRequest is the fix40 OrderCancelRequest type, MsgType = F +type OrderCancelRequest struct { + fix40.Header + quickfix.Body + fix40.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a OrderCancelRequest from a quickfix.Message instance +func FromMessage(m quickfix.Message) OrderCancelRequest { + return OrderCancelRequest{ + Header: fix40.Header{Header: m.Header}, + Body: m.Body, + Trailer: fix40.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m OrderCancelRequest) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a OrderCancelRequest initialized with the required fields for OrderCancelRequest +func New(origclordid field.OrigClOrdIDField, clordid field.ClOrdIDField, cxltype field.CxlTypeField, symbol field.SymbolField, side field.SideField, orderqty field.OrderQtyField) (m OrderCancelRequest) { + m.Header = fix40.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("F")) + m.Set(origclordid) + m.Set(clordid) + m.Set(cxltype) + m.Set(symbol) + m.Set(side) + m.Set(orderqty) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg OrderCancelRequest, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "FIX.4.0", "F", r +} + +//SetClOrdID sets ClOrdID, Tag 11 +func (m OrderCancelRequest) SetClOrdID(v string) { + m.Set(field.NewClOrdID(v)) +} + +//SetIDSource sets IDSource, Tag 22 +func (m OrderCancelRequest) SetIDSource(v string) { + m.Set(field.NewIDSource(v)) +} + +//SetOrderID sets OrderID, Tag 37 +func (m OrderCancelRequest) SetOrderID(v string) { + m.Set(field.NewOrderID(v)) +} + +//SetOrderQty sets OrderQty, Tag 38 +func (m OrderCancelRequest) SetOrderQty(v float64) { + m.Set(field.NewOrderQty(v)) +} + +//SetOrigClOrdID sets OrigClOrdID, Tag 41 +func (m OrderCancelRequest) SetOrigClOrdID(v string) { + m.Set(field.NewOrigClOrdID(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m OrderCancelRequest) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSide sets Side, Tag 54 +func (m OrderCancelRequest) SetSide(v string) { + m.Set(field.NewSide(v)) +} + +//SetSymbol sets Symbol, Tag 55 +func (m OrderCancelRequest) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetText sets Text, Tag 58 +func (m OrderCancelRequest) SetText(v string) { + m.Set(field.NewText(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m OrderCancelRequest) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetListID sets ListID, Tag 66 +func (m OrderCancelRequest) SetListID(v string) { + m.Set(field.NewListID(v)) +} + +//SetExecBroker sets ExecBroker, Tag 76 +func (m OrderCancelRequest) SetExecBroker(v string) { + m.Set(field.NewExecBroker(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m OrderCancelRequest) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m OrderCancelRequest) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetClientID sets ClientID, Tag 109 +func (m OrderCancelRequest) SetClientID(v string) { + m.Set(field.NewClientID(v)) +} + +//SetCxlType sets CxlType, Tag 125 +func (m OrderCancelRequest) SetCxlType(v string) { + m.Set(field.NewCxlType(v)) +} + +//GetClOrdID gets ClOrdID, Tag 11 +func (m OrderCancelRequest) GetClOrdID() (f field.ClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIDSource gets IDSource, Tag 22 +func (m OrderCancelRequest) GetIDSource() (f field.IDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderID gets OrderID, Tag 37 +func (m OrderCancelRequest) GetOrderID() (f field.OrderIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty gets OrderQty, Tag 38 +func (m OrderCancelRequest) GetOrderQty() (f field.OrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrigClOrdID gets OrigClOrdID, Tag 41 +func (m OrderCancelRequest) GetOrigClOrdID() (f field.OrigClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m OrderCancelRequest) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSide gets Side, Tag 54 +func (m OrderCancelRequest) GetSide() (f field.SideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbol gets Symbol, Tag 55 +func (m OrderCancelRequest) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetText gets Text, Tag 58 +func (m OrderCancelRequest) GetText() (f field.TextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m OrderCancelRequest) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetListID gets ListID, Tag 66 +func (m OrderCancelRequest) GetListID() (f field.ListIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecBroker gets ExecBroker, Tag 76 +func (m OrderCancelRequest) GetExecBroker() (f field.ExecBrokerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m OrderCancelRequest) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m OrderCancelRequest) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClientID gets ClientID, Tag 109 +func (m OrderCancelRequest) GetClientID() (f field.ClientIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCxlType gets CxlType, Tag 125 +func (m OrderCancelRequest) GetCxlType() (f field.CxlTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasClOrdID returns true if ClOrdID is present, Tag 11 +func (m OrderCancelRequest) HasClOrdID() bool { + return m.Has(tag.ClOrdID) +} + +//HasIDSource returns true if IDSource is present, Tag 22 +func (m OrderCancelRequest) HasIDSource() bool { + return m.Has(tag.IDSource) +} + +//HasOrderID returns true if OrderID is present, Tag 37 +func (m OrderCancelRequest) HasOrderID() bool { + return m.Has(tag.OrderID) +} + +//HasOrderQty returns true if OrderQty is present, Tag 38 +func (m OrderCancelRequest) HasOrderQty() bool { + return m.Has(tag.OrderQty) +} + +//HasOrigClOrdID returns true if OrigClOrdID is present, Tag 41 +func (m OrderCancelRequest) HasOrigClOrdID() bool { + return m.Has(tag.OrigClOrdID) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m OrderCancelRequest) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSide returns true if Side is present, Tag 54 +func (m OrderCancelRequest) HasSide() bool { + return m.Has(tag.Side) +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m OrderCancelRequest) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasText returns true if Text is present, Tag 58 +func (m OrderCancelRequest) HasText() bool { + return m.Has(tag.Text) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m OrderCancelRequest) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasListID returns true if ListID is present, Tag 66 +func (m OrderCancelRequest) HasListID() bool { + return m.Has(tag.ListID) +} + +//HasExecBroker returns true if ExecBroker is present, Tag 76 +func (m OrderCancelRequest) HasExecBroker() bool { + return m.Has(tag.ExecBroker) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m OrderCancelRequest) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m OrderCancelRequest) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasClientID returns true if ClientID is present, Tag 109 +func (m OrderCancelRequest) HasClientID() bool { + return m.Has(tag.ClientID) +} + +//HasCxlType returns true if CxlType is present, Tag 125 +func (m OrderCancelRequest) HasCxlType() bool { + return m.Has(tag.CxlType) +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix40/trailer.generated.go b/vendor/github.com/quickfixgo/quickfix/fix40/trailer.generated.go new file mode 100644 index 0000000..d3e2c7b --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix40/trailer.generated.go @@ -0,0 +1,60 @@ +package fix40 + +import ( + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/tag" +) + +//Trailer is the fix40 Trailer type +type Trailer struct { + quickfix.Trailer +} + +//SetCheckSum sets CheckSum, Tag 10 +func (t Trailer) SetCheckSum(v string) { + t.Set(field.NewCheckSum(v)) +} + +//SetSignature sets Signature, Tag 89 +func (t Trailer) SetSignature(v string) { + t.Set(field.NewSignature(v)) +} + +//SetSignatureLength sets SignatureLength, Tag 93 +func (t Trailer) SetSignatureLength(v int) { + t.Set(field.NewSignatureLength(v)) +} + +//GetCheckSum gets CheckSum, Tag 10 +func (t Trailer) GetCheckSum() (f field.CheckSumField, err quickfix.MessageRejectError) { + err = t.Get(&f) + return +} + +//GetSignature gets Signature, Tag 89 +func (t Trailer) GetSignature() (f field.SignatureField, err quickfix.MessageRejectError) { + err = t.Get(&f) + return +} + +//GetSignatureLength gets SignatureLength, Tag 93 +func (t Trailer) GetSignatureLength() (f field.SignatureLengthField, err quickfix.MessageRejectError) { + err = t.Get(&f) + return +} + +//HasCheckSum returns true if CheckSum is present, Tag 10 +func (t Trailer) HasCheckSum() bool { + return t.Has(tag.CheckSum) +} + +//HasSignature returns true if Signature is present, Tag 89 +func (t Trailer) HasSignature() bool { + return t.Has(tag.Signature) +} + +//HasSignatureLength returns true if SignatureLength is present, Tag 93 +func (t Trailer) HasSignatureLength() bool { + return t.Has(tag.SignatureLength) +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix41/executionreport/ExecutionReport.generated.go b/vendor/github.com/quickfixgo/quickfix/fix41/executionreport/ExecutionReport.generated.go new file mode 100644 index 0000000..31ece1d --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix41/executionreport/ExecutionReport.generated.go @@ -0,0 +1,1018 @@ +package executionreport + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fix41" + "github.com/quickfixgo/quickfix/tag" +) + +//ExecutionReport is the fix41 ExecutionReport type, MsgType = 8 +type ExecutionReport struct { + fix41.Header + quickfix.Body + fix41.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a ExecutionReport from a quickfix.Message instance +func FromMessage(m quickfix.Message) ExecutionReport { + return ExecutionReport{ + Header: fix41.Header{Header: m.Header}, + Body: m.Body, + Trailer: fix41.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m ExecutionReport) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a ExecutionReport initialized with the required fields for ExecutionReport +func New(orderid field.OrderIDField, execid field.ExecIDField, exectranstype field.ExecTransTypeField, exectype field.ExecTypeField, ordstatus field.OrdStatusField, symbol field.SymbolField, side field.SideField, orderqty field.OrderQtyField, lastshares field.LastSharesField, lastpx field.LastPxField, leavesqty field.LeavesQtyField, cumqty field.CumQtyField, avgpx field.AvgPxField) (m ExecutionReport) { + m.Header = fix41.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("8")) + m.Set(orderid) + m.Set(execid) + m.Set(exectranstype) + m.Set(exectype) + m.Set(ordstatus) + m.Set(symbol) + m.Set(side) + m.Set(orderqty) + m.Set(lastshares) + m.Set(lastpx) + m.Set(leavesqty) + m.Set(cumqty) + m.Set(avgpx) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg ExecutionReport, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "FIX.4.1", "8", r +} + +//SetAccount sets Account, Tag 1 +func (m ExecutionReport) SetAccount(v string) { + m.Set(field.NewAccount(v)) +} + +//SetAvgPx sets AvgPx, Tag 6 +func (m ExecutionReport) SetAvgPx(v float64) { + m.Set(field.NewAvgPx(v)) +} + +//SetClOrdID sets ClOrdID, Tag 11 +func (m ExecutionReport) SetClOrdID(v string) { + m.Set(field.NewClOrdID(v)) +} + +//SetCommission sets Commission, Tag 12 +func (m ExecutionReport) SetCommission(v float64) { + m.Set(field.NewCommission(v)) +} + +//SetCommType sets CommType, Tag 13 +func (m ExecutionReport) SetCommType(v string) { + m.Set(field.NewCommType(v)) +} + +//SetCumQty sets CumQty, Tag 14 +func (m ExecutionReport) SetCumQty(v float64) { + m.Set(field.NewCumQty(v)) +} + +//SetCurrency sets Currency, Tag 15 +func (m ExecutionReport) SetCurrency(v string) { + m.Set(field.NewCurrency(v)) +} + +//SetExecID sets ExecID, Tag 17 +func (m ExecutionReport) SetExecID(v string) { + m.Set(field.NewExecID(v)) +} + +//SetExecInst sets ExecInst, Tag 18 +func (m ExecutionReport) SetExecInst(v string) { + m.Set(field.NewExecInst(v)) +} + +//SetExecRefID sets ExecRefID, Tag 19 +func (m ExecutionReport) SetExecRefID(v string) { + m.Set(field.NewExecRefID(v)) +} + +//SetExecTransType sets ExecTransType, Tag 20 +func (m ExecutionReport) SetExecTransType(v string) { + m.Set(field.NewExecTransType(v)) +} + +//SetIDSource sets IDSource, Tag 22 +func (m ExecutionReport) SetIDSource(v string) { + m.Set(field.NewIDSource(v)) +} + +//SetLastCapacity sets LastCapacity, Tag 29 +func (m ExecutionReport) SetLastCapacity(v string) { + m.Set(field.NewLastCapacity(v)) +} + +//SetLastMkt sets LastMkt, Tag 30 +func (m ExecutionReport) SetLastMkt(v string) { + m.Set(field.NewLastMkt(v)) +} + +//SetLastPx sets LastPx, Tag 31 +func (m ExecutionReport) SetLastPx(v float64) { + m.Set(field.NewLastPx(v)) +} + +//SetLastShares sets LastShares, Tag 32 +func (m ExecutionReport) SetLastShares(v float64) { + m.Set(field.NewLastShares(v)) +} + +//SetOrderID sets OrderID, Tag 37 +func (m ExecutionReport) SetOrderID(v string) { + m.Set(field.NewOrderID(v)) +} + +//SetOrderQty sets OrderQty, Tag 38 +func (m ExecutionReport) SetOrderQty(v float64) { + m.Set(field.NewOrderQty(v)) +} + +//SetOrdStatus sets OrdStatus, Tag 39 +func (m ExecutionReport) SetOrdStatus(v string) { + m.Set(field.NewOrdStatus(v)) +} + +//SetOrdType sets OrdType, Tag 40 +func (m ExecutionReport) SetOrdType(v string) { + m.Set(field.NewOrdType(v)) +} + +//SetOrigClOrdID sets OrigClOrdID, Tag 41 +func (m ExecutionReport) SetOrigClOrdID(v string) { + m.Set(field.NewOrigClOrdID(v)) +} + +//SetPrice sets Price, Tag 44 +func (m ExecutionReport) SetPrice(v float64) { + m.Set(field.NewPrice(v)) +} + +//SetRule80A sets Rule80A, Tag 47 +func (m ExecutionReport) SetRule80A(v string) { + m.Set(field.NewRule80A(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m ExecutionReport) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSide sets Side, Tag 54 +func (m ExecutionReport) SetSide(v string) { + m.Set(field.NewSide(v)) +} + +//SetSymbol sets Symbol, Tag 55 +func (m ExecutionReport) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetText sets Text, Tag 58 +func (m ExecutionReport) SetText(v string) { + m.Set(field.NewText(v)) +} + +//SetTimeInForce sets TimeInForce, Tag 59 +func (m ExecutionReport) SetTimeInForce(v string) { + m.Set(field.NewTimeInForce(v)) +} + +//SetTransactTime sets TransactTime, Tag 60 +func (m ExecutionReport) SetTransactTime(v time.Time) { + m.Set(field.NewTransactTime(v)) +} + +//SetSettlmntTyp sets SettlmntTyp, Tag 63 +func (m ExecutionReport) SetSettlmntTyp(v string) { + m.Set(field.NewSettlmntTyp(v)) +} + +//SetFutSettDate sets FutSettDate, Tag 64 +func (m ExecutionReport) SetFutSettDate(v string) { + m.Set(field.NewFutSettDate(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m ExecutionReport) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetListID sets ListID, Tag 66 +func (m ExecutionReport) SetListID(v string) { + m.Set(field.NewListID(v)) +} + +//SetTradeDate sets TradeDate, Tag 75 +func (m ExecutionReport) SetTradeDate(v string) { + m.Set(field.NewTradeDate(v)) +} + +//SetExecBroker sets ExecBroker, Tag 76 +func (m ExecutionReport) SetExecBroker(v string) { + m.Set(field.NewExecBroker(v)) +} + +//SetStopPx sets StopPx, Tag 99 +func (m ExecutionReport) SetStopPx(v float64) { + m.Set(field.NewStopPx(v)) +} + +//SetOrdRejReason sets OrdRejReason, Tag 103 +func (m ExecutionReport) SetOrdRejReason(v int) { + m.Set(field.NewOrdRejReason(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m ExecutionReport) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m ExecutionReport) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetClientID sets ClientID, Tag 109 +func (m ExecutionReport) SetClientID(v string) { + m.Set(field.NewClientID(v)) +} + +//SetReportToExch sets ReportToExch, Tag 113 +func (m ExecutionReport) SetReportToExch(v bool) { + m.Set(field.NewReportToExch(v)) +} + +//SetSettlCurrAmt sets SettlCurrAmt, Tag 119 +func (m ExecutionReport) SetSettlCurrAmt(v float64) { + m.Set(field.NewSettlCurrAmt(v)) +} + +//SetSettlCurrency sets SettlCurrency, Tag 120 +func (m ExecutionReport) SetSettlCurrency(v string) { + m.Set(field.NewSettlCurrency(v)) +} + +//SetExpireTime sets ExpireTime, Tag 126 +func (m ExecutionReport) SetExpireTime(v time.Time) { + m.Set(field.NewExpireTime(v)) +} + +//SetExecType sets ExecType, Tag 150 +func (m ExecutionReport) SetExecType(v string) { + m.Set(field.NewExecType(v)) +} + +//SetLeavesQty sets LeavesQty, Tag 151 +func (m ExecutionReport) SetLeavesQty(v float64) { + m.Set(field.NewLeavesQty(v)) +} + +//SetSettlCurrFxRate sets SettlCurrFxRate, Tag 155 +func (m ExecutionReport) SetSettlCurrFxRate(v float64) { + m.Set(field.NewSettlCurrFxRate(v)) +} + +//SetSettlCurrFxRateCalc sets SettlCurrFxRateCalc, Tag 156 +func (m ExecutionReport) SetSettlCurrFxRateCalc(v string) { + m.Set(field.NewSettlCurrFxRateCalc(v)) +} + +//SetSecurityType sets SecurityType, Tag 167 +func (m ExecutionReport) SetSecurityType(v string) { + m.Set(field.NewSecurityType(v)) +} + +//SetLastSpotRate sets LastSpotRate, Tag 194 +func (m ExecutionReport) SetLastSpotRate(v float64) { + m.Set(field.NewLastSpotRate(v)) +} + +//SetLastForwardPoints sets LastForwardPoints, Tag 195 +func (m ExecutionReport) SetLastForwardPoints(v float64) { + m.Set(field.NewLastForwardPoints(v)) +} + +//SetSecondaryOrderID sets SecondaryOrderID, Tag 198 +func (m ExecutionReport) SetSecondaryOrderID(v string) { + m.Set(field.NewSecondaryOrderID(v)) +} + +//SetMaturityMonthYear sets MaturityMonthYear, Tag 200 +func (m ExecutionReport) SetMaturityMonthYear(v string) { + m.Set(field.NewMaturityMonthYear(v)) +} + +//SetPutOrCall sets PutOrCall, Tag 201 +func (m ExecutionReport) SetPutOrCall(v int) { + m.Set(field.NewPutOrCall(v)) +} + +//SetStrikePrice sets StrikePrice, Tag 202 +func (m ExecutionReport) SetStrikePrice(v float64) { + m.Set(field.NewStrikePrice(v)) +} + +//SetMaturityDay sets MaturityDay, Tag 205 +func (m ExecutionReport) SetMaturityDay(v int) { + m.Set(field.NewMaturityDay(v)) +} + +//SetOptAttribute sets OptAttribute, Tag 206 +func (m ExecutionReport) SetOptAttribute(v string) { + m.Set(field.NewOptAttribute(v)) +} + +//SetSecurityExchange sets SecurityExchange, Tag 207 +func (m ExecutionReport) SetSecurityExchange(v string) { + m.Set(field.NewSecurityExchange(v)) +} + +//SetPegDifference sets PegDifference, Tag 211 +func (m ExecutionReport) SetPegDifference(v float64) { + m.Set(field.NewPegDifference(v)) +} + +//GetAccount gets Account, Tag 1 +func (m ExecutionReport) GetAccount() (f field.AccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAvgPx gets AvgPx, Tag 6 +func (m ExecutionReport) GetAvgPx() (f field.AvgPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdID gets ClOrdID, Tag 11 +func (m ExecutionReport) GetClOrdID() (f field.ClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommission gets Commission, Tag 12 +func (m ExecutionReport) GetCommission() (f field.CommissionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommType gets CommType, Tag 13 +func (m ExecutionReport) GetCommType() (f field.CommTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCumQty gets CumQty, Tag 14 +func (m ExecutionReport) GetCumQty() (f field.CumQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCurrency gets Currency, Tag 15 +func (m ExecutionReport) GetCurrency() (f field.CurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecID gets ExecID, Tag 17 +func (m ExecutionReport) GetExecID() (f field.ExecIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecInst gets ExecInst, Tag 18 +func (m ExecutionReport) GetExecInst() (f field.ExecInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecRefID gets ExecRefID, Tag 19 +func (m ExecutionReport) GetExecRefID() (f field.ExecRefIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecTransType gets ExecTransType, Tag 20 +func (m ExecutionReport) GetExecTransType() (f field.ExecTransTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIDSource gets IDSource, Tag 22 +func (m ExecutionReport) GetIDSource() (f field.IDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastCapacity gets LastCapacity, Tag 29 +func (m ExecutionReport) GetLastCapacity() (f field.LastCapacityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastMkt gets LastMkt, Tag 30 +func (m ExecutionReport) GetLastMkt() (f field.LastMktField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastPx gets LastPx, Tag 31 +func (m ExecutionReport) GetLastPx() (f field.LastPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastShares gets LastShares, Tag 32 +func (m ExecutionReport) GetLastShares() (f field.LastSharesField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderID gets OrderID, Tag 37 +func (m ExecutionReport) GetOrderID() (f field.OrderIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty gets OrderQty, Tag 38 +func (m ExecutionReport) GetOrderQty() (f field.OrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdStatus gets OrdStatus, Tag 39 +func (m ExecutionReport) GetOrdStatus() (f field.OrdStatusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdType gets OrdType, Tag 40 +func (m ExecutionReport) GetOrdType() (f field.OrdTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrigClOrdID gets OrigClOrdID, Tag 41 +func (m ExecutionReport) GetOrigClOrdID() (f field.OrigClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrice gets Price, Tag 44 +func (m ExecutionReport) GetPrice() (f field.PriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRule80A gets Rule80A, Tag 47 +func (m ExecutionReport) GetRule80A() (f field.Rule80AField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m ExecutionReport) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSide gets Side, Tag 54 +func (m ExecutionReport) GetSide() (f field.SideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbol gets Symbol, Tag 55 +func (m ExecutionReport) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetText gets Text, Tag 58 +func (m ExecutionReport) GetText() (f field.TextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTimeInForce gets TimeInForce, Tag 59 +func (m ExecutionReport) GetTimeInForce() (f field.TimeInForceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTransactTime gets TransactTime, Tag 60 +func (m ExecutionReport) GetTransactTime() (f field.TransactTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlmntTyp gets SettlmntTyp, Tag 63 +func (m ExecutionReport) GetSettlmntTyp() (f field.SettlmntTypField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFutSettDate gets FutSettDate, Tag 64 +func (m ExecutionReport) GetFutSettDate() (f field.FutSettDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m ExecutionReport) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetListID gets ListID, Tag 66 +func (m ExecutionReport) GetListID() (f field.ListIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradeDate gets TradeDate, Tag 75 +func (m ExecutionReport) GetTradeDate() (f field.TradeDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecBroker gets ExecBroker, Tag 76 +func (m ExecutionReport) GetExecBroker() (f field.ExecBrokerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStopPx gets StopPx, Tag 99 +func (m ExecutionReport) GetStopPx() (f field.StopPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdRejReason gets OrdRejReason, Tag 103 +func (m ExecutionReport) GetOrdRejReason() (f field.OrdRejReasonField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m ExecutionReport) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m ExecutionReport) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClientID gets ClientID, Tag 109 +func (m ExecutionReport) GetClientID() (f field.ClientIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetReportToExch gets ReportToExch, Tag 113 +func (m ExecutionReport) GetReportToExch() (f field.ReportToExchField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrAmt gets SettlCurrAmt, Tag 119 +func (m ExecutionReport) GetSettlCurrAmt() (f field.SettlCurrAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrency gets SettlCurrency, Tag 120 +func (m ExecutionReport) GetSettlCurrency() (f field.SettlCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireTime gets ExpireTime, Tag 126 +func (m ExecutionReport) GetExpireTime() (f field.ExpireTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecType gets ExecType, Tag 150 +func (m ExecutionReport) GetExecType() (f field.ExecTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLeavesQty gets LeavesQty, Tag 151 +func (m ExecutionReport) GetLeavesQty() (f field.LeavesQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrFxRate gets SettlCurrFxRate, Tag 155 +func (m ExecutionReport) GetSettlCurrFxRate() (f field.SettlCurrFxRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrFxRateCalc gets SettlCurrFxRateCalc, Tag 156 +func (m ExecutionReport) GetSettlCurrFxRateCalc() (f field.SettlCurrFxRateCalcField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityType gets SecurityType, Tag 167 +func (m ExecutionReport) GetSecurityType() (f field.SecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastSpotRate gets LastSpotRate, Tag 194 +func (m ExecutionReport) GetLastSpotRate() (f field.LastSpotRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastForwardPoints gets LastForwardPoints, Tag 195 +func (m ExecutionReport) GetLastForwardPoints() (f field.LastForwardPointsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecondaryOrderID gets SecondaryOrderID, Tag 198 +func (m ExecutionReport) GetSecondaryOrderID() (f field.SecondaryOrderIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityMonthYear gets MaturityMonthYear, Tag 200 +func (m ExecutionReport) GetMaturityMonthYear() (f field.MaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPutOrCall gets PutOrCall, Tag 201 +func (m ExecutionReport) GetPutOrCall() (f field.PutOrCallField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikePrice gets StrikePrice, Tag 202 +func (m ExecutionReport) GetStrikePrice() (f field.StrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityDay gets MaturityDay, Tag 205 +func (m ExecutionReport) GetMaturityDay() (f field.MaturityDayField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOptAttribute gets OptAttribute, Tag 206 +func (m ExecutionReport) GetOptAttribute() (f field.OptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityExchange gets SecurityExchange, Tag 207 +func (m ExecutionReport) GetSecurityExchange() (f field.SecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegDifference gets PegDifference, Tag 211 +func (m ExecutionReport) GetPegDifference() (f field.PegDifferenceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasAccount returns true if Account is present, Tag 1 +func (m ExecutionReport) HasAccount() bool { + return m.Has(tag.Account) +} + +//HasAvgPx returns true if AvgPx is present, Tag 6 +func (m ExecutionReport) HasAvgPx() bool { + return m.Has(tag.AvgPx) +} + +//HasClOrdID returns true if ClOrdID is present, Tag 11 +func (m ExecutionReport) HasClOrdID() bool { + return m.Has(tag.ClOrdID) +} + +//HasCommission returns true if Commission is present, Tag 12 +func (m ExecutionReport) HasCommission() bool { + return m.Has(tag.Commission) +} + +//HasCommType returns true if CommType is present, Tag 13 +func (m ExecutionReport) HasCommType() bool { + return m.Has(tag.CommType) +} + +//HasCumQty returns true if CumQty is present, Tag 14 +func (m ExecutionReport) HasCumQty() bool { + return m.Has(tag.CumQty) +} + +//HasCurrency returns true if Currency is present, Tag 15 +func (m ExecutionReport) HasCurrency() bool { + return m.Has(tag.Currency) +} + +//HasExecID returns true if ExecID is present, Tag 17 +func (m ExecutionReport) HasExecID() bool { + return m.Has(tag.ExecID) +} + +//HasExecInst returns true if ExecInst is present, Tag 18 +func (m ExecutionReport) HasExecInst() bool { + return m.Has(tag.ExecInst) +} + +//HasExecRefID returns true if ExecRefID is present, Tag 19 +func (m ExecutionReport) HasExecRefID() bool { + return m.Has(tag.ExecRefID) +} + +//HasExecTransType returns true if ExecTransType is present, Tag 20 +func (m ExecutionReport) HasExecTransType() bool { + return m.Has(tag.ExecTransType) +} + +//HasIDSource returns true if IDSource is present, Tag 22 +func (m ExecutionReport) HasIDSource() bool { + return m.Has(tag.IDSource) +} + +//HasLastCapacity returns true if LastCapacity is present, Tag 29 +func (m ExecutionReport) HasLastCapacity() bool { + return m.Has(tag.LastCapacity) +} + +//HasLastMkt returns true if LastMkt is present, Tag 30 +func (m ExecutionReport) HasLastMkt() bool { + return m.Has(tag.LastMkt) +} + +//HasLastPx returns true if LastPx is present, Tag 31 +func (m ExecutionReport) HasLastPx() bool { + return m.Has(tag.LastPx) +} + +//HasLastShares returns true if LastShares is present, Tag 32 +func (m ExecutionReport) HasLastShares() bool { + return m.Has(tag.LastShares) +} + +//HasOrderID returns true if OrderID is present, Tag 37 +func (m ExecutionReport) HasOrderID() bool { + return m.Has(tag.OrderID) +} + +//HasOrderQty returns true if OrderQty is present, Tag 38 +func (m ExecutionReport) HasOrderQty() bool { + return m.Has(tag.OrderQty) +} + +//HasOrdStatus returns true if OrdStatus is present, Tag 39 +func (m ExecutionReport) HasOrdStatus() bool { + return m.Has(tag.OrdStatus) +} + +//HasOrdType returns true if OrdType is present, Tag 40 +func (m ExecutionReport) HasOrdType() bool { + return m.Has(tag.OrdType) +} + +//HasOrigClOrdID returns true if OrigClOrdID is present, Tag 41 +func (m ExecutionReport) HasOrigClOrdID() bool { + return m.Has(tag.OrigClOrdID) +} + +//HasPrice returns true if Price is present, Tag 44 +func (m ExecutionReport) HasPrice() bool { + return m.Has(tag.Price) +} + +//HasRule80A returns true if Rule80A is present, Tag 47 +func (m ExecutionReport) HasRule80A() bool { + return m.Has(tag.Rule80A) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m ExecutionReport) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSide returns true if Side is present, Tag 54 +func (m ExecutionReport) HasSide() bool { + return m.Has(tag.Side) +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m ExecutionReport) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasText returns true if Text is present, Tag 58 +func (m ExecutionReport) HasText() bool { + return m.Has(tag.Text) +} + +//HasTimeInForce returns true if TimeInForce is present, Tag 59 +func (m ExecutionReport) HasTimeInForce() bool { + return m.Has(tag.TimeInForce) +} + +//HasTransactTime returns true if TransactTime is present, Tag 60 +func (m ExecutionReport) HasTransactTime() bool { + return m.Has(tag.TransactTime) +} + +//HasSettlmntTyp returns true if SettlmntTyp is present, Tag 63 +func (m ExecutionReport) HasSettlmntTyp() bool { + return m.Has(tag.SettlmntTyp) +} + +//HasFutSettDate returns true if FutSettDate is present, Tag 64 +func (m ExecutionReport) HasFutSettDate() bool { + return m.Has(tag.FutSettDate) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m ExecutionReport) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasListID returns true if ListID is present, Tag 66 +func (m ExecutionReport) HasListID() bool { + return m.Has(tag.ListID) +} + +//HasTradeDate returns true if TradeDate is present, Tag 75 +func (m ExecutionReport) HasTradeDate() bool { + return m.Has(tag.TradeDate) +} + +//HasExecBroker returns true if ExecBroker is present, Tag 76 +func (m ExecutionReport) HasExecBroker() bool { + return m.Has(tag.ExecBroker) +} + +//HasStopPx returns true if StopPx is present, Tag 99 +func (m ExecutionReport) HasStopPx() bool { + return m.Has(tag.StopPx) +} + +//HasOrdRejReason returns true if OrdRejReason is present, Tag 103 +func (m ExecutionReport) HasOrdRejReason() bool { + return m.Has(tag.OrdRejReason) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m ExecutionReport) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m ExecutionReport) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasClientID returns true if ClientID is present, Tag 109 +func (m ExecutionReport) HasClientID() bool { + return m.Has(tag.ClientID) +} + +//HasReportToExch returns true if ReportToExch is present, Tag 113 +func (m ExecutionReport) HasReportToExch() bool { + return m.Has(tag.ReportToExch) +} + +//HasSettlCurrAmt returns true if SettlCurrAmt is present, Tag 119 +func (m ExecutionReport) HasSettlCurrAmt() bool { + return m.Has(tag.SettlCurrAmt) +} + +//HasSettlCurrency returns true if SettlCurrency is present, Tag 120 +func (m ExecutionReport) HasSettlCurrency() bool { + return m.Has(tag.SettlCurrency) +} + +//HasExpireTime returns true if ExpireTime is present, Tag 126 +func (m ExecutionReport) HasExpireTime() bool { + return m.Has(tag.ExpireTime) +} + +//HasExecType returns true if ExecType is present, Tag 150 +func (m ExecutionReport) HasExecType() bool { + return m.Has(tag.ExecType) +} + +//HasLeavesQty returns true if LeavesQty is present, Tag 151 +func (m ExecutionReport) HasLeavesQty() bool { + return m.Has(tag.LeavesQty) +} + +//HasSettlCurrFxRate returns true if SettlCurrFxRate is present, Tag 155 +func (m ExecutionReport) HasSettlCurrFxRate() bool { + return m.Has(tag.SettlCurrFxRate) +} + +//HasSettlCurrFxRateCalc returns true if SettlCurrFxRateCalc is present, Tag 156 +func (m ExecutionReport) HasSettlCurrFxRateCalc() bool { + return m.Has(tag.SettlCurrFxRateCalc) +} + +//HasSecurityType returns true if SecurityType is present, Tag 167 +func (m ExecutionReport) HasSecurityType() bool { + return m.Has(tag.SecurityType) +} + +//HasLastSpotRate returns true if LastSpotRate is present, Tag 194 +func (m ExecutionReport) HasLastSpotRate() bool { + return m.Has(tag.LastSpotRate) +} + +//HasLastForwardPoints returns true if LastForwardPoints is present, Tag 195 +func (m ExecutionReport) HasLastForwardPoints() bool { + return m.Has(tag.LastForwardPoints) +} + +//HasSecondaryOrderID returns true if SecondaryOrderID is present, Tag 198 +func (m ExecutionReport) HasSecondaryOrderID() bool { + return m.Has(tag.SecondaryOrderID) +} + +//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200 +func (m ExecutionReport) HasMaturityMonthYear() bool { + return m.Has(tag.MaturityMonthYear) +} + +//HasPutOrCall returns true if PutOrCall is present, Tag 201 +func (m ExecutionReport) HasPutOrCall() bool { + return m.Has(tag.PutOrCall) +} + +//HasStrikePrice returns true if StrikePrice is present, Tag 202 +func (m ExecutionReport) HasStrikePrice() bool { + return m.Has(tag.StrikePrice) +} + +//HasMaturityDay returns true if MaturityDay is present, Tag 205 +func (m ExecutionReport) HasMaturityDay() bool { + return m.Has(tag.MaturityDay) +} + +//HasOptAttribute returns true if OptAttribute is present, Tag 206 +func (m ExecutionReport) HasOptAttribute() bool { + return m.Has(tag.OptAttribute) +} + +//HasSecurityExchange returns true if SecurityExchange is present, Tag 207 +func (m ExecutionReport) HasSecurityExchange() bool { + return m.Has(tag.SecurityExchange) +} + +//HasPegDifference returns true if PegDifference is present, Tag 211 +func (m ExecutionReport) HasPegDifference() bool { + return m.Has(tag.PegDifference) +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix41/header.generated.go b/vendor/github.com/quickfixgo/quickfix/fix41/header.generated.go new file mode 100644 index 0000000..5b85b68 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix41/header.generated.go @@ -0,0 +1,373 @@ +package fix41 + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/tag" +) + +//Header is the fix41 Header type +type Header struct { + quickfix.Header +} + +//NewHeader returns a new, initialized Header instance +func NewHeader() (h Header) { + h.Init() + h.SetBeginString("FIX.4.1") + return +} + +//SetBeginString sets BeginString, Tag 8 +func (h Header) SetBeginString(v string) { + h.Set(field.NewBeginString(v)) +} + +//SetBodyLength sets BodyLength, Tag 9 +func (h Header) SetBodyLength(v int) { + h.Set(field.NewBodyLength(v)) +} + +//SetMsgSeqNum sets MsgSeqNum, Tag 34 +func (h Header) SetMsgSeqNum(v int) { + h.Set(field.NewMsgSeqNum(v)) +} + +//SetMsgType sets MsgType, Tag 35 +func (h Header) SetMsgType(v string) { + h.Set(field.NewMsgType(v)) +} + +//SetPossDupFlag sets PossDupFlag, Tag 43 +func (h Header) SetPossDupFlag(v bool) { + h.Set(field.NewPossDupFlag(v)) +} + +//SetSenderCompID sets SenderCompID, Tag 49 +func (h Header) SetSenderCompID(v string) { + h.Set(field.NewSenderCompID(v)) +} + +//SetSenderSubID sets SenderSubID, Tag 50 +func (h Header) SetSenderSubID(v string) { + h.Set(field.NewSenderSubID(v)) +} + +//SetSendingTime sets SendingTime, Tag 52 +func (h Header) SetSendingTime(v time.Time) { + h.Set(field.NewSendingTime(v)) +} + +//SetTargetCompID sets TargetCompID, Tag 56 +func (h Header) SetTargetCompID(v string) { + h.Set(field.NewTargetCompID(v)) +} + +//SetTargetSubID sets TargetSubID, Tag 57 +func (h Header) SetTargetSubID(v string) { + h.Set(field.NewTargetSubID(v)) +} + +//SetSecureDataLen sets SecureDataLen, Tag 90 +func (h Header) SetSecureDataLen(v int) { + h.Set(field.NewSecureDataLen(v)) +} + +//SetSecureData sets SecureData, Tag 91 +func (h Header) SetSecureData(v string) { + h.Set(field.NewSecureData(v)) +} + +//SetPossResend sets PossResend, Tag 97 +func (h Header) SetPossResend(v bool) { + h.Set(field.NewPossResend(v)) +} + +//SetOnBehalfOfCompID sets OnBehalfOfCompID, Tag 115 +func (h Header) SetOnBehalfOfCompID(v string) { + h.Set(field.NewOnBehalfOfCompID(v)) +} + +//SetOnBehalfOfSubID sets OnBehalfOfSubID, Tag 116 +func (h Header) SetOnBehalfOfSubID(v string) { + h.Set(field.NewOnBehalfOfSubID(v)) +} + +//SetOrigSendingTime sets OrigSendingTime, Tag 122 +func (h Header) SetOrigSendingTime(v time.Time) { + h.Set(field.NewOrigSendingTime(v)) +} + +//SetDeliverToCompID sets DeliverToCompID, Tag 128 +func (h Header) SetDeliverToCompID(v string) { + h.Set(field.NewDeliverToCompID(v)) +} + +//SetDeliverToSubID sets DeliverToSubID, Tag 129 +func (h Header) SetDeliverToSubID(v string) { + h.Set(field.NewDeliverToSubID(v)) +} + +//SetSenderLocationID sets SenderLocationID, Tag 142 +func (h Header) SetSenderLocationID(v string) { + h.Set(field.NewSenderLocationID(v)) +} + +//SetTargetLocationID sets TargetLocationID, Tag 143 +func (h Header) SetTargetLocationID(v string) { + h.Set(field.NewTargetLocationID(v)) +} + +//SetOnBehalfOfLocationID sets OnBehalfOfLocationID, Tag 144 +func (h Header) SetOnBehalfOfLocationID(v string) { + h.Set(field.NewOnBehalfOfLocationID(v)) +} + +//SetDeliverToLocationID sets DeliverToLocationID, Tag 145 +func (h Header) SetDeliverToLocationID(v string) { + h.Set(field.NewDeliverToLocationID(v)) +} + +//GetBeginString gets BeginString, Tag 8 +func (h Header) GetBeginString() (f field.BeginStringField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetBodyLength gets BodyLength, Tag 9 +func (h Header) GetBodyLength() (f field.BodyLengthField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetMsgSeqNum gets MsgSeqNum, Tag 34 +func (h Header) GetMsgSeqNum() (f field.MsgSeqNumField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetMsgType gets MsgType, Tag 35 +func (h Header) GetMsgType() (f field.MsgTypeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetPossDupFlag gets PossDupFlag, Tag 43 +func (h Header) GetPossDupFlag() (f field.PossDupFlagField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSenderCompID gets SenderCompID, Tag 49 +func (h Header) GetSenderCompID() (f field.SenderCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSenderSubID gets SenderSubID, Tag 50 +func (h Header) GetSenderSubID() (f field.SenderSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSendingTime gets SendingTime, Tag 52 +func (h Header) GetSendingTime() (f field.SendingTimeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetTargetCompID gets TargetCompID, Tag 56 +func (h Header) GetTargetCompID() (f field.TargetCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetTargetSubID gets TargetSubID, Tag 57 +func (h Header) GetTargetSubID() (f field.TargetSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSecureDataLen gets SecureDataLen, Tag 90 +func (h Header) GetSecureDataLen() (f field.SecureDataLenField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSecureData gets SecureData, Tag 91 +func (h Header) GetSecureData() (f field.SecureDataField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetPossResend gets PossResend, Tag 97 +func (h Header) GetPossResend() (f field.PossResendField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOnBehalfOfCompID gets OnBehalfOfCompID, Tag 115 +func (h Header) GetOnBehalfOfCompID() (f field.OnBehalfOfCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOnBehalfOfSubID gets OnBehalfOfSubID, Tag 116 +func (h Header) GetOnBehalfOfSubID() (f field.OnBehalfOfSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOrigSendingTime gets OrigSendingTime, Tag 122 +func (h Header) GetOrigSendingTime() (f field.OrigSendingTimeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetDeliverToCompID gets DeliverToCompID, Tag 128 +func (h Header) GetDeliverToCompID() (f field.DeliverToCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetDeliverToSubID gets DeliverToSubID, Tag 129 +func (h Header) GetDeliverToSubID() (f field.DeliverToSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSenderLocationID gets SenderLocationID, Tag 142 +func (h Header) GetSenderLocationID() (f field.SenderLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetTargetLocationID gets TargetLocationID, Tag 143 +func (h Header) GetTargetLocationID() (f field.TargetLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOnBehalfOfLocationID gets OnBehalfOfLocationID, Tag 144 +func (h Header) GetOnBehalfOfLocationID() (f field.OnBehalfOfLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetDeliverToLocationID gets DeliverToLocationID, Tag 145 +func (h Header) GetDeliverToLocationID() (f field.DeliverToLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//HasBeginString returns true if BeginString is present, Tag 8 +func (h Header) HasBeginString() bool { + return h.Has(tag.BeginString) +} + +//HasBodyLength returns true if BodyLength is present, Tag 9 +func (h Header) HasBodyLength() bool { + return h.Has(tag.BodyLength) +} + +//HasMsgSeqNum returns true if MsgSeqNum is present, Tag 34 +func (h Header) HasMsgSeqNum() bool { + return h.Has(tag.MsgSeqNum) +} + +//HasMsgType returns true if MsgType is present, Tag 35 +func (h Header) HasMsgType() bool { + return h.Has(tag.MsgType) +} + +//HasPossDupFlag returns true if PossDupFlag is present, Tag 43 +func (h Header) HasPossDupFlag() bool { + return h.Has(tag.PossDupFlag) +} + +//HasSenderCompID returns true if SenderCompID is present, Tag 49 +func (h Header) HasSenderCompID() bool { + return h.Has(tag.SenderCompID) +} + +//HasSenderSubID returns true if SenderSubID is present, Tag 50 +func (h Header) HasSenderSubID() bool { + return h.Has(tag.SenderSubID) +} + +//HasSendingTime returns true if SendingTime is present, Tag 52 +func (h Header) HasSendingTime() bool { + return h.Has(tag.SendingTime) +} + +//HasTargetCompID returns true if TargetCompID is present, Tag 56 +func (h Header) HasTargetCompID() bool { + return h.Has(tag.TargetCompID) +} + +//HasTargetSubID returns true if TargetSubID is present, Tag 57 +func (h Header) HasTargetSubID() bool { + return h.Has(tag.TargetSubID) +} + +//HasSecureDataLen returns true if SecureDataLen is present, Tag 90 +func (h Header) HasSecureDataLen() bool { + return h.Has(tag.SecureDataLen) +} + +//HasSecureData returns true if SecureData is present, Tag 91 +func (h Header) HasSecureData() bool { + return h.Has(tag.SecureData) +} + +//HasPossResend returns true if PossResend is present, Tag 97 +func (h Header) HasPossResend() bool { + return h.Has(tag.PossResend) +} + +//HasOnBehalfOfCompID returns true if OnBehalfOfCompID is present, Tag 115 +func (h Header) HasOnBehalfOfCompID() bool { + return h.Has(tag.OnBehalfOfCompID) +} + +//HasOnBehalfOfSubID returns true if OnBehalfOfSubID is present, Tag 116 +func (h Header) HasOnBehalfOfSubID() bool { + return h.Has(tag.OnBehalfOfSubID) +} + +//HasOrigSendingTime returns true if OrigSendingTime is present, Tag 122 +func (h Header) HasOrigSendingTime() bool { + return h.Has(tag.OrigSendingTime) +} + +//HasDeliverToCompID returns true if DeliverToCompID is present, Tag 128 +func (h Header) HasDeliverToCompID() bool { + return h.Has(tag.DeliverToCompID) +} + +//HasDeliverToSubID returns true if DeliverToSubID is present, Tag 129 +func (h Header) HasDeliverToSubID() bool { + return h.Has(tag.DeliverToSubID) +} + +//HasSenderLocationID returns true if SenderLocationID is present, Tag 142 +func (h Header) HasSenderLocationID() bool { + return h.Has(tag.SenderLocationID) +} + +//HasTargetLocationID returns true if TargetLocationID is present, Tag 143 +func (h Header) HasTargetLocationID() bool { + return h.Has(tag.TargetLocationID) +} + +//HasOnBehalfOfLocationID returns true if OnBehalfOfLocationID is present, Tag 144 +func (h Header) HasOnBehalfOfLocationID() bool { + return h.Has(tag.OnBehalfOfLocationID) +} + +//HasDeliverToLocationID returns true if DeliverToLocationID is present, Tag 145 +func (h Header) HasDeliverToLocationID() bool { + return h.Has(tag.DeliverToLocationID) +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix41/newordersingle/NewOrderSingle.generated.go b/vendor/github.com/quickfixgo/quickfix/fix41/newordersingle/NewOrderSingle.generated.go new file mode 100644 index 0000000..3b339e2 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix41/newordersingle/NewOrderSingle.generated.go @@ -0,0 +1,882 @@ +package newordersingle + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fix41" + "github.com/quickfixgo/quickfix/tag" +) + +//NewOrderSingle is the fix41 NewOrderSingle type, MsgType = D +type NewOrderSingle struct { + fix41.Header + quickfix.Body + fix41.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a NewOrderSingle from a quickfix.Message instance +func FromMessage(m quickfix.Message) NewOrderSingle { + return NewOrderSingle{ + Header: fix41.Header{Header: m.Header}, + Body: m.Body, + Trailer: fix41.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m NewOrderSingle) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a NewOrderSingle initialized with the required fields for NewOrderSingle +func New(clordid field.ClOrdIDField, handlinst field.HandlInstField, symbol field.SymbolField, side field.SideField, ordtype field.OrdTypeField) (m NewOrderSingle) { + m.Header = fix41.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("D")) + m.Set(clordid) + m.Set(handlinst) + m.Set(symbol) + m.Set(side) + m.Set(ordtype) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg NewOrderSingle, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "FIX.4.1", "D", r +} + +//SetAccount sets Account, Tag 1 +func (m NewOrderSingle) SetAccount(v string) { + m.Set(field.NewAccount(v)) +} + +//SetClOrdID sets ClOrdID, Tag 11 +func (m NewOrderSingle) SetClOrdID(v string) { + m.Set(field.NewClOrdID(v)) +} + +//SetCommission sets Commission, Tag 12 +func (m NewOrderSingle) SetCommission(v float64) { + m.Set(field.NewCommission(v)) +} + +//SetCommType sets CommType, Tag 13 +func (m NewOrderSingle) SetCommType(v string) { + m.Set(field.NewCommType(v)) +} + +//SetCurrency sets Currency, Tag 15 +func (m NewOrderSingle) SetCurrency(v string) { + m.Set(field.NewCurrency(v)) +} + +//SetExecInst sets ExecInst, Tag 18 +func (m NewOrderSingle) SetExecInst(v string) { + m.Set(field.NewExecInst(v)) +} + +//SetHandlInst sets HandlInst, Tag 21 +func (m NewOrderSingle) SetHandlInst(v string) { + m.Set(field.NewHandlInst(v)) +} + +//SetIDSource sets IDSource, Tag 22 +func (m NewOrderSingle) SetIDSource(v string) { + m.Set(field.NewIDSource(v)) +} + +//SetIOIid sets IOIid, Tag 23 +func (m NewOrderSingle) SetIOIid(v string) { + m.Set(field.NewIOIid(v)) +} + +//SetOrderQty sets OrderQty, Tag 38 +func (m NewOrderSingle) SetOrderQty(v float64) { + m.Set(field.NewOrderQty(v)) +} + +//SetOrdType sets OrdType, Tag 40 +func (m NewOrderSingle) SetOrdType(v string) { + m.Set(field.NewOrdType(v)) +} + +//SetPrice sets Price, Tag 44 +func (m NewOrderSingle) SetPrice(v float64) { + m.Set(field.NewPrice(v)) +} + +//SetRule80A sets Rule80A, Tag 47 +func (m NewOrderSingle) SetRule80A(v string) { + m.Set(field.NewRule80A(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m NewOrderSingle) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSide sets Side, Tag 54 +func (m NewOrderSingle) SetSide(v string) { + m.Set(field.NewSide(v)) +} + +//SetSymbol sets Symbol, Tag 55 +func (m NewOrderSingle) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetText sets Text, Tag 58 +func (m NewOrderSingle) SetText(v string) { + m.Set(field.NewText(v)) +} + +//SetTimeInForce sets TimeInForce, Tag 59 +func (m NewOrderSingle) SetTimeInForce(v string) { + m.Set(field.NewTimeInForce(v)) +} + +//SetSettlmntTyp sets SettlmntTyp, Tag 63 +func (m NewOrderSingle) SetSettlmntTyp(v string) { + m.Set(field.NewSettlmntTyp(v)) +} + +//SetFutSettDate sets FutSettDate, Tag 64 +func (m NewOrderSingle) SetFutSettDate(v string) { + m.Set(field.NewFutSettDate(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m NewOrderSingle) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetExecBroker sets ExecBroker, Tag 76 +func (m NewOrderSingle) SetExecBroker(v string) { + m.Set(field.NewExecBroker(v)) +} + +//SetOpenClose sets OpenClose, Tag 77 +func (m NewOrderSingle) SetOpenClose(v string) { + m.Set(field.NewOpenClose(v)) +} + +//SetProcessCode sets ProcessCode, Tag 81 +func (m NewOrderSingle) SetProcessCode(v string) { + m.Set(field.NewProcessCode(v)) +} + +//SetStopPx sets StopPx, Tag 99 +func (m NewOrderSingle) SetStopPx(v float64) { + m.Set(field.NewStopPx(v)) +} + +//SetExDestination sets ExDestination, Tag 100 +func (m NewOrderSingle) SetExDestination(v string) { + m.Set(field.NewExDestination(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m NewOrderSingle) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m NewOrderSingle) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetClientID sets ClientID, Tag 109 +func (m NewOrderSingle) SetClientID(v string) { + m.Set(field.NewClientID(v)) +} + +//SetMinQty sets MinQty, Tag 110 +func (m NewOrderSingle) SetMinQty(v float64) { + m.Set(field.NewMinQty(v)) +} + +//SetMaxFloor sets MaxFloor, Tag 111 +func (m NewOrderSingle) SetMaxFloor(v float64) { + m.Set(field.NewMaxFloor(v)) +} + +//SetLocateReqd sets LocateReqd, Tag 114 +func (m NewOrderSingle) SetLocateReqd(v bool) { + m.Set(field.NewLocateReqd(v)) +} + +//SetQuoteID sets QuoteID, Tag 117 +func (m NewOrderSingle) SetQuoteID(v string) { + m.Set(field.NewQuoteID(v)) +} + +//SetSettlCurrency sets SettlCurrency, Tag 120 +func (m NewOrderSingle) SetSettlCurrency(v string) { + m.Set(field.NewSettlCurrency(v)) +} + +//SetForexReq sets ForexReq, Tag 121 +func (m NewOrderSingle) SetForexReq(v bool) { + m.Set(field.NewForexReq(v)) +} + +//SetExpireTime sets ExpireTime, Tag 126 +func (m NewOrderSingle) SetExpireTime(v time.Time) { + m.Set(field.NewExpireTime(v)) +} + +//SetPrevClosePx sets PrevClosePx, Tag 140 +func (m NewOrderSingle) SetPrevClosePx(v float64) { + m.Set(field.NewPrevClosePx(v)) +} + +//SetCashOrderQty sets CashOrderQty, Tag 152 +func (m NewOrderSingle) SetCashOrderQty(v float64) { + m.Set(field.NewCashOrderQty(v)) +} + +//SetSecurityType sets SecurityType, Tag 167 +func (m NewOrderSingle) SetSecurityType(v string) { + m.Set(field.NewSecurityType(v)) +} + +//SetOrderQty2 sets OrderQty2, Tag 192 +func (m NewOrderSingle) SetOrderQty2(v float64) { + m.Set(field.NewOrderQty2(v)) +} + +//SetFutSettDate2 sets FutSettDate2, Tag 193 +func (m NewOrderSingle) SetFutSettDate2(v string) { + m.Set(field.NewFutSettDate2(v)) +} + +//SetMaturityMonthYear sets MaturityMonthYear, Tag 200 +func (m NewOrderSingle) SetMaturityMonthYear(v string) { + m.Set(field.NewMaturityMonthYear(v)) +} + +//SetPutOrCall sets PutOrCall, Tag 201 +func (m NewOrderSingle) SetPutOrCall(v int) { + m.Set(field.NewPutOrCall(v)) +} + +//SetStrikePrice sets StrikePrice, Tag 202 +func (m NewOrderSingle) SetStrikePrice(v float64) { + m.Set(field.NewStrikePrice(v)) +} + +//SetCoveredOrUncovered sets CoveredOrUncovered, Tag 203 +func (m NewOrderSingle) SetCoveredOrUncovered(v int) { + m.Set(field.NewCoveredOrUncovered(v)) +} + +//SetCustomerOrFirm sets CustomerOrFirm, Tag 204 +func (m NewOrderSingle) SetCustomerOrFirm(v int) { + m.Set(field.NewCustomerOrFirm(v)) +} + +//SetMaturityDay sets MaturityDay, Tag 205 +func (m NewOrderSingle) SetMaturityDay(v int) { + m.Set(field.NewMaturityDay(v)) +} + +//SetOptAttribute sets OptAttribute, Tag 206 +func (m NewOrderSingle) SetOptAttribute(v string) { + m.Set(field.NewOptAttribute(v)) +} + +//SetSecurityExchange sets SecurityExchange, Tag 207 +func (m NewOrderSingle) SetSecurityExchange(v string) { + m.Set(field.NewSecurityExchange(v)) +} + +//SetMaxShow sets MaxShow, Tag 210 +func (m NewOrderSingle) SetMaxShow(v float64) { + m.Set(field.NewMaxShow(v)) +} + +//SetPegDifference sets PegDifference, Tag 211 +func (m NewOrderSingle) SetPegDifference(v float64) { + m.Set(field.NewPegDifference(v)) +} + +//GetAccount gets Account, Tag 1 +func (m NewOrderSingle) GetAccount() (f field.AccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdID gets ClOrdID, Tag 11 +func (m NewOrderSingle) GetClOrdID() (f field.ClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommission gets Commission, Tag 12 +func (m NewOrderSingle) GetCommission() (f field.CommissionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommType gets CommType, Tag 13 +func (m NewOrderSingle) GetCommType() (f field.CommTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCurrency gets Currency, Tag 15 +func (m NewOrderSingle) GetCurrency() (f field.CurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecInst gets ExecInst, Tag 18 +func (m NewOrderSingle) GetExecInst() (f field.ExecInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetHandlInst gets HandlInst, Tag 21 +func (m NewOrderSingle) GetHandlInst() (f field.HandlInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIDSource gets IDSource, Tag 22 +func (m NewOrderSingle) GetIDSource() (f field.IDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIOIid gets IOIid, Tag 23 +func (m NewOrderSingle) GetIOIid() (f field.IOIidField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty gets OrderQty, Tag 38 +func (m NewOrderSingle) GetOrderQty() (f field.OrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdType gets OrdType, Tag 40 +func (m NewOrderSingle) GetOrdType() (f field.OrdTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrice gets Price, Tag 44 +func (m NewOrderSingle) GetPrice() (f field.PriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRule80A gets Rule80A, Tag 47 +func (m NewOrderSingle) GetRule80A() (f field.Rule80AField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m NewOrderSingle) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSide gets Side, Tag 54 +func (m NewOrderSingle) GetSide() (f field.SideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbol gets Symbol, Tag 55 +func (m NewOrderSingle) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetText gets Text, Tag 58 +func (m NewOrderSingle) GetText() (f field.TextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTimeInForce gets TimeInForce, Tag 59 +func (m NewOrderSingle) GetTimeInForce() (f field.TimeInForceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlmntTyp gets SettlmntTyp, Tag 63 +func (m NewOrderSingle) GetSettlmntTyp() (f field.SettlmntTypField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFutSettDate gets FutSettDate, Tag 64 +func (m NewOrderSingle) GetFutSettDate() (f field.FutSettDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m NewOrderSingle) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecBroker gets ExecBroker, Tag 76 +func (m NewOrderSingle) GetExecBroker() (f field.ExecBrokerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOpenClose gets OpenClose, Tag 77 +func (m NewOrderSingle) GetOpenClose() (f field.OpenCloseField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetProcessCode gets ProcessCode, Tag 81 +func (m NewOrderSingle) GetProcessCode() (f field.ProcessCodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStopPx gets StopPx, Tag 99 +func (m NewOrderSingle) GetStopPx() (f field.StopPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExDestination gets ExDestination, Tag 100 +func (m NewOrderSingle) GetExDestination() (f field.ExDestinationField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m NewOrderSingle) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m NewOrderSingle) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClientID gets ClientID, Tag 109 +func (m NewOrderSingle) GetClientID() (f field.ClientIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMinQty gets MinQty, Tag 110 +func (m NewOrderSingle) GetMinQty() (f field.MinQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxFloor gets MaxFloor, Tag 111 +func (m NewOrderSingle) GetMaxFloor() (f field.MaxFloorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLocateReqd gets LocateReqd, Tag 114 +func (m NewOrderSingle) GetLocateReqd() (f field.LocateReqdField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetQuoteID gets QuoteID, Tag 117 +func (m NewOrderSingle) GetQuoteID() (f field.QuoteIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrency gets SettlCurrency, Tag 120 +func (m NewOrderSingle) GetSettlCurrency() (f field.SettlCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetForexReq gets ForexReq, Tag 121 +func (m NewOrderSingle) GetForexReq() (f field.ForexReqField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireTime gets ExpireTime, Tag 126 +func (m NewOrderSingle) GetExpireTime() (f field.ExpireTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrevClosePx gets PrevClosePx, Tag 140 +func (m NewOrderSingle) GetPrevClosePx() (f field.PrevClosePxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashOrderQty gets CashOrderQty, Tag 152 +func (m NewOrderSingle) GetCashOrderQty() (f field.CashOrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityType gets SecurityType, Tag 167 +func (m NewOrderSingle) GetSecurityType() (f field.SecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty2 gets OrderQty2, Tag 192 +func (m NewOrderSingle) GetOrderQty2() (f field.OrderQty2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFutSettDate2 gets FutSettDate2, Tag 193 +func (m NewOrderSingle) GetFutSettDate2() (f field.FutSettDate2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityMonthYear gets MaturityMonthYear, Tag 200 +func (m NewOrderSingle) GetMaturityMonthYear() (f field.MaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPutOrCall gets PutOrCall, Tag 201 +func (m NewOrderSingle) GetPutOrCall() (f field.PutOrCallField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikePrice gets StrikePrice, Tag 202 +func (m NewOrderSingle) GetStrikePrice() (f field.StrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCoveredOrUncovered gets CoveredOrUncovered, Tag 203 +func (m NewOrderSingle) GetCoveredOrUncovered() (f field.CoveredOrUncoveredField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCustomerOrFirm gets CustomerOrFirm, Tag 204 +func (m NewOrderSingle) GetCustomerOrFirm() (f field.CustomerOrFirmField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityDay gets MaturityDay, Tag 205 +func (m NewOrderSingle) GetMaturityDay() (f field.MaturityDayField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOptAttribute gets OptAttribute, Tag 206 +func (m NewOrderSingle) GetOptAttribute() (f field.OptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityExchange gets SecurityExchange, Tag 207 +func (m NewOrderSingle) GetSecurityExchange() (f field.SecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxShow gets MaxShow, Tag 210 +func (m NewOrderSingle) GetMaxShow() (f field.MaxShowField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegDifference gets PegDifference, Tag 211 +func (m NewOrderSingle) GetPegDifference() (f field.PegDifferenceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasAccount returns true if Account is present, Tag 1 +func (m NewOrderSingle) HasAccount() bool { + return m.Has(tag.Account) +} + +//HasClOrdID returns true if ClOrdID is present, Tag 11 +func (m NewOrderSingle) HasClOrdID() bool { + return m.Has(tag.ClOrdID) +} + +//HasCommission returns true if Commission is present, Tag 12 +func (m NewOrderSingle) HasCommission() bool { + return m.Has(tag.Commission) +} + +//HasCommType returns true if CommType is present, Tag 13 +func (m NewOrderSingle) HasCommType() bool { + return m.Has(tag.CommType) +} + +//HasCurrency returns true if Currency is present, Tag 15 +func (m NewOrderSingle) HasCurrency() bool { + return m.Has(tag.Currency) +} + +//HasExecInst returns true if ExecInst is present, Tag 18 +func (m NewOrderSingle) HasExecInst() bool { + return m.Has(tag.ExecInst) +} + +//HasHandlInst returns true if HandlInst is present, Tag 21 +func (m NewOrderSingle) HasHandlInst() bool { + return m.Has(tag.HandlInst) +} + +//HasIDSource returns true if IDSource is present, Tag 22 +func (m NewOrderSingle) HasIDSource() bool { + return m.Has(tag.IDSource) +} + +//HasIOIid returns true if IOIid is present, Tag 23 +func (m NewOrderSingle) HasIOIid() bool { + return m.Has(tag.IOIid) +} + +//HasOrderQty returns true if OrderQty is present, Tag 38 +func (m NewOrderSingle) HasOrderQty() bool { + return m.Has(tag.OrderQty) +} + +//HasOrdType returns true if OrdType is present, Tag 40 +func (m NewOrderSingle) HasOrdType() bool { + return m.Has(tag.OrdType) +} + +//HasPrice returns true if Price is present, Tag 44 +func (m NewOrderSingle) HasPrice() bool { + return m.Has(tag.Price) +} + +//HasRule80A returns true if Rule80A is present, Tag 47 +func (m NewOrderSingle) HasRule80A() bool { + return m.Has(tag.Rule80A) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m NewOrderSingle) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSide returns true if Side is present, Tag 54 +func (m NewOrderSingle) HasSide() bool { + return m.Has(tag.Side) +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m NewOrderSingle) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasText returns true if Text is present, Tag 58 +func (m NewOrderSingle) HasText() bool { + return m.Has(tag.Text) +} + +//HasTimeInForce returns true if TimeInForce is present, Tag 59 +func (m NewOrderSingle) HasTimeInForce() bool { + return m.Has(tag.TimeInForce) +} + +//HasSettlmntTyp returns true if SettlmntTyp is present, Tag 63 +func (m NewOrderSingle) HasSettlmntTyp() bool { + return m.Has(tag.SettlmntTyp) +} + +//HasFutSettDate returns true if FutSettDate is present, Tag 64 +func (m NewOrderSingle) HasFutSettDate() bool { + return m.Has(tag.FutSettDate) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m NewOrderSingle) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasExecBroker returns true if ExecBroker is present, Tag 76 +func (m NewOrderSingle) HasExecBroker() bool { + return m.Has(tag.ExecBroker) +} + +//HasOpenClose returns true if OpenClose is present, Tag 77 +func (m NewOrderSingle) HasOpenClose() bool { + return m.Has(tag.OpenClose) +} + +//HasProcessCode returns true if ProcessCode is present, Tag 81 +func (m NewOrderSingle) HasProcessCode() bool { + return m.Has(tag.ProcessCode) +} + +//HasStopPx returns true if StopPx is present, Tag 99 +func (m NewOrderSingle) HasStopPx() bool { + return m.Has(tag.StopPx) +} + +//HasExDestination returns true if ExDestination is present, Tag 100 +func (m NewOrderSingle) HasExDestination() bool { + return m.Has(tag.ExDestination) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m NewOrderSingle) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m NewOrderSingle) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasClientID returns true if ClientID is present, Tag 109 +func (m NewOrderSingle) HasClientID() bool { + return m.Has(tag.ClientID) +} + +//HasMinQty returns true if MinQty is present, Tag 110 +func (m NewOrderSingle) HasMinQty() bool { + return m.Has(tag.MinQty) +} + +//HasMaxFloor returns true if MaxFloor is present, Tag 111 +func (m NewOrderSingle) HasMaxFloor() bool { + return m.Has(tag.MaxFloor) +} + +//HasLocateReqd returns true if LocateReqd is present, Tag 114 +func (m NewOrderSingle) HasLocateReqd() bool { + return m.Has(tag.LocateReqd) +} + +//HasQuoteID returns true if QuoteID is present, Tag 117 +func (m NewOrderSingle) HasQuoteID() bool { + return m.Has(tag.QuoteID) +} + +//HasSettlCurrency returns true if SettlCurrency is present, Tag 120 +func (m NewOrderSingle) HasSettlCurrency() bool { + return m.Has(tag.SettlCurrency) +} + +//HasForexReq returns true if ForexReq is present, Tag 121 +func (m NewOrderSingle) HasForexReq() bool { + return m.Has(tag.ForexReq) +} + +//HasExpireTime returns true if ExpireTime is present, Tag 126 +func (m NewOrderSingle) HasExpireTime() bool { + return m.Has(tag.ExpireTime) +} + +//HasPrevClosePx returns true if PrevClosePx is present, Tag 140 +func (m NewOrderSingle) HasPrevClosePx() bool { + return m.Has(tag.PrevClosePx) +} + +//HasCashOrderQty returns true if CashOrderQty is present, Tag 152 +func (m NewOrderSingle) HasCashOrderQty() bool { + return m.Has(tag.CashOrderQty) +} + +//HasSecurityType returns true if SecurityType is present, Tag 167 +func (m NewOrderSingle) HasSecurityType() bool { + return m.Has(tag.SecurityType) +} + +//HasOrderQty2 returns true if OrderQty2 is present, Tag 192 +func (m NewOrderSingle) HasOrderQty2() bool { + return m.Has(tag.OrderQty2) +} + +//HasFutSettDate2 returns true if FutSettDate2 is present, Tag 193 +func (m NewOrderSingle) HasFutSettDate2() bool { + return m.Has(tag.FutSettDate2) +} + +//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200 +func (m NewOrderSingle) HasMaturityMonthYear() bool { + return m.Has(tag.MaturityMonthYear) +} + +//HasPutOrCall returns true if PutOrCall is present, Tag 201 +func (m NewOrderSingle) HasPutOrCall() bool { + return m.Has(tag.PutOrCall) +} + +//HasStrikePrice returns true if StrikePrice is present, Tag 202 +func (m NewOrderSingle) HasStrikePrice() bool { + return m.Has(tag.StrikePrice) +} + +//HasCoveredOrUncovered returns true if CoveredOrUncovered is present, Tag 203 +func (m NewOrderSingle) HasCoveredOrUncovered() bool { + return m.Has(tag.CoveredOrUncovered) +} + +//HasCustomerOrFirm returns true if CustomerOrFirm is present, Tag 204 +func (m NewOrderSingle) HasCustomerOrFirm() bool { + return m.Has(tag.CustomerOrFirm) +} + +//HasMaturityDay returns true if MaturityDay is present, Tag 205 +func (m NewOrderSingle) HasMaturityDay() bool { + return m.Has(tag.MaturityDay) +} + +//HasOptAttribute returns true if OptAttribute is present, Tag 206 +func (m NewOrderSingle) HasOptAttribute() bool { + return m.Has(tag.OptAttribute) +} + +//HasSecurityExchange returns true if SecurityExchange is present, Tag 207 +func (m NewOrderSingle) HasSecurityExchange() bool { + return m.Has(tag.SecurityExchange) +} + +//HasMaxShow returns true if MaxShow is present, Tag 210 +func (m NewOrderSingle) HasMaxShow() bool { + return m.Has(tag.MaxShow) +} + +//HasPegDifference returns true if PegDifference is present, Tag 211 +func (m NewOrderSingle) HasPegDifference() bool { + return m.Has(tag.PegDifference) +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix41/ordercancelrequest/OrderCancelRequest.generated.go b/vendor/github.com/quickfixgo/quickfix/fix41/ordercancelrequest/OrderCancelRequest.generated.go new file mode 100644 index 0000000..b8eb370 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix41/ordercancelrequest/OrderCancelRequest.generated.go @@ -0,0 +1,433 @@ +package ordercancelrequest + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fix41" + "github.com/quickfixgo/quickfix/tag" +) + +//OrderCancelRequest is the fix41 OrderCancelRequest type, MsgType = F +type OrderCancelRequest struct { + fix41.Header + quickfix.Body + fix41.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a OrderCancelRequest from a quickfix.Message instance +func FromMessage(m quickfix.Message) OrderCancelRequest { + return OrderCancelRequest{ + Header: fix41.Header{Header: m.Header}, + Body: m.Body, + Trailer: fix41.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m OrderCancelRequest) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a OrderCancelRequest initialized with the required fields for OrderCancelRequest +func New(origclordid field.OrigClOrdIDField, clordid field.ClOrdIDField, symbol field.SymbolField, side field.SideField) (m OrderCancelRequest) { + m.Header = fix41.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("F")) + m.Set(origclordid) + m.Set(clordid) + m.Set(symbol) + m.Set(side) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg OrderCancelRequest, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "FIX.4.1", "F", r +} + +//SetClOrdID sets ClOrdID, Tag 11 +func (m OrderCancelRequest) SetClOrdID(v string) { + m.Set(field.NewClOrdID(v)) +} + +//SetIDSource sets IDSource, Tag 22 +func (m OrderCancelRequest) SetIDSource(v string) { + m.Set(field.NewIDSource(v)) +} + +//SetOrderID sets OrderID, Tag 37 +func (m OrderCancelRequest) SetOrderID(v string) { + m.Set(field.NewOrderID(v)) +} + +//SetOrderQty sets OrderQty, Tag 38 +func (m OrderCancelRequest) SetOrderQty(v float64) { + m.Set(field.NewOrderQty(v)) +} + +//SetOrigClOrdID sets OrigClOrdID, Tag 41 +func (m OrderCancelRequest) SetOrigClOrdID(v string) { + m.Set(field.NewOrigClOrdID(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m OrderCancelRequest) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSide sets Side, Tag 54 +func (m OrderCancelRequest) SetSide(v string) { + m.Set(field.NewSide(v)) +} + +//SetSymbol sets Symbol, Tag 55 +func (m OrderCancelRequest) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetText sets Text, Tag 58 +func (m OrderCancelRequest) SetText(v string) { + m.Set(field.NewText(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m OrderCancelRequest) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetListID sets ListID, Tag 66 +func (m OrderCancelRequest) SetListID(v string) { + m.Set(field.NewListID(v)) +} + +//SetExecBroker sets ExecBroker, Tag 76 +func (m OrderCancelRequest) SetExecBroker(v string) { + m.Set(field.NewExecBroker(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m OrderCancelRequest) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m OrderCancelRequest) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetClientID sets ClientID, Tag 109 +func (m OrderCancelRequest) SetClientID(v string) { + m.Set(field.NewClientID(v)) +} + +//SetCashOrderQty sets CashOrderQty, Tag 152 +func (m OrderCancelRequest) SetCashOrderQty(v float64) { + m.Set(field.NewCashOrderQty(v)) +} + +//SetSecurityType sets SecurityType, Tag 167 +func (m OrderCancelRequest) SetSecurityType(v string) { + m.Set(field.NewSecurityType(v)) +} + +//SetMaturityMonthYear sets MaturityMonthYear, Tag 200 +func (m OrderCancelRequest) SetMaturityMonthYear(v string) { + m.Set(field.NewMaturityMonthYear(v)) +} + +//SetPutOrCall sets PutOrCall, Tag 201 +func (m OrderCancelRequest) SetPutOrCall(v int) { + m.Set(field.NewPutOrCall(v)) +} + +//SetStrikePrice sets StrikePrice, Tag 202 +func (m OrderCancelRequest) SetStrikePrice(v float64) { + m.Set(field.NewStrikePrice(v)) +} + +//SetMaturityDay sets MaturityDay, Tag 205 +func (m OrderCancelRequest) SetMaturityDay(v int) { + m.Set(field.NewMaturityDay(v)) +} + +//SetOptAttribute sets OptAttribute, Tag 206 +func (m OrderCancelRequest) SetOptAttribute(v string) { + m.Set(field.NewOptAttribute(v)) +} + +//SetSecurityExchange sets SecurityExchange, Tag 207 +func (m OrderCancelRequest) SetSecurityExchange(v string) { + m.Set(field.NewSecurityExchange(v)) +} + +//GetClOrdID gets ClOrdID, Tag 11 +func (m OrderCancelRequest) GetClOrdID() (f field.ClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIDSource gets IDSource, Tag 22 +func (m OrderCancelRequest) GetIDSource() (f field.IDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderID gets OrderID, Tag 37 +func (m OrderCancelRequest) GetOrderID() (f field.OrderIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty gets OrderQty, Tag 38 +func (m OrderCancelRequest) GetOrderQty() (f field.OrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrigClOrdID gets OrigClOrdID, Tag 41 +func (m OrderCancelRequest) GetOrigClOrdID() (f field.OrigClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m OrderCancelRequest) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSide gets Side, Tag 54 +func (m OrderCancelRequest) GetSide() (f field.SideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbol gets Symbol, Tag 55 +func (m OrderCancelRequest) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetText gets Text, Tag 58 +func (m OrderCancelRequest) GetText() (f field.TextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m OrderCancelRequest) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetListID gets ListID, Tag 66 +func (m OrderCancelRequest) GetListID() (f field.ListIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecBroker gets ExecBroker, Tag 76 +func (m OrderCancelRequest) GetExecBroker() (f field.ExecBrokerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m OrderCancelRequest) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m OrderCancelRequest) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClientID gets ClientID, Tag 109 +func (m OrderCancelRequest) GetClientID() (f field.ClientIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashOrderQty gets CashOrderQty, Tag 152 +func (m OrderCancelRequest) GetCashOrderQty() (f field.CashOrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityType gets SecurityType, Tag 167 +func (m OrderCancelRequest) GetSecurityType() (f field.SecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityMonthYear gets MaturityMonthYear, Tag 200 +func (m OrderCancelRequest) GetMaturityMonthYear() (f field.MaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPutOrCall gets PutOrCall, Tag 201 +func (m OrderCancelRequest) GetPutOrCall() (f field.PutOrCallField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikePrice gets StrikePrice, Tag 202 +func (m OrderCancelRequest) GetStrikePrice() (f field.StrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityDay gets MaturityDay, Tag 205 +func (m OrderCancelRequest) GetMaturityDay() (f field.MaturityDayField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOptAttribute gets OptAttribute, Tag 206 +func (m OrderCancelRequest) GetOptAttribute() (f field.OptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityExchange gets SecurityExchange, Tag 207 +func (m OrderCancelRequest) GetSecurityExchange() (f field.SecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasClOrdID returns true if ClOrdID is present, Tag 11 +func (m OrderCancelRequest) HasClOrdID() bool { + return m.Has(tag.ClOrdID) +} + +//HasIDSource returns true if IDSource is present, Tag 22 +func (m OrderCancelRequest) HasIDSource() bool { + return m.Has(tag.IDSource) +} + +//HasOrderID returns true if OrderID is present, Tag 37 +func (m OrderCancelRequest) HasOrderID() bool { + return m.Has(tag.OrderID) +} + +//HasOrderQty returns true if OrderQty is present, Tag 38 +func (m OrderCancelRequest) HasOrderQty() bool { + return m.Has(tag.OrderQty) +} + +//HasOrigClOrdID returns true if OrigClOrdID is present, Tag 41 +func (m OrderCancelRequest) HasOrigClOrdID() bool { + return m.Has(tag.OrigClOrdID) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m OrderCancelRequest) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSide returns true if Side is present, Tag 54 +func (m OrderCancelRequest) HasSide() bool { + return m.Has(tag.Side) +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m OrderCancelRequest) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasText returns true if Text is present, Tag 58 +func (m OrderCancelRequest) HasText() bool { + return m.Has(tag.Text) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m OrderCancelRequest) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasListID returns true if ListID is present, Tag 66 +func (m OrderCancelRequest) HasListID() bool { + return m.Has(tag.ListID) +} + +//HasExecBroker returns true if ExecBroker is present, Tag 76 +func (m OrderCancelRequest) HasExecBroker() bool { + return m.Has(tag.ExecBroker) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m OrderCancelRequest) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m OrderCancelRequest) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasClientID returns true if ClientID is present, Tag 109 +func (m OrderCancelRequest) HasClientID() bool { + return m.Has(tag.ClientID) +} + +//HasCashOrderQty returns true if CashOrderQty is present, Tag 152 +func (m OrderCancelRequest) HasCashOrderQty() bool { + return m.Has(tag.CashOrderQty) +} + +//HasSecurityType returns true if SecurityType is present, Tag 167 +func (m OrderCancelRequest) HasSecurityType() bool { + return m.Has(tag.SecurityType) +} + +//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200 +func (m OrderCancelRequest) HasMaturityMonthYear() bool { + return m.Has(tag.MaturityMonthYear) +} + +//HasPutOrCall returns true if PutOrCall is present, Tag 201 +func (m OrderCancelRequest) HasPutOrCall() bool { + return m.Has(tag.PutOrCall) +} + +//HasStrikePrice returns true if StrikePrice is present, Tag 202 +func (m OrderCancelRequest) HasStrikePrice() bool { + return m.Has(tag.StrikePrice) +} + +//HasMaturityDay returns true if MaturityDay is present, Tag 205 +func (m OrderCancelRequest) HasMaturityDay() bool { + return m.Has(tag.MaturityDay) +} + +//HasOptAttribute returns true if OptAttribute is present, Tag 206 +func (m OrderCancelRequest) HasOptAttribute() bool { + return m.Has(tag.OptAttribute) +} + +//HasSecurityExchange returns true if SecurityExchange is present, Tag 207 +func (m OrderCancelRequest) HasSecurityExchange() bool { + return m.Has(tag.SecurityExchange) +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix41/trailer.generated.go b/vendor/github.com/quickfixgo/quickfix/fix41/trailer.generated.go new file mode 100644 index 0000000..63b47b6 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix41/trailer.generated.go @@ -0,0 +1,60 @@ +package fix41 + +import ( + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/tag" +) + +//Trailer is the fix41 Trailer type +type Trailer struct { + quickfix.Trailer +} + +//SetCheckSum sets CheckSum, Tag 10 +func (t Trailer) SetCheckSum(v string) { + t.Set(field.NewCheckSum(v)) +} + +//SetSignature sets Signature, Tag 89 +func (t Trailer) SetSignature(v string) { + t.Set(field.NewSignature(v)) +} + +//SetSignatureLength sets SignatureLength, Tag 93 +func (t Trailer) SetSignatureLength(v int) { + t.Set(field.NewSignatureLength(v)) +} + +//GetCheckSum gets CheckSum, Tag 10 +func (t Trailer) GetCheckSum() (f field.CheckSumField, err quickfix.MessageRejectError) { + err = t.Get(&f) + return +} + +//GetSignature gets Signature, Tag 89 +func (t Trailer) GetSignature() (f field.SignatureField, err quickfix.MessageRejectError) { + err = t.Get(&f) + return +} + +//GetSignatureLength gets SignatureLength, Tag 93 +func (t Trailer) GetSignatureLength() (f field.SignatureLengthField, err quickfix.MessageRejectError) { + err = t.Get(&f) + return +} + +//HasCheckSum returns true if CheckSum is present, Tag 10 +func (t Trailer) HasCheckSum() bool { + return t.Has(tag.CheckSum) +} + +//HasSignature returns true if Signature is present, Tag 89 +func (t Trailer) HasSignature() bool { + return t.Has(tag.Signature) +} + +//HasSignatureLength returns true if SignatureLength is present, Tag 93 +func (t Trailer) HasSignatureLength() bool { + return t.Has(tag.SignatureLength) +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix42/executionreport/ExecutionReport.generated.go b/vendor/github.com/quickfixgo/quickfix/fix42/executionreport/ExecutionReport.generated.go new file mode 100644 index 0000000..142b590 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix42/executionreport/ExecutionReport.generated.go @@ -0,0 +1,1636 @@ +package executionreport + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fix42" + "github.com/quickfixgo/quickfix/tag" +) + +//ExecutionReport is the fix42 ExecutionReport type, MsgType = 8 +type ExecutionReport struct { + fix42.Header + quickfix.Body + fix42.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a ExecutionReport from a quickfix.Message instance +func FromMessage(m quickfix.Message) ExecutionReport { + return ExecutionReport{ + Header: fix42.Header{Header: m.Header}, + Body: m.Body, + Trailer: fix42.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m ExecutionReport) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a ExecutionReport initialized with the required fields for ExecutionReport +func New(orderid field.OrderIDField, execid field.ExecIDField, exectranstype field.ExecTransTypeField, exectype field.ExecTypeField, ordstatus field.OrdStatusField, symbol field.SymbolField, side field.SideField, leavesqty field.LeavesQtyField, cumqty field.CumQtyField, avgpx field.AvgPxField) (m ExecutionReport) { + m.Header = fix42.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("8")) + m.Set(orderid) + m.Set(execid) + m.Set(exectranstype) + m.Set(exectype) + m.Set(ordstatus) + m.Set(symbol) + m.Set(side) + m.Set(leavesqty) + m.Set(cumqty) + m.Set(avgpx) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg ExecutionReport, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "FIX.4.2", "8", r +} + +//SetAccount sets Account, Tag 1 +func (m ExecutionReport) SetAccount(v string) { + m.Set(field.NewAccount(v)) +} + +//SetAvgPx sets AvgPx, Tag 6 +func (m ExecutionReport) SetAvgPx(v float64) { + m.Set(field.NewAvgPx(v)) +} + +//SetClOrdID sets ClOrdID, Tag 11 +func (m ExecutionReport) SetClOrdID(v string) { + m.Set(field.NewClOrdID(v)) +} + +//SetCommission sets Commission, Tag 12 +func (m ExecutionReport) SetCommission(v float64) { + m.Set(field.NewCommission(v)) +} + +//SetCommType sets CommType, Tag 13 +func (m ExecutionReport) SetCommType(v string) { + m.Set(field.NewCommType(v)) +} + +//SetCumQty sets CumQty, Tag 14 +func (m ExecutionReport) SetCumQty(v float64) { + m.Set(field.NewCumQty(v)) +} + +//SetCurrency sets Currency, Tag 15 +func (m ExecutionReport) SetCurrency(v string) { + m.Set(field.NewCurrency(v)) +} + +//SetExecID sets ExecID, Tag 17 +func (m ExecutionReport) SetExecID(v string) { + m.Set(field.NewExecID(v)) +} + +//SetExecInst sets ExecInst, Tag 18 +func (m ExecutionReport) SetExecInst(v string) { + m.Set(field.NewExecInst(v)) +} + +//SetExecRefID sets ExecRefID, Tag 19 +func (m ExecutionReport) SetExecRefID(v string) { + m.Set(field.NewExecRefID(v)) +} + +//SetExecTransType sets ExecTransType, Tag 20 +func (m ExecutionReport) SetExecTransType(v string) { + m.Set(field.NewExecTransType(v)) +} + +//SetHandlInst sets HandlInst, Tag 21 +func (m ExecutionReport) SetHandlInst(v string) { + m.Set(field.NewHandlInst(v)) +} + +//SetIDSource sets IDSource, Tag 22 +func (m ExecutionReport) SetIDSource(v string) { + m.Set(field.NewIDSource(v)) +} + +//SetLastCapacity sets LastCapacity, Tag 29 +func (m ExecutionReport) SetLastCapacity(v string) { + m.Set(field.NewLastCapacity(v)) +} + +//SetLastMkt sets LastMkt, Tag 30 +func (m ExecutionReport) SetLastMkt(v string) { + m.Set(field.NewLastMkt(v)) +} + +//SetLastPx sets LastPx, Tag 31 +func (m ExecutionReport) SetLastPx(v float64) { + m.Set(field.NewLastPx(v)) +} + +//SetLastShares sets LastShares, Tag 32 +func (m ExecutionReport) SetLastShares(v float64) { + m.Set(field.NewLastShares(v)) +} + +//SetOrderID sets OrderID, Tag 37 +func (m ExecutionReport) SetOrderID(v string) { + m.Set(field.NewOrderID(v)) +} + +//SetOrderQty sets OrderQty, Tag 38 +func (m ExecutionReport) SetOrderQty(v float64) { + m.Set(field.NewOrderQty(v)) +} + +//SetOrdStatus sets OrdStatus, Tag 39 +func (m ExecutionReport) SetOrdStatus(v string) { + m.Set(field.NewOrdStatus(v)) +} + +//SetOrdType sets OrdType, Tag 40 +func (m ExecutionReport) SetOrdType(v string) { + m.Set(field.NewOrdType(v)) +} + +//SetOrigClOrdID sets OrigClOrdID, Tag 41 +func (m ExecutionReport) SetOrigClOrdID(v string) { + m.Set(field.NewOrigClOrdID(v)) +} + +//SetPrice sets Price, Tag 44 +func (m ExecutionReport) SetPrice(v float64) { + m.Set(field.NewPrice(v)) +} + +//SetRule80A sets Rule80A, Tag 47 +func (m ExecutionReport) SetRule80A(v string) { + m.Set(field.NewRule80A(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m ExecutionReport) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSide sets Side, Tag 54 +func (m ExecutionReport) SetSide(v string) { + m.Set(field.NewSide(v)) +} + +//SetSymbol sets Symbol, Tag 55 +func (m ExecutionReport) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetText sets Text, Tag 58 +func (m ExecutionReport) SetText(v string) { + m.Set(field.NewText(v)) +} + +//SetTimeInForce sets TimeInForce, Tag 59 +func (m ExecutionReport) SetTimeInForce(v string) { + m.Set(field.NewTimeInForce(v)) +} + +//SetTransactTime sets TransactTime, Tag 60 +func (m ExecutionReport) SetTransactTime(v time.Time) { + m.Set(field.NewTransactTime(v)) +} + +//SetSettlmntTyp sets SettlmntTyp, Tag 63 +func (m ExecutionReport) SetSettlmntTyp(v string) { + m.Set(field.NewSettlmntTyp(v)) +} + +//SetFutSettDate sets FutSettDate, Tag 64 +func (m ExecutionReport) SetFutSettDate(v string) { + m.Set(field.NewFutSettDate(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m ExecutionReport) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetListID sets ListID, Tag 66 +func (m ExecutionReport) SetListID(v string) { + m.Set(field.NewListID(v)) +} + +//SetTradeDate sets TradeDate, Tag 75 +func (m ExecutionReport) SetTradeDate(v string) { + m.Set(field.NewTradeDate(v)) +} + +//SetExecBroker sets ExecBroker, Tag 76 +func (m ExecutionReport) SetExecBroker(v string) { + m.Set(field.NewExecBroker(v)) +} + +//SetOpenClose sets OpenClose, Tag 77 +func (m ExecutionReport) SetOpenClose(v string) { + m.Set(field.NewOpenClose(v)) +} + +//SetStopPx sets StopPx, Tag 99 +func (m ExecutionReport) SetStopPx(v float64) { + m.Set(field.NewStopPx(v)) +} + +//SetOrdRejReason sets OrdRejReason, Tag 103 +func (m ExecutionReport) SetOrdRejReason(v int) { + m.Set(field.NewOrdRejReason(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m ExecutionReport) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m ExecutionReport) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetClientID sets ClientID, Tag 109 +func (m ExecutionReport) SetClientID(v string) { + m.Set(field.NewClientID(v)) +} + +//SetMinQty sets MinQty, Tag 110 +func (m ExecutionReport) SetMinQty(v float64) { + m.Set(field.NewMinQty(v)) +} + +//SetMaxFloor sets MaxFloor, Tag 111 +func (m ExecutionReport) SetMaxFloor(v float64) { + m.Set(field.NewMaxFloor(v)) +} + +//SetReportToExch sets ReportToExch, Tag 113 +func (m ExecutionReport) SetReportToExch(v bool) { + m.Set(field.NewReportToExch(v)) +} + +//SetSettlCurrAmt sets SettlCurrAmt, Tag 119 +func (m ExecutionReport) SetSettlCurrAmt(v float64) { + m.Set(field.NewSettlCurrAmt(v)) +} + +//SetSettlCurrency sets SettlCurrency, Tag 120 +func (m ExecutionReport) SetSettlCurrency(v string) { + m.Set(field.NewSettlCurrency(v)) +} + +//SetExpireTime sets ExpireTime, Tag 126 +func (m ExecutionReport) SetExpireTime(v time.Time) { + m.Set(field.NewExpireTime(v)) +} + +//SetExecType sets ExecType, Tag 150 +func (m ExecutionReport) SetExecType(v string) { + m.Set(field.NewExecType(v)) +} + +//SetLeavesQty sets LeavesQty, Tag 151 +func (m ExecutionReport) SetLeavesQty(v float64) { + m.Set(field.NewLeavesQty(v)) +} + +//SetCashOrderQty sets CashOrderQty, Tag 152 +func (m ExecutionReport) SetCashOrderQty(v float64) { + m.Set(field.NewCashOrderQty(v)) +} + +//SetSettlCurrFxRate sets SettlCurrFxRate, Tag 155 +func (m ExecutionReport) SetSettlCurrFxRate(v float64) { + m.Set(field.NewSettlCurrFxRate(v)) +} + +//SetSettlCurrFxRateCalc sets SettlCurrFxRateCalc, Tag 156 +func (m ExecutionReport) SetSettlCurrFxRateCalc(v string) { + m.Set(field.NewSettlCurrFxRateCalc(v)) +} + +//SetSecurityType sets SecurityType, Tag 167 +func (m ExecutionReport) SetSecurityType(v string) { + m.Set(field.NewSecurityType(v)) +} + +//SetEffectiveTime sets EffectiveTime, Tag 168 +func (m ExecutionReport) SetEffectiveTime(v time.Time) { + m.Set(field.NewEffectiveTime(v)) +} + +//SetOrderQty2 sets OrderQty2, Tag 192 +func (m ExecutionReport) SetOrderQty2(v float64) { + m.Set(field.NewOrderQty2(v)) +} + +//SetFutSettDate2 sets FutSettDate2, Tag 193 +func (m ExecutionReport) SetFutSettDate2(v string) { + m.Set(field.NewFutSettDate2(v)) +} + +//SetLastSpotRate sets LastSpotRate, Tag 194 +func (m ExecutionReport) SetLastSpotRate(v float64) { + m.Set(field.NewLastSpotRate(v)) +} + +//SetLastForwardPoints sets LastForwardPoints, Tag 195 +func (m ExecutionReport) SetLastForwardPoints(v float64) { + m.Set(field.NewLastForwardPoints(v)) +} + +//SetSecondaryOrderID sets SecondaryOrderID, Tag 198 +func (m ExecutionReport) SetSecondaryOrderID(v string) { + m.Set(field.NewSecondaryOrderID(v)) +} + +//SetMaturityMonthYear sets MaturityMonthYear, Tag 200 +func (m ExecutionReport) SetMaturityMonthYear(v string) { + m.Set(field.NewMaturityMonthYear(v)) +} + +//SetPutOrCall sets PutOrCall, Tag 201 +func (m ExecutionReport) SetPutOrCall(v int) { + m.Set(field.NewPutOrCall(v)) +} + +//SetStrikePrice sets StrikePrice, Tag 202 +func (m ExecutionReport) SetStrikePrice(v float64) { + m.Set(field.NewStrikePrice(v)) +} + +//SetMaturityDay sets MaturityDay, Tag 205 +func (m ExecutionReport) SetMaturityDay(v int) { + m.Set(field.NewMaturityDay(v)) +} + +//SetOptAttribute sets OptAttribute, Tag 206 +func (m ExecutionReport) SetOptAttribute(v string) { + m.Set(field.NewOptAttribute(v)) +} + +//SetSecurityExchange sets SecurityExchange, Tag 207 +func (m ExecutionReport) SetSecurityExchange(v string) { + m.Set(field.NewSecurityExchange(v)) +} + +//SetMaxShow sets MaxShow, Tag 210 +func (m ExecutionReport) SetMaxShow(v float64) { + m.Set(field.NewMaxShow(v)) +} + +//SetPegDifference sets PegDifference, Tag 211 +func (m ExecutionReport) SetPegDifference(v float64) { + m.Set(field.NewPegDifference(v)) +} + +//SetCouponRate sets CouponRate, Tag 223 +func (m ExecutionReport) SetCouponRate(v float64) { + m.Set(field.NewCouponRate(v)) +} + +//SetContractMultiplier sets ContractMultiplier, Tag 231 +func (m ExecutionReport) SetContractMultiplier(v float64) { + m.Set(field.NewContractMultiplier(v)) +} + +//SetTradingSessionID sets TradingSessionID, Tag 336 +func (m ExecutionReport) SetTradingSessionID(v string) { + m.Set(field.NewTradingSessionID(v)) +} + +//SetEncodedIssuerLen sets EncodedIssuerLen, Tag 348 +func (m ExecutionReport) SetEncodedIssuerLen(v int) { + m.Set(field.NewEncodedIssuerLen(v)) +} + +//SetEncodedIssuer sets EncodedIssuer, Tag 349 +func (m ExecutionReport) SetEncodedIssuer(v string) { + m.Set(field.NewEncodedIssuer(v)) +} + +//SetEncodedSecurityDescLen sets EncodedSecurityDescLen, Tag 350 +func (m ExecutionReport) SetEncodedSecurityDescLen(v int) { + m.Set(field.NewEncodedSecurityDescLen(v)) +} + +//SetEncodedSecurityDesc sets EncodedSecurityDesc, Tag 351 +func (m ExecutionReport) SetEncodedSecurityDesc(v string) { + m.Set(field.NewEncodedSecurityDesc(v)) +} + +//SetEncodedTextLen sets EncodedTextLen, Tag 354 +func (m ExecutionReport) SetEncodedTextLen(v int) { + m.Set(field.NewEncodedTextLen(v)) +} + +//SetEncodedText sets EncodedText, Tag 355 +func (m ExecutionReport) SetEncodedText(v string) { + m.Set(field.NewEncodedText(v)) +} + +//SetComplianceID sets ComplianceID, Tag 376 +func (m ExecutionReport) SetComplianceID(v string) { + m.Set(field.NewComplianceID(v)) +} + +//SetSolicitedFlag sets SolicitedFlag, Tag 377 +func (m ExecutionReport) SetSolicitedFlag(v bool) { + m.Set(field.NewSolicitedFlag(v)) +} + +//SetExecRestatementReason sets ExecRestatementReason, Tag 378 +func (m ExecutionReport) SetExecRestatementReason(v int) { + m.Set(field.NewExecRestatementReason(v)) +} + +//SetGrossTradeAmt sets GrossTradeAmt, Tag 381 +func (m ExecutionReport) SetGrossTradeAmt(v float64) { + m.Set(field.NewGrossTradeAmt(v)) +} + +//SetNoContraBrokers sets NoContraBrokers, Tag 382 +func (m ExecutionReport) SetNoContraBrokers(f NoContraBrokersRepeatingGroup) { + m.SetGroup(f) +} + +//SetDiscretionInst sets DiscretionInst, Tag 388 +func (m ExecutionReport) SetDiscretionInst(v string) { + m.Set(field.NewDiscretionInst(v)) +} + +//SetDiscretionOffset sets DiscretionOffset, Tag 389 +func (m ExecutionReport) SetDiscretionOffset(v float64) { + m.Set(field.NewDiscretionOffset(v)) +} + +//SetDayOrderQty sets DayOrderQty, Tag 424 +func (m ExecutionReport) SetDayOrderQty(v float64) { + m.Set(field.NewDayOrderQty(v)) +} + +//SetDayCumQty sets DayCumQty, Tag 425 +func (m ExecutionReport) SetDayCumQty(v float64) { + m.Set(field.NewDayCumQty(v)) +} + +//SetDayAvgPx sets DayAvgPx, Tag 426 +func (m ExecutionReport) SetDayAvgPx(v float64) { + m.Set(field.NewDayAvgPx(v)) +} + +//SetGTBookingInst sets GTBookingInst, Tag 427 +func (m ExecutionReport) SetGTBookingInst(v int) { + m.Set(field.NewGTBookingInst(v)) +} + +//SetExpireDate sets ExpireDate, Tag 432 +func (m ExecutionReport) SetExpireDate(v string) { + m.Set(field.NewExpireDate(v)) +} + +//SetClearingFirm sets ClearingFirm, Tag 439 +func (m ExecutionReport) SetClearingFirm(v string) { + m.Set(field.NewClearingFirm(v)) +} + +//SetClearingAccount sets ClearingAccount, Tag 440 +func (m ExecutionReport) SetClearingAccount(v string) { + m.Set(field.NewClearingAccount(v)) +} + +//SetMultiLegReportingType sets MultiLegReportingType, Tag 442 +func (m ExecutionReport) SetMultiLegReportingType(v string) { + m.Set(field.NewMultiLegReportingType(v)) +} + +//GetAccount gets Account, Tag 1 +func (m ExecutionReport) GetAccount() (f field.AccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAvgPx gets AvgPx, Tag 6 +func (m ExecutionReport) GetAvgPx() (f field.AvgPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdID gets ClOrdID, Tag 11 +func (m ExecutionReport) GetClOrdID() (f field.ClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommission gets Commission, Tag 12 +func (m ExecutionReport) GetCommission() (f field.CommissionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommType gets CommType, Tag 13 +func (m ExecutionReport) GetCommType() (f field.CommTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCumQty gets CumQty, Tag 14 +func (m ExecutionReport) GetCumQty() (f field.CumQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCurrency gets Currency, Tag 15 +func (m ExecutionReport) GetCurrency() (f field.CurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecID gets ExecID, Tag 17 +func (m ExecutionReport) GetExecID() (f field.ExecIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecInst gets ExecInst, Tag 18 +func (m ExecutionReport) GetExecInst() (f field.ExecInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecRefID gets ExecRefID, Tag 19 +func (m ExecutionReport) GetExecRefID() (f field.ExecRefIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecTransType gets ExecTransType, Tag 20 +func (m ExecutionReport) GetExecTransType() (f field.ExecTransTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetHandlInst gets HandlInst, Tag 21 +func (m ExecutionReport) GetHandlInst() (f field.HandlInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIDSource gets IDSource, Tag 22 +func (m ExecutionReport) GetIDSource() (f field.IDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastCapacity gets LastCapacity, Tag 29 +func (m ExecutionReport) GetLastCapacity() (f field.LastCapacityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastMkt gets LastMkt, Tag 30 +func (m ExecutionReport) GetLastMkt() (f field.LastMktField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastPx gets LastPx, Tag 31 +func (m ExecutionReport) GetLastPx() (f field.LastPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastShares gets LastShares, Tag 32 +func (m ExecutionReport) GetLastShares() (f field.LastSharesField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderID gets OrderID, Tag 37 +func (m ExecutionReport) GetOrderID() (f field.OrderIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty gets OrderQty, Tag 38 +func (m ExecutionReport) GetOrderQty() (f field.OrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdStatus gets OrdStatus, Tag 39 +func (m ExecutionReport) GetOrdStatus() (f field.OrdStatusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdType gets OrdType, Tag 40 +func (m ExecutionReport) GetOrdType() (f field.OrdTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrigClOrdID gets OrigClOrdID, Tag 41 +func (m ExecutionReport) GetOrigClOrdID() (f field.OrigClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrice gets Price, Tag 44 +func (m ExecutionReport) GetPrice() (f field.PriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRule80A gets Rule80A, Tag 47 +func (m ExecutionReport) GetRule80A() (f field.Rule80AField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m ExecutionReport) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSide gets Side, Tag 54 +func (m ExecutionReport) GetSide() (f field.SideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbol gets Symbol, Tag 55 +func (m ExecutionReport) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetText gets Text, Tag 58 +func (m ExecutionReport) GetText() (f field.TextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTimeInForce gets TimeInForce, Tag 59 +func (m ExecutionReport) GetTimeInForce() (f field.TimeInForceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTransactTime gets TransactTime, Tag 60 +func (m ExecutionReport) GetTransactTime() (f field.TransactTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlmntTyp gets SettlmntTyp, Tag 63 +func (m ExecutionReport) GetSettlmntTyp() (f field.SettlmntTypField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFutSettDate gets FutSettDate, Tag 64 +func (m ExecutionReport) GetFutSettDate() (f field.FutSettDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m ExecutionReport) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetListID gets ListID, Tag 66 +func (m ExecutionReport) GetListID() (f field.ListIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradeDate gets TradeDate, Tag 75 +func (m ExecutionReport) GetTradeDate() (f field.TradeDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecBroker gets ExecBroker, Tag 76 +func (m ExecutionReport) GetExecBroker() (f field.ExecBrokerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOpenClose gets OpenClose, Tag 77 +func (m ExecutionReport) GetOpenClose() (f field.OpenCloseField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStopPx gets StopPx, Tag 99 +func (m ExecutionReport) GetStopPx() (f field.StopPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdRejReason gets OrdRejReason, Tag 103 +func (m ExecutionReport) GetOrdRejReason() (f field.OrdRejReasonField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m ExecutionReport) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m ExecutionReport) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClientID gets ClientID, Tag 109 +func (m ExecutionReport) GetClientID() (f field.ClientIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMinQty gets MinQty, Tag 110 +func (m ExecutionReport) GetMinQty() (f field.MinQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxFloor gets MaxFloor, Tag 111 +func (m ExecutionReport) GetMaxFloor() (f field.MaxFloorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetReportToExch gets ReportToExch, Tag 113 +func (m ExecutionReport) GetReportToExch() (f field.ReportToExchField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrAmt gets SettlCurrAmt, Tag 119 +func (m ExecutionReport) GetSettlCurrAmt() (f field.SettlCurrAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrency gets SettlCurrency, Tag 120 +func (m ExecutionReport) GetSettlCurrency() (f field.SettlCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireTime gets ExpireTime, Tag 126 +func (m ExecutionReport) GetExpireTime() (f field.ExpireTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecType gets ExecType, Tag 150 +func (m ExecutionReport) GetExecType() (f field.ExecTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLeavesQty gets LeavesQty, Tag 151 +func (m ExecutionReport) GetLeavesQty() (f field.LeavesQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashOrderQty gets CashOrderQty, Tag 152 +func (m ExecutionReport) GetCashOrderQty() (f field.CashOrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrFxRate gets SettlCurrFxRate, Tag 155 +func (m ExecutionReport) GetSettlCurrFxRate() (f field.SettlCurrFxRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrFxRateCalc gets SettlCurrFxRateCalc, Tag 156 +func (m ExecutionReport) GetSettlCurrFxRateCalc() (f field.SettlCurrFxRateCalcField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityType gets SecurityType, Tag 167 +func (m ExecutionReport) GetSecurityType() (f field.SecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEffectiveTime gets EffectiveTime, Tag 168 +func (m ExecutionReport) GetEffectiveTime() (f field.EffectiveTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty2 gets OrderQty2, Tag 192 +func (m ExecutionReport) GetOrderQty2() (f field.OrderQty2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFutSettDate2 gets FutSettDate2, Tag 193 +func (m ExecutionReport) GetFutSettDate2() (f field.FutSettDate2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastSpotRate gets LastSpotRate, Tag 194 +func (m ExecutionReport) GetLastSpotRate() (f field.LastSpotRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastForwardPoints gets LastForwardPoints, Tag 195 +func (m ExecutionReport) GetLastForwardPoints() (f field.LastForwardPointsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecondaryOrderID gets SecondaryOrderID, Tag 198 +func (m ExecutionReport) GetSecondaryOrderID() (f field.SecondaryOrderIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityMonthYear gets MaturityMonthYear, Tag 200 +func (m ExecutionReport) GetMaturityMonthYear() (f field.MaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPutOrCall gets PutOrCall, Tag 201 +func (m ExecutionReport) GetPutOrCall() (f field.PutOrCallField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikePrice gets StrikePrice, Tag 202 +func (m ExecutionReport) GetStrikePrice() (f field.StrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityDay gets MaturityDay, Tag 205 +func (m ExecutionReport) GetMaturityDay() (f field.MaturityDayField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOptAttribute gets OptAttribute, Tag 206 +func (m ExecutionReport) GetOptAttribute() (f field.OptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityExchange gets SecurityExchange, Tag 207 +func (m ExecutionReport) GetSecurityExchange() (f field.SecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxShow gets MaxShow, Tag 210 +func (m ExecutionReport) GetMaxShow() (f field.MaxShowField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegDifference gets PegDifference, Tag 211 +func (m ExecutionReport) GetPegDifference() (f field.PegDifferenceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponRate gets CouponRate, Tag 223 +func (m ExecutionReport) GetCouponRate() (f field.CouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractMultiplier gets ContractMultiplier, Tag 231 +func (m ExecutionReport) GetContractMultiplier() (f field.ContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradingSessionID gets TradingSessionID, Tag 336 +func (m ExecutionReport) GetTradingSessionID() (f field.TradingSessionIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuerLen gets EncodedIssuerLen, Tag 348 +func (m ExecutionReport) GetEncodedIssuerLen() (f field.EncodedIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuer gets EncodedIssuer, Tag 349 +func (m ExecutionReport) GetEncodedIssuer() (f field.EncodedIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDescLen gets EncodedSecurityDescLen, Tag 350 +func (m ExecutionReport) GetEncodedSecurityDescLen() (f field.EncodedSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDesc gets EncodedSecurityDesc, Tag 351 +func (m ExecutionReport) GetEncodedSecurityDesc() (f field.EncodedSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedTextLen gets EncodedTextLen, Tag 354 +func (m ExecutionReport) GetEncodedTextLen() (f field.EncodedTextLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedText gets EncodedText, Tag 355 +func (m ExecutionReport) GetEncodedText() (f field.EncodedTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetComplianceID gets ComplianceID, Tag 376 +func (m ExecutionReport) GetComplianceID() (f field.ComplianceIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSolicitedFlag gets SolicitedFlag, Tag 377 +func (m ExecutionReport) GetSolicitedFlag() (f field.SolicitedFlagField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecRestatementReason gets ExecRestatementReason, Tag 378 +func (m ExecutionReport) GetExecRestatementReason() (f field.ExecRestatementReasonField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetGrossTradeAmt gets GrossTradeAmt, Tag 381 +func (m ExecutionReport) GetGrossTradeAmt() (f field.GrossTradeAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoContraBrokers gets NoContraBrokers, Tag 382 +func (m ExecutionReport) GetNoContraBrokers() (NoContraBrokersRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoContraBrokersRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetDiscretionInst gets DiscretionInst, Tag 388 +func (m ExecutionReport) GetDiscretionInst() (f field.DiscretionInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionOffset gets DiscretionOffset, Tag 389 +func (m ExecutionReport) GetDiscretionOffset() (f field.DiscretionOffsetField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDayOrderQty gets DayOrderQty, Tag 424 +func (m ExecutionReport) GetDayOrderQty() (f field.DayOrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDayCumQty gets DayCumQty, Tag 425 +func (m ExecutionReport) GetDayCumQty() (f field.DayCumQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDayAvgPx gets DayAvgPx, Tag 426 +func (m ExecutionReport) GetDayAvgPx() (f field.DayAvgPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetGTBookingInst gets GTBookingInst, Tag 427 +func (m ExecutionReport) GetGTBookingInst() (f field.GTBookingInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireDate gets ExpireDate, Tag 432 +func (m ExecutionReport) GetExpireDate() (f field.ExpireDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClearingFirm gets ClearingFirm, Tag 439 +func (m ExecutionReport) GetClearingFirm() (f field.ClearingFirmField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClearingAccount gets ClearingAccount, Tag 440 +func (m ExecutionReport) GetClearingAccount() (f field.ClearingAccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMultiLegReportingType gets MultiLegReportingType, Tag 442 +func (m ExecutionReport) GetMultiLegReportingType() (f field.MultiLegReportingTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasAccount returns true if Account is present, Tag 1 +func (m ExecutionReport) HasAccount() bool { + return m.Has(tag.Account) +} + +//HasAvgPx returns true if AvgPx is present, Tag 6 +func (m ExecutionReport) HasAvgPx() bool { + return m.Has(tag.AvgPx) +} + +//HasClOrdID returns true if ClOrdID is present, Tag 11 +func (m ExecutionReport) HasClOrdID() bool { + return m.Has(tag.ClOrdID) +} + +//HasCommission returns true if Commission is present, Tag 12 +func (m ExecutionReport) HasCommission() bool { + return m.Has(tag.Commission) +} + +//HasCommType returns true if CommType is present, Tag 13 +func (m ExecutionReport) HasCommType() bool { + return m.Has(tag.CommType) +} + +//HasCumQty returns true if CumQty is present, Tag 14 +func (m ExecutionReport) HasCumQty() bool { + return m.Has(tag.CumQty) +} + +//HasCurrency returns true if Currency is present, Tag 15 +func (m ExecutionReport) HasCurrency() bool { + return m.Has(tag.Currency) +} + +//HasExecID returns true if ExecID is present, Tag 17 +func (m ExecutionReport) HasExecID() bool { + return m.Has(tag.ExecID) +} + +//HasExecInst returns true if ExecInst is present, Tag 18 +func (m ExecutionReport) HasExecInst() bool { + return m.Has(tag.ExecInst) +} + +//HasExecRefID returns true if ExecRefID is present, Tag 19 +func (m ExecutionReport) HasExecRefID() bool { + return m.Has(tag.ExecRefID) +} + +//HasExecTransType returns true if ExecTransType is present, Tag 20 +func (m ExecutionReport) HasExecTransType() bool { + return m.Has(tag.ExecTransType) +} + +//HasHandlInst returns true if HandlInst is present, Tag 21 +func (m ExecutionReport) HasHandlInst() bool { + return m.Has(tag.HandlInst) +} + +//HasIDSource returns true if IDSource is present, Tag 22 +func (m ExecutionReport) HasIDSource() bool { + return m.Has(tag.IDSource) +} + +//HasLastCapacity returns true if LastCapacity is present, Tag 29 +func (m ExecutionReport) HasLastCapacity() bool { + return m.Has(tag.LastCapacity) +} + +//HasLastMkt returns true if LastMkt is present, Tag 30 +func (m ExecutionReport) HasLastMkt() bool { + return m.Has(tag.LastMkt) +} + +//HasLastPx returns true if LastPx is present, Tag 31 +func (m ExecutionReport) HasLastPx() bool { + return m.Has(tag.LastPx) +} + +//HasLastShares returns true if LastShares is present, Tag 32 +func (m ExecutionReport) HasLastShares() bool { + return m.Has(tag.LastShares) +} + +//HasOrderID returns true if OrderID is present, Tag 37 +func (m ExecutionReport) HasOrderID() bool { + return m.Has(tag.OrderID) +} + +//HasOrderQty returns true if OrderQty is present, Tag 38 +func (m ExecutionReport) HasOrderQty() bool { + return m.Has(tag.OrderQty) +} + +//HasOrdStatus returns true if OrdStatus is present, Tag 39 +func (m ExecutionReport) HasOrdStatus() bool { + return m.Has(tag.OrdStatus) +} + +//HasOrdType returns true if OrdType is present, Tag 40 +func (m ExecutionReport) HasOrdType() bool { + return m.Has(tag.OrdType) +} + +//HasOrigClOrdID returns true if OrigClOrdID is present, Tag 41 +func (m ExecutionReport) HasOrigClOrdID() bool { + return m.Has(tag.OrigClOrdID) +} + +//HasPrice returns true if Price is present, Tag 44 +func (m ExecutionReport) HasPrice() bool { + return m.Has(tag.Price) +} + +//HasRule80A returns true if Rule80A is present, Tag 47 +func (m ExecutionReport) HasRule80A() bool { + return m.Has(tag.Rule80A) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m ExecutionReport) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSide returns true if Side is present, Tag 54 +func (m ExecutionReport) HasSide() bool { + return m.Has(tag.Side) +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m ExecutionReport) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasText returns true if Text is present, Tag 58 +func (m ExecutionReport) HasText() bool { + return m.Has(tag.Text) +} + +//HasTimeInForce returns true if TimeInForce is present, Tag 59 +func (m ExecutionReport) HasTimeInForce() bool { + return m.Has(tag.TimeInForce) +} + +//HasTransactTime returns true if TransactTime is present, Tag 60 +func (m ExecutionReport) HasTransactTime() bool { + return m.Has(tag.TransactTime) +} + +//HasSettlmntTyp returns true if SettlmntTyp is present, Tag 63 +func (m ExecutionReport) HasSettlmntTyp() bool { + return m.Has(tag.SettlmntTyp) +} + +//HasFutSettDate returns true if FutSettDate is present, Tag 64 +func (m ExecutionReport) HasFutSettDate() bool { + return m.Has(tag.FutSettDate) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m ExecutionReport) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasListID returns true if ListID is present, Tag 66 +func (m ExecutionReport) HasListID() bool { + return m.Has(tag.ListID) +} + +//HasTradeDate returns true if TradeDate is present, Tag 75 +func (m ExecutionReport) HasTradeDate() bool { + return m.Has(tag.TradeDate) +} + +//HasExecBroker returns true if ExecBroker is present, Tag 76 +func (m ExecutionReport) HasExecBroker() bool { + return m.Has(tag.ExecBroker) +} + +//HasOpenClose returns true if OpenClose is present, Tag 77 +func (m ExecutionReport) HasOpenClose() bool { + return m.Has(tag.OpenClose) +} + +//HasStopPx returns true if StopPx is present, Tag 99 +func (m ExecutionReport) HasStopPx() bool { + return m.Has(tag.StopPx) +} + +//HasOrdRejReason returns true if OrdRejReason is present, Tag 103 +func (m ExecutionReport) HasOrdRejReason() bool { + return m.Has(tag.OrdRejReason) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m ExecutionReport) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m ExecutionReport) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasClientID returns true if ClientID is present, Tag 109 +func (m ExecutionReport) HasClientID() bool { + return m.Has(tag.ClientID) +} + +//HasMinQty returns true if MinQty is present, Tag 110 +func (m ExecutionReport) HasMinQty() bool { + return m.Has(tag.MinQty) +} + +//HasMaxFloor returns true if MaxFloor is present, Tag 111 +func (m ExecutionReport) HasMaxFloor() bool { + return m.Has(tag.MaxFloor) +} + +//HasReportToExch returns true if ReportToExch is present, Tag 113 +func (m ExecutionReport) HasReportToExch() bool { + return m.Has(tag.ReportToExch) +} + +//HasSettlCurrAmt returns true if SettlCurrAmt is present, Tag 119 +func (m ExecutionReport) HasSettlCurrAmt() bool { + return m.Has(tag.SettlCurrAmt) +} + +//HasSettlCurrency returns true if SettlCurrency is present, Tag 120 +func (m ExecutionReport) HasSettlCurrency() bool { + return m.Has(tag.SettlCurrency) +} + +//HasExpireTime returns true if ExpireTime is present, Tag 126 +func (m ExecutionReport) HasExpireTime() bool { + return m.Has(tag.ExpireTime) +} + +//HasExecType returns true if ExecType is present, Tag 150 +func (m ExecutionReport) HasExecType() bool { + return m.Has(tag.ExecType) +} + +//HasLeavesQty returns true if LeavesQty is present, Tag 151 +func (m ExecutionReport) HasLeavesQty() bool { + return m.Has(tag.LeavesQty) +} + +//HasCashOrderQty returns true if CashOrderQty is present, Tag 152 +func (m ExecutionReport) HasCashOrderQty() bool { + return m.Has(tag.CashOrderQty) +} + +//HasSettlCurrFxRate returns true if SettlCurrFxRate is present, Tag 155 +func (m ExecutionReport) HasSettlCurrFxRate() bool { + return m.Has(tag.SettlCurrFxRate) +} + +//HasSettlCurrFxRateCalc returns true if SettlCurrFxRateCalc is present, Tag 156 +func (m ExecutionReport) HasSettlCurrFxRateCalc() bool { + return m.Has(tag.SettlCurrFxRateCalc) +} + +//HasSecurityType returns true if SecurityType is present, Tag 167 +func (m ExecutionReport) HasSecurityType() bool { + return m.Has(tag.SecurityType) +} + +//HasEffectiveTime returns true if EffectiveTime is present, Tag 168 +func (m ExecutionReport) HasEffectiveTime() bool { + return m.Has(tag.EffectiveTime) +} + +//HasOrderQty2 returns true if OrderQty2 is present, Tag 192 +func (m ExecutionReport) HasOrderQty2() bool { + return m.Has(tag.OrderQty2) +} + +//HasFutSettDate2 returns true if FutSettDate2 is present, Tag 193 +func (m ExecutionReport) HasFutSettDate2() bool { + return m.Has(tag.FutSettDate2) +} + +//HasLastSpotRate returns true if LastSpotRate is present, Tag 194 +func (m ExecutionReport) HasLastSpotRate() bool { + return m.Has(tag.LastSpotRate) +} + +//HasLastForwardPoints returns true if LastForwardPoints is present, Tag 195 +func (m ExecutionReport) HasLastForwardPoints() bool { + return m.Has(tag.LastForwardPoints) +} + +//HasSecondaryOrderID returns true if SecondaryOrderID is present, Tag 198 +func (m ExecutionReport) HasSecondaryOrderID() bool { + return m.Has(tag.SecondaryOrderID) +} + +//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200 +func (m ExecutionReport) HasMaturityMonthYear() bool { + return m.Has(tag.MaturityMonthYear) +} + +//HasPutOrCall returns true if PutOrCall is present, Tag 201 +func (m ExecutionReport) HasPutOrCall() bool { + return m.Has(tag.PutOrCall) +} + +//HasStrikePrice returns true if StrikePrice is present, Tag 202 +func (m ExecutionReport) HasStrikePrice() bool { + return m.Has(tag.StrikePrice) +} + +//HasMaturityDay returns true if MaturityDay is present, Tag 205 +func (m ExecutionReport) HasMaturityDay() bool { + return m.Has(tag.MaturityDay) +} + +//HasOptAttribute returns true if OptAttribute is present, Tag 206 +func (m ExecutionReport) HasOptAttribute() bool { + return m.Has(tag.OptAttribute) +} + +//HasSecurityExchange returns true if SecurityExchange is present, Tag 207 +func (m ExecutionReport) HasSecurityExchange() bool { + return m.Has(tag.SecurityExchange) +} + +//HasMaxShow returns true if MaxShow is present, Tag 210 +func (m ExecutionReport) HasMaxShow() bool { + return m.Has(tag.MaxShow) +} + +//HasPegDifference returns true if PegDifference is present, Tag 211 +func (m ExecutionReport) HasPegDifference() bool { + return m.Has(tag.PegDifference) +} + +//HasCouponRate returns true if CouponRate is present, Tag 223 +func (m ExecutionReport) HasCouponRate() bool { + return m.Has(tag.CouponRate) +} + +//HasContractMultiplier returns true if ContractMultiplier is present, Tag 231 +func (m ExecutionReport) HasContractMultiplier() bool { + return m.Has(tag.ContractMultiplier) +} + +//HasTradingSessionID returns true if TradingSessionID is present, Tag 336 +func (m ExecutionReport) HasTradingSessionID() bool { + return m.Has(tag.TradingSessionID) +} + +//HasEncodedIssuerLen returns true if EncodedIssuerLen is present, Tag 348 +func (m ExecutionReport) HasEncodedIssuerLen() bool { + return m.Has(tag.EncodedIssuerLen) +} + +//HasEncodedIssuer returns true if EncodedIssuer is present, Tag 349 +func (m ExecutionReport) HasEncodedIssuer() bool { + return m.Has(tag.EncodedIssuer) +} + +//HasEncodedSecurityDescLen returns true if EncodedSecurityDescLen is present, Tag 350 +func (m ExecutionReport) HasEncodedSecurityDescLen() bool { + return m.Has(tag.EncodedSecurityDescLen) +} + +//HasEncodedSecurityDesc returns true if EncodedSecurityDesc is present, Tag 351 +func (m ExecutionReport) HasEncodedSecurityDesc() bool { + return m.Has(tag.EncodedSecurityDesc) +} + +//HasEncodedTextLen returns true if EncodedTextLen is present, Tag 354 +func (m ExecutionReport) HasEncodedTextLen() bool { + return m.Has(tag.EncodedTextLen) +} + +//HasEncodedText returns true if EncodedText is present, Tag 355 +func (m ExecutionReport) HasEncodedText() bool { + return m.Has(tag.EncodedText) +} + +//HasComplianceID returns true if ComplianceID is present, Tag 376 +func (m ExecutionReport) HasComplianceID() bool { + return m.Has(tag.ComplianceID) +} + +//HasSolicitedFlag returns true if SolicitedFlag is present, Tag 377 +func (m ExecutionReport) HasSolicitedFlag() bool { + return m.Has(tag.SolicitedFlag) +} + +//HasExecRestatementReason returns true if ExecRestatementReason is present, Tag 378 +func (m ExecutionReport) HasExecRestatementReason() bool { + return m.Has(tag.ExecRestatementReason) +} + +//HasGrossTradeAmt returns true if GrossTradeAmt is present, Tag 381 +func (m ExecutionReport) HasGrossTradeAmt() bool { + return m.Has(tag.GrossTradeAmt) +} + +//HasNoContraBrokers returns true if NoContraBrokers is present, Tag 382 +func (m ExecutionReport) HasNoContraBrokers() bool { + return m.Has(tag.NoContraBrokers) +} + +//HasDiscretionInst returns true if DiscretionInst is present, Tag 388 +func (m ExecutionReport) HasDiscretionInst() bool { + return m.Has(tag.DiscretionInst) +} + +//HasDiscretionOffset returns true if DiscretionOffset is present, Tag 389 +func (m ExecutionReport) HasDiscretionOffset() bool { + return m.Has(tag.DiscretionOffset) +} + +//HasDayOrderQty returns true if DayOrderQty is present, Tag 424 +func (m ExecutionReport) HasDayOrderQty() bool { + return m.Has(tag.DayOrderQty) +} + +//HasDayCumQty returns true if DayCumQty is present, Tag 425 +func (m ExecutionReport) HasDayCumQty() bool { + return m.Has(tag.DayCumQty) +} + +//HasDayAvgPx returns true if DayAvgPx is present, Tag 426 +func (m ExecutionReport) HasDayAvgPx() bool { + return m.Has(tag.DayAvgPx) +} + +//HasGTBookingInst returns true if GTBookingInst is present, Tag 427 +func (m ExecutionReport) HasGTBookingInst() bool { + return m.Has(tag.GTBookingInst) +} + +//HasExpireDate returns true if ExpireDate is present, Tag 432 +func (m ExecutionReport) HasExpireDate() bool { + return m.Has(tag.ExpireDate) +} + +//HasClearingFirm returns true if ClearingFirm is present, Tag 439 +func (m ExecutionReport) HasClearingFirm() bool { + return m.Has(tag.ClearingFirm) +} + +//HasClearingAccount returns true if ClearingAccount is present, Tag 440 +func (m ExecutionReport) HasClearingAccount() bool { + return m.Has(tag.ClearingAccount) +} + +//HasMultiLegReportingType returns true if MultiLegReportingType is present, Tag 442 +func (m ExecutionReport) HasMultiLegReportingType() bool { + return m.Has(tag.MultiLegReportingType) +} + +//NoContraBrokers is a repeating group element, Tag 382 +type NoContraBrokers struct { + quickfix.Group +} + +//SetContraBroker sets ContraBroker, Tag 375 +func (m NoContraBrokers) SetContraBroker(v string) { + m.Set(field.NewContraBroker(v)) +} + +//SetContraTrader sets ContraTrader, Tag 337 +func (m NoContraBrokers) SetContraTrader(v string) { + m.Set(field.NewContraTrader(v)) +} + +//SetContraTradeQty sets ContraTradeQty, Tag 437 +func (m NoContraBrokers) SetContraTradeQty(v float64) { + m.Set(field.NewContraTradeQty(v)) +} + +//SetContraTradeTime sets ContraTradeTime, Tag 438 +func (m NoContraBrokers) SetContraTradeTime(v time.Time) { + m.Set(field.NewContraTradeTime(v)) +} + +//GetContraBroker gets ContraBroker, Tag 375 +func (m NoContraBrokers) GetContraBroker() (f field.ContraBrokerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContraTrader gets ContraTrader, Tag 337 +func (m NoContraBrokers) GetContraTrader() (f field.ContraTraderField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContraTradeQty gets ContraTradeQty, Tag 437 +func (m NoContraBrokers) GetContraTradeQty() (f field.ContraTradeQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContraTradeTime gets ContraTradeTime, Tag 438 +func (m NoContraBrokers) GetContraTradeTime() (f field.ContraTradeTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasContraBroker returns true if ContraBroker is present, Tag 375 +func (m NoContraBrokers) HasContraBroker() bool { + return m.Has(tag.ContraBroker) +} + +//HasContraTrader returns true if ContraTrader is present, Tag 337 +func (m NoContraBrokers) HasContraTrader() bool { + return m.Has(tag.ContraTrader) +} + +//HasContraTradeQty returns true if ContraTradeQty is present, Tag 437 +func (m NoContraBrokers) HasContraTradeQty() bool { + return m.Has(tag.ContraTradeQty) +} + +//HasContraTradeTime returns true if ContraTradeTime is present, Tag 438 +func (m NoContraBrokers) HasContraTradeTime() bool { + return m.Has(tag.ContraTradeTime) +} + +//NoContraBrokersRepeatingGroup is a repeating group, Tag 382 +type NoContraBrokersRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoContraBrokersRepeatingGroup returns an initialized, NoContraBrokersRepeatingGroup +func NewNoContraBrokersRepeatingGroup() NoContraBrokersRepeatingGroup { + return NoContraBrokersRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoContraBrokers, + quickfix.GroupTemplate{quickfix.GroupElement(tag.ContraBroker), quickfix.GroupElement(tag.ContraTrader), quickfix.GroupElement(tag.ContraTradeQty), quickfix.GroupElement(tag.ContraTradeTime)})} +} + +//Add create and append a new NoContraBrokers to this group +func (m NoContraBrokersRepeatingGroup) Add() NoContraBrokers { + g := m.RepeatingGroup.Add() + return NoContraBrokers{g} +} + +//Get returns the ith NoContraBrokers in the NoContraBrokersRepeatinGroup +func (m NoContraBrokersRepeatingGroup) Get(i int) NoContraBrokers { + return NoContraBrokers{m.RepeatingGroup.Get(i)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix42/header.generated.go b/vendor/github.com/quickfixgo/quickfix/fix42/header.generated.go new file mode 100644 index 0000000..bc3d83f --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix42/header.generated.go @@ -0,0 +1,453 @@ +package fix42 + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/tag" +) + +//Header is the fix42 Header type +type Header struct { + quickfix.Header +} + +//NewHeader returns a new, initialized Header instance +func NewHeader() (h Header) { + h.Init() + h.SetBeginString("FIX.4.2") + return +} + +//SetBeginString sets BeginString, Tag 8 +func (h Header) SetBeginString(v string) { + h.Set(field.NewBeginString(v)) +} + +//SetBodyLength sets BodyLength, Tag 9 +func (h Header) SetBodyLength(v int) { + h.Set(field.NewBodyLength(v)) +} + +//SetMsgSeqNum sets MsgSeqNum, Tag 34 +func (h Header) SetMsgSeqNum(v int) { + h.Set(field.NewMsgSeqNum(v)) +} + +//SetMsgType sets MsgType, Tag 35 +func (h Header) SetMsgType(v string) { + h.Set(field.NewMsgType(v)) +} + +//SetPossDupFlag sets PossDupFlag, Tag 43 +func (h Header) SetPossDupFlag(v bool) { + h.Set(field.NewPossDupFlag(v)) +} + +//SetSenderCompID sets SenderCompID, Tag 49 +func (h Header) SetSenderCompID(v string) { + h.Set(field.NewSenderCompID(v)) +} + +//SetSenderSubID sets SenderSubID, Tag 50 +func (h Header) SetSenderSubID(v string) { + h.Set(field.NewSenderSubID(v)) +} + +//SetSendingTime sets SendingTime, Tag 52 +func (h Header) SetSendingTime(v time.Time) { + h.Set(field.NewSendingTime(v)) +} + +//SetTargetCompID sets TargetCompID, Tag 56 +func (h Header) SetTargetCompID(v string) { + h.Set(field.NewTargetCompID(v)) +} + +//SetTargetSubID sets TargetSubID, Tag 57 +func (h Header) SetTargetSubID(v string) { + h.Set(field.NewTargetSubID(v)) +} + +//SetSecureDataLen sets SecureDataLen, Tag 90 +func (h Header) SetSecureDataLen(v int) { + h.Set(field.NewSecureDataLen(v)) +} + +//SetSecureData sets SecureData, Tag 91 +func (h Header) SetSecureData(v string) { + h.Set(field.NewSecureData(v)) +} + +//SetPossResend sets PossResend, Tag 97 +func (h Header) SetPossResend(v bool) { + h.Set(field.NewPossResend(v)) +} + +//SetOnBehalfOfCompID sets OnBehalfOfCompID, Tag 115 +func (h Header) SetOnBehalfOfCompID(v string) { + h.Set(field.NewOnBehalfOfCompID(v)) +} + +//SetOnBehalfOfSubID sets OnBehalfOfSubID, Tag 116 +func (h Header) SetOnBehalfOfSubID(v string) { + h.Set(field.NewOnBehalfOfSubID(v)) +} + +//SetOrigSendingTime sets OrigSendingTime, Tag 122 +func (h Header) SetOrigSendingTime(v time.Time) { + h.Set(field.NewOrigSendingTime(v)) +} + +//SetDeliverToCompID sets DeliverToCompID, Tag 128 +func (h Header) SetDeliverToCompID(v string) { + h.Set(field.NewDeliverToCompID(v)) +} + +//SetDeliverToSubID sets DeliverToSubID, Tag 129 +func (h Header) SetDeliverToSubID(v string) { + h.Set(field.NewDeliverToSubID(v)) +} + +//SetSenderLocationID sets SenderLocationID, Tag 142 +func (h Header) SetSenderLocationID(v string) { + h.Set(field.NewSenderLocationID(v)) +} + +//SetTargetLocationID sets TargetLocationID, Tag 143 +func (h Header) SetTargetLocationID(v string) { + h.Set(field.NewTargetLocationID(v)) +} + +//SetOnBehalfOfLocationID sets OnBehalfOfLocationID, Tag 144 +func (h Header) SetOnBehalfOfLocationID(v string) { + h.Set(field.NewOnBehalfOfLocationID(v)) +} + +//SetDeliverToLocationID sets DeliverToLocationID, Tag 145 +func (h Header) SetDeliverToLocationID(v string) { + h.Set(field.NewDeliverToLocationID(v)) +} + +//SetXmlDataLen sets XmlDataLen, Tag 212 +func (h Header) SetXmlDataLen(v int) { + h.Set(field.NewXmlDataLen(v)) +} + +//SetXmlData sets XmlData, Tag 213 +func (h Header) SetXmlData(v string) { + h.Set(field.NewXmlData(v)) +} + +//SetMessageEncoding sets MessageEncoding, Tag 347 +func (h Header) SetMessageEncoding(v string) { + h.Set(field.NewMessageEncoding(v)) +} + +//SetLastMsgSeqNumProcessed sets LastMsgSeqNumProcessed, Tag 369 +func (h Header) SetLastMsgSeqNumProcessed(v int) { + h.Set(field.NewLastMsgSeqNumProcessed(v)) +} + +//SetOnBehalfOfSendingTime sets OnBehalfOfSendingTime, Tag 370 +func (h Header) SetOnBehalfOfSendingTime(v time.Time) { + h.Set(field.NewOnBehalfOfSendingTime(v)) +} + +//GetBeginString gets BeginString, Tag 8 +func (h Header) GetBeginString() (f field.BeginStringField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetBodyLength gets BodyLength, Tag 9 +func (h Header) GetBodyLength() (f field.BodyLengthField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetMsgSeqNum gets MsgSeqNum, Tag 34 +func (h Header) GetMsgSeqNum() (f field.MsgSeqNumField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetMsgType gets MsgType, Tag 35 +func (h Header) GetMsgType() (f field.MsgTypeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetPossDupFlag gets PossDupFlag, Tag 43 +func (h Header) GetPossDupFlag() (f field.PossDupFlagField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSenderCompID gets SenderCompID, Tag 49 +func (h Header) GetSenderCompID() (f field.SenderCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSenderSubID gets SenderSubID, Tag 50 +func (h Header) GetSenderSubID() (f field.SenderSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSendingTime gets SendingTime, Tag 52 +func (h Header) GetSendingTime() (f field.SendingTimeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetTargetCompID gets TargetCompID, Tag 56 +func (h Header) GetTargetCompID() (f field.TargetCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetTargetSubID gets TargetSubID, Tag 57 +func (h Header) GetTargetSubID() (f field.TargetSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSecureDataLen gets SecureDataLen, Tag 90 +func (h Header) GetSecureDataLen() (f field.SecureDataLenField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSecureData gets SecureData, Tag 91 +func (h Header) GetSecureData() (f field.SecureDataField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetPossResend gets PossResend, Tag 97 +func (h Header) GetPossResend() (f field.PossResendField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOnBehalfOfCompID gets OnBehalfOfCompID, Tag 115 +func (h Header) GetOnBehalfOfCompID() (f field.OnBehalfOfCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOnBehalfOfSubID gets OnBehalfOfSubID, Tag 116 +func (h Header) GetOnBehalfOfSubID() (f field.OnBehalfOfSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOrigSendingTime gets OrigSendingTime, Tag 122 +func (h Header) GetOrigSendingTime() (f field.OrigSendingTimeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetDeliverToCompID gets DeliverToCompID, Tag 128 +func (h Header) GetDeliverToCompID() (f field.DeliverToCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetDeliverToSubID gets DeliverToSubID, Tag 129 +func (h Header) GetDeliverToSubID() (f field.DeliverToSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSenderLocationID gets SenderLocationID, Tag 142 +func (h Header) GetSenderLocationID() (f field.SenderLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetTargetLocationID gets TargetLocationID, Tag 143 +func (h Header) GetTargetLocationID() (f field.TargetLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOnBehalfOfLocationID gets OnBehalfOfLocationID, Tag 144 +func (h Header) GetOnBehalfOfLocationID() (f field.OnBehalfOfLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetDeliverToLocationID gets DeliverToLocationID, Tag 145 +func (h Header) GetDeliverToLocationID() (f field.DeliverToLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetXmlDataLen gets XmlDataLen, Tag 212 +func (h Header) GetXmlDataLen() (f field.XmlDataLenField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetXmlData gets XmlData, Tag 213 +func (h Header) GetXmlData() (f field.XmlDataField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetMessageEncoding gets MessageEncoding, Tag 347 +func (h Header) GetMessageEncoding() (f field.MessageEncodingField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetLastMsgSeqNumProcessed gets LastMsgSeqNumProcessed, Tag 369 +func (h Header) GetLastMsgSeqNumProcessed() (f field.LastMsgSeqNumProcessedField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOnBehalfOfSendingTime gets OnBehalfOfSendingTime, Tag 370 +func (h Header) GetOnBehalfOfSendingTime() (f field.OnBehalfOfSendingTimeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//HasBeginString returns true if BeginString is present, Tag 8 +func (h Header) HasBeginString() bool { + return h.Has(tag.BeginString) +} + +//HasBodyLength returns true if BodyLength is present, Tag 9 +func (h Header) HasBodyLength() bool { + return h.Has(tag.BodyLength) +} + +//HasMsgSeqNum returns true if MsgSeqNum is present, Tag 34 +func (h Header) HasMsgSeqNum() bool { + return h.Has(tag.MsgSeqNum) +} + +//HasMsgType returns true if MsgType is present, Tag 35 +func (h Header) HasMsgType() bool { + return h.Has(tag.MsgType) +} + +//HasPossDupFlag returns true if PossDupFlag is present, Tag 43 +func (h Header) HasPossDupFlag() bool { + return h.Has(tag.PossDupFlag) +} + +//HasSenderCompID returns true if SenderCompID is present, Tag 49 +func (h Header) HasSenderCompID() bool { + return h.Has(tag.SenderCompID) +} + +//HasSenderSubID returns true if SenderSubID is present, Tag 50 +func (h Header) HasSenderSubID() bool { + return h.Has(tag.SenderSubID) +} + +//HasSendingTime returns true if SendingTime is present, Tag 52 +func (h Header) HasSendingTime() bool { + return h.Has(tag.SendingTime) +} + +//HasTargetCompID returns true if TargetCompID is present, Tag 56 +func (h Header) HasTargetCompID() bool { + return h.Has(tag.TargetCompID) +} + +//HasTargetSubID returns true if TargetSubID is present, Tag 57 +func (h Header) HasTargetSubID() bool { + return h.Has(tag.TargetSubID) +} + +//HasSecureDataLen returns true if SecureDataLen is present, Tag 90 +func (h Header) HasSecureDataLen() bool { + return h.Has(tag.SecureDataLen) +} + +//HasSecureData returns true if SecureData is present, Tag 91 +func (h Header) HasSecureData() bool { + return h.Has(tag.SecureData) +} + +//HasPossResend returns true if PossResend is present, Tag 97 +func (h Header) HasPossResend() bool { + return h.Has(tag.PossResend) +} + +//HasOnBehalfOfCompID returns true if OnBehalfOfCompID is present, Tag 115 +func (h Header) HasOnBehalfOfCompID() bool { + return h.Has(tag.OnBehalfOfCompID) +} + +//HasOnBehalfOfSubID returns true if OnBehalfOfSubID is present, Tag 116 +func (h Header) HasOnBehalfOfSubID() bool { + return h.Has(tag.OnBehalfOfSubID) +} + +//HasOrigSendingTime returns true if OrigSendingTime is present, Tag 122 +func (h Header) HasOrigSendingTime() bool { + return h.Has(tag.OrigSendingTime) +} + +//HasDeliverToCompID returns true if DeliverToCompID is present, Tag 128 +func (h Header) HasDeliverToCompID() bool { + return h.Has(tag.DeliverToCompID) +} + +//HasDeliverToSubID returns true if DeliverToSubID is present, Tag 129 +func (h Header) HasDeliverToSubID() bool { + return h.Has(tag.DeliverToSubID) +} + +//HasSenderLocationID returns true if SenderLocationID is present, Tag 142 +func (h Header) HasSenderLocationID() bool { + return h.Has(tag.SenderLocationID) +} + +//HasTargetLocationID returns true if TargetLocationID is present, Tag 143 +func (h Header) HasTargetLocationID() bool { + return h.Has(tag.TargetLocationID) +} + +//HasOnBehalfOfLocationID returns true if OnBehalfOfLocationID is present, Tag 144 +func (h Header) HasOnBehalfOfLocationID() bool { + return h.Has(tag.OnBehalfOfLocationID) +} + +//HasDeliverToLocationID returns true if DeliverToLocationID is present, Tag 145 +func (h Header) HasDeliverToLocationID() bool { + return h.Has(tag.DeliverToLocationID) +} + +//HasXmlDataLen returns true if XmlDataLen is present, Tag 212 +func (h Header) HasXmlDataLen() bool { + return h.Has(tag.XmlDataLen) +} + +//HasXmlData returns true if XmlData is present, Tag 213 +func (h Header) HasXmlData() bool { + return h.Has(tag.XmlData) +} + +//HasMessageEncoding returns true if MessageEncoding is present, Tag 347 +func (h Header) HasMessageEncoding() bool { + return h.Has(tag.MessageEncoding) +} + +//HasLastMsgSeqNumProcessed returns true if LastMsgSeqNumProcessed is present, Tag 369 +func (h Header) HasLastMsgSeqNumProcessed() bool { + return h.Has(tag.LastMsgSeqNumProcessed) +} + +//HasOnBehalfOfSendingTime returns true if OnBehalfOfSendingTime is present, Tag 370 +func (h Header) HasOnBehalfOfSendingTime() bool { + return h.Has(tag.OnBehalfOfSendingTime) +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix42/marketdatarequest/MarketDataRequest.generated.go b/vendor/github.com/quickfixgo/quickfix/fix42/marketdatarequest/MarketDataRequest.generated.go new file mode 100644 index 0000000..acc3ee1 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix42/marketdatarequest/MarketDataRequest.generated.go @@ -0,0 +1,570 @@ +package marketdatarequest + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fix42" + "github.com/quickfixgo/quickfix/tag" +) + +//MarketDataRequest is the fix42 MarketDataRequest type, MsgType = V +type MarketDataRequest struct { + fix42.Header + quickfix.Body + fix42.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a MarketDataRequest from a quickfix.Message instance +func FromMessage(m quickfix.Message) MarketDataRequest { + return MarketDataRequest{ + Header: fix42.Header{Header: m.Header}, + Body: m.Body, + Trailer: fix42.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m MarketDataRequest) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a MarketDataRequest initialized with the required fields for MarketDataRequest +func New(mdreqid field.MDReqIDField, subscriptionrequesttype field.SubscriptionRequestTypeField, marketdepth field.MarketDepthField) (m MarketDataRequest) { + m.Header = fix42.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("V")) + m.Set(mdreqid) + m.Set(subscriptionrequesttype) + m.Set(marketdepth) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg MarketDataRequest, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "FIX.4.2", "V", r +} + +//SetNoRelatedSym sets NoRelatedSym, Tag 146 +func (m MarketDataRequest) SetNoRelatedSym(f NoRelatedSymRepeatingGroup) { + m.SetGroup(f) +} + +//SetMDReqID sets MDReqID, Tag 262 +func (m MarketDataRequest) SetMDReqID(v string) { + m.Set(field.NewMDReqID(v)) +} + +//SetSubscriptionRequestType sets SubscriptionRequestType, Tag 263 +func (m MarketDataRequest) SetSubscriptionRequestType(v string) { + m.Set(field.NewSubscriptionRequestType(v)) +} + +//SetMarketDepth sets MarketDepth, Tag 264 +func (m MarketDataRequest) SetMarketDepth(v int) { + m.Set(field.NewMarketDepth(v)) +} + +//SetMDUpdateType sets MDUpdateType, Tag 265 +func (m MarketDataRequest) SetMDUpdateType(v int) { + m.Set(field.NewMDUpdateType(v)) +} + +//SetAggregatedBook sets AggregatedBook, Tag 266 +func (m MarketDataRequest) SetAggregatedBook(v bool) { + m.Set(field.NewAggregatedBook(v)) +} + +//SetNoMDEntryTypes sets NoMDEntryTypes, Tag 267 +func (m MarketDataRequest) SetNoMDEntryTypes(f NoMDEntryTypesRepeatingGroup) { + m.SetGroup(f) +} + +//GetNoRelatedSym gets NoRelatedSym, Tag 146 +func (m MarketDataRequest) GetNoRelatedSym() (NoRelatedSymRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoRelatedSymRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetMDReqID gets MDReqID, Tag 262 +func (m MarketDataRequest) GetMDReqID() (f field.MDReqIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSubscriptionRequestType gets SubscriptionRequestType, Tag 263 +func (m MarketDataRequest) GetSubscriptionRequestType() (f field.SubscriptionRequestTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMarketDepth gets MarketDepth, Tag 264 +func (m MarketDataRequest) GetMarketDepth() (f field.MarketDepthField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMDUpdateType gets MDUpdateType, Tag 265 +func (m MarketDataRequest) GetMDUpdateType() (f field.MDUpdateTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAggregatedBook gets AggregatedBook, Tag 266 +func (m MarketDataRequest) GetAggregatedBook() (f field.AggregatedBookField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoMDEntryTypes gets NoMDEntryTypes, Tag 267 +func (m MarketDataRequest) GetNoMDEntryTypes() (NoMDEntryTypesRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoMDEntryTypesRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasNoRelatedSym returns true if NoRelatedSym is present, Tag 146 +func (m MarketDataRequest) HasNoRelatedSym() bool { + return m.Has(tag.NoRelatedSym) +} + +//HasMDReqID returns true if MDReqID is present, Tag 262 +func (m MarketDataRequest) HasMDReqID() bool { + return m.Has(tag.MDReqID) +} + +//HasSubscriptionRequestType returns true if SubscriptionRequestType is present, Tag 263 +func (m MarketDataRequest) HasSubscriptionRequestType() bool { + return m.Has(tag.SubscriptionRequestType) +} + +//HasMarketDepth returns true if MarketDepth is present, Tag 264 +func (m MarketDataRequest) HasMarketDepth() bool { + return m.Has(tag.MarketDepth) +} + +//HasMDUpdateType returns true if MDUpdateType is present, Tag 265 +func (m MarketDataRequest) HasMDUpdateType() bool { + return m.Has(tag.MDUpdateType) +} + +//HasAggregatedBook returns true if AggregatedBook is present, Tag 266 +func (m MarketDataRequest) HasAggregatedBook() bool { + return m.Has(tag.AggregatedBook) +} + +//HasNoMDEntryTypes returns true if NoMDEntryTypes is present, Tag 267 +func (m MarketDataRequest) HasNoMDEntryTypes() bool { + return m.Has(tag.NoMDEntryTypes) +} + +//NoRelatedSym is a repeating group element, Tag 146 +type NoRelatedSym struct { + quickfix.Group +} + +//SetSymbol sets Symbol, Tag 55 +func (m NoRelatedSym) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m NoRelatedSym) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m NoRelatedSym) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetIDSource sets IDSource, Tag 22 +func (m NoRelatedSym) SetIDSource(v string) { + m.Set(field.NewIDSource(v)) +} + +//SetSecurityType sets SecurityType, Tag 167 +func (m NoRelatedSym) SetSecurityType(v string) { + m.Set(field.NewSecurityType(v)) +} + +//SetMaturityMonthYear sets MaturityMonthYear, Tag 200 +func (m NoRelatedSym) SetMaturityMonthYear(v string) { + m.Set(field.NewMaturityMonthYear(v)) +} + +//SetMaturityDay sets MaturityDay, Tag 205 +func (m NoRelatedSym) SetMaturityDay(v int) { + m.Set(field.NewMaturityDay(v)) +} + +//SetPutOrCall sets PutOrCall, Tag 201 +func (m NoRelatedSym) SetPutOrCall(v int) { + m.Set(field.NewPutOrCall(v)) +} + +//SetStrikePrice sets StrikePrice, Tag 202 +func (m NoRelatedSym) SetStrikePrice(v float64) { + m.Set(field.NewStrikePrice(v)) +} + +//SetOptAttribute sets OptAttribute, Tag 206 +func (m NoRelatedSym) SetOptAttribute(v string) { + m.Set(field.NewOptAttribute(v)) +} + +//SetContractMultiplier sets ContractMultiplier, Tag 231 +func (m NoRelatedSym) SetContractMultiplier(v float64) { + m.Set(field.NewContractMultiplier(v)) +} + +//SetCouponRate sets CouponRate, Tag 223 +func (m NoRelatedSym) SetCouponRate(v float64) { + m.Set(field.NewCouponRate(v)) +} + +//SetSecurityExchange sets SecurityExchange, Tag 207 +func (m NoRelatedSym) SetSecurityExchange(v string) { + m.Set(field.NewSecurityExchange(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m NoRelatedSym) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetEncodedIssuerLen sets EncodedIssuerLen, Tag 348 +func (m NoRelatedSym) SetEncodedIssuerLen(v int) { + m.Set(field.NewEncodedIssuerLen(v)) +} + +//SetEncodedIssuer sets EncodedIssuer, Tag 349 +func (m NoRelatedSym) SetEncodedIssuer(v string) { + m.Set(field.NewEncodedIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m NoRelatedSym) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetEncodedSecurityDescLen sets EncodedSecurityDescLen, Tag 350 +func (m NoRelatedSym) SetEncodedSecurityDescLen(v int) { + m.Set(field.NewEncodedSecurityDescLen(v)) +} + +//SetEncodedSecurityDesc sets EncodedSecurityDesc, Tag 351 +func (m NoRelatedSym) SetEncodedSecurityDesc(v string) { + m.Set(field.NewEncodedSecurityDesc(v)) +} + +//SetTradingSessionID sets TradingSessionID, Tag 336 +func (m NoRelatedSym) SetTradingSessionID(v string) { + m.Set(field.NewTradingSessionID(v)) +} + +//GetSymbol gets Symbol, Tag 55 +func (m NoRelatedSym) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m NoRelatedSym) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m NoRelatedSym) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIDSource gets IDSource, Tag 22 +func (m NoRelatedSym) GetIDSource() (f field.IDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityType gets SecurityType, Tag 167 +func (m NoRelatedSym) GetSecurityType() (f field.SecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityMonthYear gets MaturityMonthYear, Tag 200 +func (m NoRelatedSym) GetMaturityMonthYear() (f field.MaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityDay gets MaturityDay, Tag 205 +func (m NoRelatedSym) GetMaturityDay() (f field.MaturityDayField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPutOrCall gets PutOrCall, Tag 201 +func (m NoRelatedSym) GetPutOrCall() (f field.PutOrCallField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikePrice gets StrikePrice, Tag 202 +func (m NoRelatedSym) GetStrikePrice() (f field.StrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOptAttribute gets OptAttribute, Tag 206 +func (m NoRelatedSym) GetOptAttribute() (f field.OptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractMultiplier gets ContractMultiplier, Tag 231 +func (m NoRelatedSym) GetContractMultiplier() (f field.ContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponRate gets CouponRate, Tag 223 +func (m NoRelatedSym) GetCouponRate() (f field.CouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityExchange gets SecurityExchange, Tag 207 +func (m NoRelatedSym) GetSecurityExchange() (f field.SecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m NoRelatedSym) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuerLen gets EncodedIssuerLen, Tag 348 +func (m NoRelatedSym) GetEncodedIssuerLen() (f field.EncodedIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuer gets EncodedIssuer, Tag 349 +func (m NoRelatedSym) GetEncodedIssuer() (f field.EncodedIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m NoRelatedSym) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDescLen gets EncodedSecurityDescLen, Tag 350 +func (m NoRelatedSym) GetEncodedSecurityDescLen() (f field.EncodedSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDesc gets EncodedSecurityDesc, Tag 351 +func (m NoRelatedSym) GetEncodedSecurityDesc() (f field.EncodedSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradingSessionID gets TradingSessionID, Tag 336 +func (m NoRelatedSym) GetTradingSessionID() (f field.TradingSessionIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m NoRelatedSym) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m NoRelatedSym) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m NoRelatedSym) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasIDSource returns true if IDSource is present, Tag 22 +func (m NoRelatedSym) HasIDSource() bool { + return m.Has(tag.IDSource) +} + +//HasSecurityType returns true if SecurityType is present, Tag 167 +func (m NoRelatedSym) HasSecurityType() bool { + return m.Has(tag.SecurityType) +} + +//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200 +func (m NoRelatedSym) HasMaturityMonthYear() bool { + return m.Has(tag.MaturityMonthYear) +} + +//HasMaturityDay returns true if MaturityDay is present, Tag 205 +func (m NoRelatedSym) HasMaturityDay() bool { + return m.Has(tag.MaturityDay) +} + +//HasPutOrCall returns true if PutOrCall is present, Tag 201 +func (m NoRelatedSym) HasPutOrCall() bool { + return m.Has(tag.PutOrCall) +} + +//HasStrikePrice returns true if StrikePrice is present, Tag 202 +func (m NoRelatedSym) HasStrikePrice() bool { + return m.Has(tag.StrikePrice) +} + +//HasOptAttribute returns true if OptAttribute is present, Tag 206 +func (m NoRelatedSym) HasOptAttribute() bool { + return m.Has(tag.OptAttribute) +} + +//HasContractMultiplier returns true if ContractMultiplier is present, Tag 231 +func (m NoRelatedSym) HasContractMultiplier() bool { + return m.Has(tag.ContractMultiplier) +} + +//HasCouponRate returns true if CouponRate is present, Tag 223 +func (m NoRelatedSym) HasCouponRate() bool { + return m.Has(tag.CouponRate) +} + +//HasSecurityExchange returns true if SecurityExchange is present, Tag 207 +func (m NoRelatedSym) HasSecurityExchange() bool { + return m.Has(tag.SecurityExchange) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m NoRelatedSym) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasEncodedIssuerLen returns true if EncodedIssuerLen is present, Tag 348 +func (m NoRelatedSym) HasEncodedIssuerLen() bool { + return m.Has(tag.EncodedIssuerLen) +} + +//HasEncodedIssuer returns true if EncodedIssuer is present, Tag 349 +func (m NoRelatedSym) HasEncodedIssuer() bool { + return m.Has(tag.EncodedIssuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m NoRelatedSym) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasEncodedSecurityDescLen returns true if EncodedSecurityDescLen is present, Tag 350 +func (m NoRelatedSym) HasEncodedSecurityDescLen() bool { + return m.Has(tag.EncodedSecurityDescLen) +} + +//HasEncodedSecurityDesc returns true if EncodedSecurityDesc is present, Tag 351 +func (m NoRelatedSym) HasEncodedSecurityDesc() bool { + return m.Has(tag.EncodedSecurityDesc) +} + +//HasTradingSessionID returns true if TradingSessionID is present, Tag 336 +func (m NoRelatedSym) HasTradingSessionID() bool { + return m.Has(tag.TradingSessionID) +} + +//NoRelatedSymRepeatingGroup is a repeating group, Tag 146 +type NoRelatedSymRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoRelatedSymRepeatingGroup returns an initialized, NoRelatedSymRepeatingGroup +func NewNoRelatedSymRepeatingGroup() NoRelatedSymRepeatingGroup { + return NoRelatedSymRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoRelatedSym, + quickfix.GroupTemplate{quickfix.GroupElement(tag.Symbol), quickfix.GroupElement(tag.SymbolSfx), quickfix.GroupElement(tag.SecurityID), quickfix.GroupElement(tag.IDSource), quickfix.GroupElement(tag.SecurityType), quickfix.GroupElement(tag.MaturityMonthYear), quickfix.GroupElement(tag.MaturityDay), quickfix.GroupElement(tag.PutOrCall), quickfix.GroupElement(tag.StrikePrice), quickfix.GroupElement(tag.OptAttribute), quickfix.GroupElement(tag.ContractMultiplier), quickfix.GroupElement(tag.CouponRate), quickfix.GroupElement(tag.SecurityExchange), quickfix.GroupElement(tag.Issuer), quickfix.GroupElement(tag.EncodedIssuerLen), quickfix.GroupElement(tag.EncodedIssuer), quickfix.GroupElement(tag.SecurityDesc), quickfix.GroupElement(tag.EncodedSecurityDescLen), quickfix.GroupElement(tag.EncodedSecurityDesc), quickfix.GroupElement(tag.TradingSessionID)})} +} + +//Add create and append a new NoRelatedSym to this group +func (m NoRelatedSymRepeatingGroup) Add() NoRelatedSym { + g := m.RepeatingGroup.Add() + return NoRelatedSym{g} +} + +//Get returns the ith NoRelatedSym in the NoRelatedSymRepeatinGroup +func (m NoRelatedSymRepeatingGroup) Get(i int) NoRelatedSym { + return NoRelatedSym{m.RepeatingGroup.Get(i)} +} + +//NoMDEntryTypes is a repeating group element, Tag 267 +type NoMDEntryTypes struct { + quickfix.Group +} + +//SetMDEntryType sets MDEntryType, Tag 269 +func (m NoMDEntryTypes) SetMDEntryType(v string) { + m.Set(field.NewMDEntryType(v)) +} + +//GetMDEntryType gets MDEntryType, Tag 269 +func (m NoMDEntryTypes) GetMDEntryType() (f field.MDEntryTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasMDEntryType returns true if MDEntryType is present, Tag 269 +func (m NoMDEntryTypes) HasMDEntryType() bool { + return m.Has(tag.MDEntryType) +} + +//NoMDEntryTypesRepeatingGroup is a repeating group, Tag 267 +type NoMDEntryTypesRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoMDEntryTypesRepeatingGroup returns an initialized, NoMDEntryTypesRepeatingGroup +func NewNoMDEntryTypesRepeatingGroup() NoMDEntryTypesRepeatingGroup { + return NoMDEntryTypesRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoMDEntryTypes, + quickfix.GroupTemplate{quickfix.GroupElement(tag.MDEntryType)})} +} + +//Add create and append a new NoMDEntryTypes to this group +func (m NoMDEntryTypesRepeatingGroup) Add() NoMDEntryTypes { + g := m.RepeatingGroup.Add() + return NoMDEntryTypes{g} +} + +//Get returns the ith NoMDEntryTypes in the NoMDEntryTypesRepeatinGroup +func (m NoMDEntryTypesRepeatingGroup) Get(i int) NoMDEntryTypes { + return NoMDEntryTypes{m.RepeatingGroup.Get(i)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix42/newordersingle/NewOrderSingle.generated.go b/vendor/github.com/quickfixgo/quickfix/fix42/newordersingle/NewOrderSingle.generated.go new file mode 100644 index 0000000..8011cfd --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix42/newordersingle/NewOrderSingle.generated.go @@ -0,0 +1,1309 @@ +package newordersingle + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fix42" + "github.com/quickfixgo/quickfix/tag" +) + +//NewOrderSingle is the fix42 NewOrderSingle type, MsgType = D +type NewOrderSingle struct { + fix42.Header + quickfix.Body + fix42.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a NewOrderSingle from a quickfix.Message instance +func FromMessage(m quickfix.Message) NewOrderSingle { + return NewOrderSingle{ + Header: fix42.Header{Header: m.Header}, + Body: m.Body, + Trailer: fix42.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m NewOrderSingle) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a NewOrderSingle initialized with the required fields for NewOrderSingle +func New(clordid field.ClOrdIDField, handlinst field.HandlInstField, symbol field.SymbolField, side field.SideField, transacttime field.TransactTimeField, ordtype field.OrdTypeField) (m NewOrderSingle) { + m.Header = fix42.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("D")) + m.Set(clordid) + m.Set(handlinst) + m.Set(symbol) + m.Set(side) + m.Set(transacttime) + m.Set(ordtype) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg NewOrderSingle, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "FIX.4.2", "D", r +} + +//SetAccount sets Account, Tag 1 +func (m NewOrderSingle) SetAccount(v string) { + m.Set(field.NewAccount(v)) +} + +//SetClOrdID sets ClOrdID, Tag 11 +func (m NewOrderSingle) SetClOrdID(v string) { + m.Set(field.NewClOrdID(v)) +} + +//SetCommission sets Commission, Tag 12 +func (m NewOrderSingle) SetCommission(v float64) { + m.Set(field.NewCommission(v)) +} + +//SetCommType sets CommType, Tag 13 +func (m NewOrderSingle) SetCommType(v string) { + m.Set(field.NewCommType(v)) +} + +//SetCurrency sets Currency, Tag 15 +func (m NewOrderSingle) SetCurrency(v string) { + m.Set(field.NewCurrency(v)) +} + +//SetExecInst sets ExecInst, Tag 18 +func (m NewOrderSingle) SetExecInst(v string) { + m.Set(field.NewExecInst(v)) +} + +//SetHandlInst sets HandlInst, Tag 21 +func (m NewOrderSingle) SetHandlInst(v string) { + m.Set(field.NewHandlInst(v)) +} + +//SetIDSource sets IDSource, Tag 22 +func (m NewOrderSingle) SetIDSource(v string) { + m.Set(field.NewIDSource(v)) +} + +//SetIOIid sets IOIid, Tag 23 +func (m NewOrderSingle) SetIOIid(v string) { + m.Set(field.NewIOIid(v)) +} + +//SetOrderQty sets OrderQty, Tag 38 +func (m NewOrderSingle) SetOrderQty(v float64) { + m.Set(field.NewOrderQty(v)) +} + +//SetOrdType sets OrdType, Tag 40 +func (m NewOrderSingle) SetOrdType(v string) { + m.Set(field.NewOrdType(v)) +} + +//SetPrice sets Price, Tag 44 +func (m NewOrderSingle) SetPrice(v float64) { + m.Set(field.NewPrice(v)) +} + +//SetRule80A sets Rule80A, Tag 47 +func (m NewOrderSingle) SetRule80A(v string) { + m.Set(field.NewRule80A(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m NewOrderSingle) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSide sets Side, Tag 54 +func (m NewOrderSingle) SetSide(v string) { + m.Set(field.NewSide(v)) +} + +//SetSymbol sets Symbol, Tag 55 +func (m NewOrderSingle) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetText sets Text, Tag 58 +func (m NewOrderSingle) SetText(v string) { + m.Set(field.NewText(v)) +} + +//SetTimeInForce sets TimeInForce, Tag 59 +func (m NewOrderSingle) SetTimeInForce(v string) { + m.Set(field.NewTimeInForce(v)) +} + +//SetTransactTime sets TransactTime, Tag 60 +func (m NewOrderSingle) SetTransactTime(v time.Time) { + m.Set(field.NewTransactTime(v)) +} + +//SetSettlmntTyp sets SettlmntTyp, Tag 63 +func (m NewOrderSingle) SetSettlmntTyp(v string) { + m.Set(field.NewSettlmntTyp(v)) +} + +//SetFutSettDate sets FutSettDate, Tag 64 +func (m NewOrderSingle) SetFutSettDate(v string) { + m.Set(field.NewFutSettDate(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m NewOrderSingle) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetExecBroker sets ExecBroker, Tag 76 +func (m NewOrderSingle) SetExecBroker(v string) { + m.Set(field.NewExecBroker(v)) +} + +//SetOpenClose sets OpenClose, Tag 77 +func (m NewOrderSingle) SetOpenClose(v string) { + m.Set(field.NewOpenClose(v)) +} + +//SetNoAllocs sets NoAllocs, Tag 78 +func (m NewOrderSingle) SetNoAllocs(f NoAllocsRepeatingGroup) { + m.SetGroup(f) +} + +//SetProcessCode sets ProcessCode, Tag 81 +func (m NewOrderSingle) SetProcessCode(v string) { + m.Set(field.NewProcessCode(v)) +} + +//SetStopPx sets StopPx, Tag 99 +func (m NewOrderSingle) SetStopPx(v float64) { + m.Set(field.NewStopPx(v)) +} + +//SetExDestination sets ExDestination, Tag 100 +func (m NewOrderSingle) SetExDestination(v string) { + m.Set(field.NewExDestination(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m NewOrderSingle) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m NewOrderSingle) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetClientID sets ClientID, Tag 109 +func (m NewOrderSingle) SetClientID(v string) { + m.Set(field.NewClientID(v)) +} + +//SetMinQty sets MinQty, Tag 110 +func (m NewOrderSingle) SetMinQty(v float64) { + m.Set(field.NewMinQty(v)) +} + +//SetMaxFloor sets MaxFloor, Tag 111 +func (m NewOrderSingle) SetMaxFloor(v float64) { + m.Set(field.NewMaxFloor(v)) +} + +//SetLocateReqd sets LocateReqd, Tag 114 +func (m NewOrderSingle) SetLocateReqd(v bool) { + m.Set(field.NewLocateReqd(v)) +} + +//SetQuoteID sets QuoteID, Tag 117 +func (m NewOrderSingle) SetQuoteID(v string) { + m.Set(field.NewQuoteID(v)) +} + +//SetSettlCurrency sets SettlCurrency, Tag 120 +func (m NewOrderSingle) SetSettlCurrency(v string) { + m.Set(field.NewSettlCurrency(v)) +} + +//SetForexReq sets ForexReq, Tag 121 +func (m NewOrderSingle) SetForexReq(v bool) { + m.Set(field.NewForexReq(v)) +} + +//SetExpireTime sets ExpireTime, Tag 126 +func (m NewOrderSingle) SetExpireTime(v time.Time) { + m.Set(field.NewExpireTime(v)) +} + +//SetPrevClosePx sets PrevClosePx, Tag 140 +func (m NewOrderSingle) SetPrevClosePx(v float64) { + m.Set(field.NewPrevClosePx(v)) +} + +//SetCashOrderQty sets CashOrderQty, Tag 152 +func (m NewOrderSingle) SetCashOrderQty(v float64) { + m.Set(field.NewCashOrderQty(v)) +} + +//SetSecurityType sets SecurityType, Tag 167 +func (m NewOrderSingle) SetSecurityType(v string) { + m.Set(field.NewSecurityType(v)) +} + +//SetEffectiveTime sets EffectiveTime, Tag 168 +func (m NewOrderSingle) SetEffectiveTime(v time.Time) { + m.Set(field.NewEffectiveTime(v)) +} + +//SetOrderQty2 sets OrderQty2, Tag 192 +func (m NewOrderSingle) SetOrderQty2(v float64) { + m.Set(field.NewOrderQty2(v)) +} + +//SetFutSettDate2 sets FutSettDate2, Tag 193 +func (m NewOrderSingle) SetFutSettDate2(v string) { + m.Set(field.NewFutSettDate2(v)) +} + +//SetMaturityMonthYear sets MaturityMonthYear, Tag 200 +func (m NewOrderSingle) SetMaturityMonthYear(v string) { + m.Set(field.NewMaturityMonthYear(v)) +} + +//SetPutOrCall sets PutOrCall, Tag 201 +func (m NewOrderSingle) SetPutOrCall(v int) { + m.Set(field.NewPutOrCall(v)) +} + +//SetStrikePrice sets StrikePrice, Tag 202 +func (m NewOrderSingle) SetStrikePrice(v float64) { + m.Set(field.NewStrikePrice(v)) +} + +//SetCoveredOrUncovered sets CoveredOrUncovered, Tag 203 +func (m NewOrderSingle) SetCoveredOrUncovered(v int) { + m.Set(field.NewCoveredOrUncovered(v)) +} + +//SetCustomerOrFirm sets CustomerOrFirm, Tag 204 +func (m NewOrderSingle) SetCustomerOrFirm(v int) { + m.Set(field.NewCustomerOrFirm(v)) +} + +//SetMaturityDay sets MaturityDay, Tag 205 +func (m NewOrderSingle) SetMaturityDay(v int) { + m.Set(field.NewMaturityDay(v)) +} + +//SetOptAttribute sets OptAttribute, Tag 206 +func (m NewOrderSingle) SetOptAttribute(v string) { + m.Set(field.NewOptAttribute(v)) +} + +//SetSecurityExchange sets SecurityExchange, Tag 207 +func (m NewOrderSingle) SetSecurityExchange(v string) { + m.Set(field.NewSecurityExchange(v)) +} + +//SetMaxShow sets MaxShow, Tag 210 +func (m NewOrderSingle) SetMaxShow(v float64) { + m.Set(field.NewMaxShow(v)) +} + +//SetPegDifference sets PegDifference, Tag 211 +func (m NewOrderSingle) SetPegDifference(v float64) { + m.Set(field.NewPegDifference(v)) +} + +//SetCouponRate sets CouponRate, Tag 223 +func (m NewOrderSingle) SetCouponRate(v float64) { + m.Set(field.NewCouponRate(v)) +} + +//SetContractMultiplier sets ContractMultiplier, Tag 231 +func (m NewOrderSingle) SetContractMultiplier(v float64) { + m.Set(field.NewContractMultiplier(v)) +} + +//SetEncodedIssuerLen sets EncodedIssuerLen, Tag 348 +func (m NewOrderSingle) SetEncodedIssuerLen(v int) { + m.Set(field.NewEncodedIssuerLen(v)) +} + +//SetEncodedIssuer sets EncodedIssuer, Tag 349 +func (m NewOrderSingle) SetEncodedIssuer(v string) { + m.Set(field.NewEncodedIssuer(v)) +} + +//SetEncodedSecurityDescLen sets EncodedSecurityDescLen, Tag 350 +func (m NewOrderSingle) SetEncodedSecurityDescLen(v int) { + m.Set(field.NewEncodedSecurityDescLen(v)) +} + +//SetEncodedSecurityDesc sets EncodedSecurityDesc, Tag 351 +func (m NewOrderSingle) SetEncodedSecurityDesc(v string) { + m.Set(field.NewEncodedSecurityDesc(v)) +} + +//SetEncodedTextLen sets EncodedTextLen, Tag 354 +func (m NewOrderSingle) SetEncodedTextLen(v int) { + m.Set(field.NewEncodedTextLen(v)) +} + +//SetEncodedText sets EncodedText, Tag 355 +func (m NewOrderSingle) SetEncodedText(v string) { + m.Set(field.NewEncodedText(v)) +} + +//SetComplianceID sets ComplianceID, Tag 376 +func (m NewOrderSingle) SetComplianceID(v string) { + m.Set(field.NewComplianceID(v)) +} + +//SetSolicitedFlag sets SolicitedFlag, Tag 377 +func (m NewOrderSingle) SetSolicitedFlag(v bool) { + m.Set(field.NewSolicitedFlag(v)) +} + +//SetNoTradingSessions sets NoTradingSessions, Tag 386 +func (m NewOrderSingle) SetNoTradingSessions(f NoTradingSessionsRepeatingGroup) { + m.SetGroup(f) +} + +//SetDiscretionInst sets DiscretionInst, Tag 388 +func (m NewOrderSingle) SetDiscretionInst(v string) { + m.Set(field.NewDiscretionInst(v)) +} + +//SetDiscretionOffset sets DiscretionOffset, Tag 389 +func (m NewOrderSingle) SetDiscretionOffset(v float64) { + m.Set(field.NewDiscretionOffset(v)) +} + +//SetGTBookingInst sets GTBookingInst, Tag 427 +func (m NewOrderSingle) SetGTBookingInst(v int) { + m.Set(field.NewGTBookingInst(v)) +} + +//SetExpireDate sets ExpireDate, Tag 432 +func (m NewOrderSingle) SetExpireDate(v string) { + m.Set(field.NewExpireDate(v)) +} + +//SetClearingFirm sets ClearingFirm, Tag 439 +func (m NewOrderSingle) SetClearingFirm(v string) { + m.Set(field.NewClearingFirm(v)) +} + +//SetClearingAccount sets ClearingAccount, Tag 440 +func (m NewOrderSingle) SetClearingAccount(v string) { + m.Set(field.NewClearingAccount(v)) +} + +//GetAccount gets Account, Tag 1 +func (m NewOrderSingle) GetAccount() (f field.AccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdID gets ClOrdID, Tag 11 +func (m NewOrderSingle) GetClOrdID() (f field.ClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommission gets Commission, Tag 12 +func (m NewOrderSingle) GetCommission() (f field.CommissionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommType gets CommType, Tag 13 +func (m NewOrderSingle) GetCommType() (f field.CommTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCurrency gets Currency, Tag 15 +func (m NewOrderSingle) GetCurrency() (f field.CurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecInst gets ExecInst, Tag 18 +func (m NewOrderSingle) GetExecInst() (f field.ExecInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetHandlInst gets HandlInst, Tag 21 +func (m NewOrderSingle) GetHandlInst() (f field.HandlInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIDSource gets IDSource, Tag 22 +func (m NewOrderSingle) GetIDSource() (f field.IDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIOIid gets IOIid, Tag 23 +func (m NewOrderSingle) GetIOIid() (f field.IOIidField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty gets OrderQty, Tag 38 +func (m NewOrderSingle) GetOrderQty() (f field.OrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdType gets OrdType, Tag 40 +func (m NewOrderSingle) GetOrdType() (f field.OrdTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrice gets Price, Tag 44 +func (m NewOrderSingle) GetPrice() (f field.PriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRule80A gets Rule80A, Tag 47 +func (m NewOrderSingle) GetRule80A() (f field.Rule80AField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m NewOrderSingle) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSide gets Side, Tag 54 +func (m NewOrderSingle) GetSide() (f field.SideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbol gets Symbol, Tag 55 +func (m NewOrderSingle) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetText gets Text, Tag 58 +func (m NewOrderSingle) GetText() (f field.TextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTimeInForce gets TimeInForce, Tag 59 +func (m NewOrderSingle) GetTimeInForce() (f field.TimeInForceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTransactTime gets TransactTime, Tag 60 +func (m NewOrderSingle) GetTransactTime() (f field.TransactTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlmntTyp gets SettlmntTyp, Tag 63 +func (m NewOrderSingle) GetSettlmntTyp() (f field.SettlmntTypField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFutSettDate gets FutSettDate, Tag 64 +func (m NewOrderSingle) GetFutSettDate() (f field.FutSettDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m NewOrderSingle) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecBroker gets ExecBroker, Tag 76 +func (m NewOrderSingle) GetExecBroker() (f field.ExecBrokerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOpenClose gets OpenClose, Tag 77 +func (m NewOrderSingle) GetOpenClose() (f field.OpenCloseField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoAllocs gets NoAllocs, Tag 78 +func (m NewOrderSingle) GetNoAllocs() (NoAllocsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoAllocsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetProcessCode gets ProcessCode, Tag 81 +func (m NewOrderSingle) GetProcessCode() (f field.ProcessCodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStopPx gets StopPx, Tag 99 +func (m NewOrderSingle) GetStopPx() (f field.StopPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExDestination gets ExDestination, Tag 100 +func (m NewOrderSingle) GetExDestination() (f field.ExDestinationField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m NewOrderSingle) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m NewOrderSingle) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClientID gets ClientID, Tag 109 +func (m NewOrderSingle) GetClientID() (f field.ClientIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMinQty gets MinQty, Tag 110 +func (m NewOrderSingle) GetMinQty() (f field.MinQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxFloor gets MaxFloor, Tag 111 +func (m NewOrderSingle) GetMaxFloor() (f field.MaxFloorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLocateReqd gets LocateReqd, Tag 114 +func (m NewOrderSingle) GetLocateReqd() (f field.LocateReqdField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetQuoteID gets QuoteID, Tag 117 +func (m NewOrderSingle) GetQuoteID() (f field.QuoteIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrency gets SettlCurrency, Tag 120 +func (m NewOrderSingle) GetSettlCurrency() (f field.SettlCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetForexReq gets ForexReq, Tag 121 +func (m NewOrderSingle) GetForexReq() (f field.ForexReqField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireTime gets ExpireTime, Tag 126 +func (m NewOrderSingle) GetExpireTime() (f field.ExpireTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrevClosePx gets PrevClosePx, Tag 140 +func (m NewOrderSingle) GetPrevClosePx() (f field.PrevClosePxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashOrderQty gets CashOrderQty, Tag 152 +func (m NewOrderSingle) GetCashOrderQty() (f field.CashOrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityType gets SecurityType, Tag 167 +func (m NewOrderSingle) GetSecurityType() (f field.SecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEffectiveTime gets EffectiveTime, Tag 168 +func (m NewOrderSingle) GetEffectiveTime() (f field.EffectiveTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty2 gets OrderQty2, Tag 192 +func (m NewOrderSingle) GetOrderQty2() (f field.OrderQty2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFutSettDate2 gets FutSettDate2, Tag 193 +func (m NewOrderSingle) GetFutSettDate2() (f field.FutSettDate2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityMonthYear gets MaturityMonthYear, Tag 200 +func (m NewOrderSingle) GetMaturityMonthYear() (f field.MaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPutOrCall gets PutOrCall, Tag 201 +func (m NewOrderSingle) GetPutOrCall() (f field.PutOrCallField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikePrice gets StrikePrice, Tag 202 +func (m NewOrderSingle) GetStrikePrice() (f field.StrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCoveredOrUncovered gets CoveredOrUncovered, Tag 203 +func (m NewOrderSingle) GetCoveredOrUncovered() (f field.CoveredOrUncoveredField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCustomerOrFirm gets CustomerOrFirm, Tag 204 +func (m NewOrderSingle) GetCustomerOrFirm() (f field.CustomerOrFirmField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityDay gets MaturityDay, Tag 205 +func (m NewOrderSingle) GetMaturityDay() (f field.MaturityDayField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOptAttribute gets OptAttribute, Tag 206 +func (m NewOrderSingle) GetOptAttribute() (f field.OptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityExchange gets SecurityExchange, Tag 207 +func (m NewOrderSingle) GetSecurityExchange() (f field.SecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxShow gets MaxShow, Tag 210 +func (m NewOrderSingle) GetMaxShow() (f field.MaxShowField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegDifference gets PegDifference, Tag 211 +func (m NewOrderSingle) GetPegDifference() (f field.PegDifferenceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponRate gets CouponRate, Tag 223 +func (m NewOrderSingle) GetCouponRate() (f field.CouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractMultiplier gets ContractMultiplier, Tag 231 +func (m NewOrderSingle) GetContractMultiplier() (f field.ContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuerLen gets EncodedIssuerLen, Tag 348 +func (m NewOrderSingle) GetEncodedIssuerLen() (f field.EncodedIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuer gets EncodedIssuer, Tag 349 +func (m NewOrderSingle) GetEncodedIssuer() (f field.EncodedIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDescLen gets EncodedSecurityDescLen, Tag 350 +func (m NewOrderSingle) GetEncodedSecurityDescLen() (f field.EncodedSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDesc gets EncodedSecurityDesc, Tag 351 +func (m NewOrderSingle) GetEncodedSecurityDesc() (f field.EncodedSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedTextLen gets EncodedTextLen, Tag 354 +func (m NewOrderSingle) GetEncodedTextLen() (f field.EncodedTextLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedText gets EncodedText, Tag 355 +func (m NewOrderSingle) GetEncodedText() (f field.EncodedTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetComplianceID gets ComplianceID, Tag 376 +func (m NewOrderSingle) GetComplianceID() (f field.ComplianceIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSolicitedFlag gets SolicitedFlag, Tag 377 +func (m NewOrderSingle) GetSolicitedFlag() (f field.SolicitedFlagField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoTradingSessions gets NoTradingSessions, Tag 386 +func (m NewOrderSingle) GetNoTradingSessions() (NoTradingSessionsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoTradingSessionsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetDiscretionInst gets DiscretionInst, Tag 388 +func (m NewOrderSingle) GetDiscretionInst() (f field.DiscretionInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionOffset gets DiscretionOffset, Tag 389 +func (m NewOrderSingle) GetDiscretionOffset() (f field.DiscretionOffsetField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetGTBookingInst gets GTBookingInst, Tag 427 +func (m NewOrderSingle) GetGTBookingInst() (f field.GTBookingInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireDate gets ExpireDate, Tag 432 +func (m NewOrderSingle) GetExpireDate() (f field.ExpireDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClearingFirm gets ClearingFirm, Tag 439 +func (m NewOrderSingle) GetClearingFirm() (f field.ClearingFirmField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClearingAccount gets ClearingAccount, Tag 440 +func (m NewOrderSingle) GetClearingAccount() (f field.ClearingAccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasAccount returns true if Account is present, Tag 1 +func (m NewOrderSingle) HasAccount() bool { + return m.Has(tag.Account) +} + +//HasClOrdID returns true if ClOrdID is present, Tag 11 +func (m NewOrderSingle) HasClOrdID() bool { + return m.Has(tag.ClOrdID) +} + +//HasCommission returns true if Commission is present, Tag 12 +func (m NewOrderSingle) HasCommission() bool { + return m.Has(tag.Commission) +} + +//HasCommType returns true if CommType is present, Tag 13 +func (m NewOrderSingle) HasCommType() bool { + return m.Has(tag.CommType) +} + +//HasCurrency returns true if Currency is present, Tag 15 +func (m NewOrderSingle) HasCurrency() bool { + return m.Has(tag.Currency) +} + +//HasExecInst returns true if ExecInst is present, Tag 18 +func (m NewOrderSingle) HasExecInst() bool { + return m.Has(tag.ExecInst) +} + +//HasHandlInst returns true if HandlInst is present, Tag 21 +func (m NewOrderSingle) HasHandlInst() bool { + return m.Has(tag.HandlInst) +} + +//HasIDSource returns true if IDSource is present, Tag 22 +func (m NewOrderSingle) HasIDSource() bool { + return m.Has(tag.IDSource) +} + +//HasIOIid returns true if IOIid is present, Tag 23 +func (m NewOrderSingle) HasIOIid() bool { + return m.Has(tag.IOIid) +} + +//HasOrderQty returns true if OrderQty is present, Tag 38 +func (m NewOrderSingle) HasOrderQty() bool { + return m.Has(tag.OrderQty) +} + +//HasOrdType returns true if OrdType is present, Tag 40 +func (m NewOrderSingle) HasOrdType() bool { + return m.Has(tag.OrdType) +} + +//HasPrice returns true if Price is present, Tag 44 +func (m NewOrderSingle) HasPrice() bool { + return m.Has(tag.Price) +} + +//HasRule80A returns true if Rule80A is present, Tag 47 +func (m NewOrderSingle) HasRule80A() bool { + return m.Has(tag.Rule80A) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m NewOrderSingle) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSide returns true if Side is present, Tag 54 +func (m NewOrderSingle) HasSide() bool { + return m.Has(tag.Side) +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m NewOrderSingle) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasText returns true if Text is present, Tag 58 +func (m NewOrderSingle) HasText() bool { + return m.Has(tag.Text) +} + +//HasTimeInForce returns true if TimeInForce is present, Tag 59 +func (m NewOrderSingle) HasTimeInForce() bool { + return m.Has(tag.TimeInForce) +} + +//HasTransactTime returns true if TransactTime is present, Tag 60 +func (m NewOrderSingle) HasTransactTime() bool { + return m.Has(tag.TransactTime) +} + +//HasSettlmntTyp returns true if SettlmntTyp is present, Tag 63 +func (m NewOrderSingle) HasSettlmntTyp() bool { + return m.Has(tag.SettlmntTyp) +} + +//HasFutSettDate returns true if FutSettDate is present, Tag 64 +func (m NewOrderSingle) HasFutSettDate() bool { + return m.Has(tag.FutSettDate) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m NewOrderSingle) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasExecBroker returns true if ExecBroker is present, Tag 76 +func (m NewOrderSingle) HasExecBroker() bool { + return m.Has(tag.ExecBroker) +} + +//HasOpenClose returns true if OpenClose is present, Tag 77 +func (m NewOrderSingle) HasOpenClose() bool { + return m.Has(tag.OpenClose) +} + +//HasNoAllocs returns true if NoAllocs is present, Tag 78 +func (m NewOrderSingle) HasNoAllocs() bool { + return m.Has(tag.NoAllocs) +} + +//HasProcessCode returns true if ProcessCode is present, Tag 81 +func (m NewOrderSingle) HasProcessCode() bool { + return m.Has(tag.ProcessCode) +} + +//HasStopPx returns true if StopPx is present, Tag 99 +func (m NewOrderSingle) HasStopPx() bool { + return m.Has(tag.StopPx) +} + +//HasExDestination returns true if ExDestination is present, Tag 100 +func (m NewOrderSingle) HasExDestination() bool { + return m.Has(tag.ExDestination) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m NewOrderSingle) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m NewOrderSingle) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasClientID returns true if ClientID is present, Tag 109 +func (m NewOrderSingle) HasClientID() bool { + return m.Has(tag.ClientID) +} + +//HasMinQty returns true if MinQty is present, Tag 110 +func (m NewOrderSingle) HasMinQty() bool { + return m.Has(tag.MinQty) +} + +//HasMaxFloor returns true if MaxFloor is present, Tag 111 +func (m NewOrderSingle) HasMaxFloor() bool { + return m.Has(tag.MaxFloor) +} + +//HasLocateReqd returns true if LocateReqd is present, Tag 114 +func (m NewOrderSingle) HasLocateReqd() bool { + return m.Has(tag.LocateReqd) +} + +//HasQuoteID returns true if QuoteID is present, Tag 117 +func (m NewOrderSingle) HasQuoteID() bool { + return m.Has(tag.QuoteID) +} + +//HasSettlCurrency returns true if SettlCurrency is present, Tag 120 +func (m NewOrderSingle) HasSettlCurrency() bool { + return m.Has(tag.SettlCurrency) +} + +//HasForexReq returns true if ForexReq is present, Tag 121 +func (m NewOrderSingle) HasForexReq() bool { + return m.Has(tag.ForexReq) +} + +//HasExpireTime returns true if ExpireTime is present, Tag 126 +func (m NewOrderSingle) HasExpireTime() bool { + return m.Has(tag.ExpireTime) +} + +//HasPrevClosePx returns true if PrevClosePx is present, Tag 140 +func (m NewOrderSingle) HasPrevClosePx() bool { + return m.Has(tag.PrevClosePx) +} + +//HasCashOrderQty returns true if CashOrderQty is present, Tag 152 +func (m NewOrderSingle) HasCashOrderQty() bool { + return m.Has(tag.CashOrderQty) +} + +//HasSecurityType returns true if SecurityType is present, Tag 167 +func (m NewOrderSingle) HasSecurityType() bool { + return m.Has(tag.SecurityType) +} + +//HasEffectiveTime returns true if EffectiveTime is present, Tag 168 +func (m NewOrderSingle) HasEffectiveTime() bool { + return m.Has(tag.EffectiveTime) +} + +//HasOrderQty2 returns true if OrderQty2 is present, Tag 192 +func (m NewOrderSingle) HasOrderQty2() bool { + return m.Has(tag.OrderQty2) +} + +//HasFutSettDate2 returns true if FutSettDate2 is present, Tag 193 +func (m NewOrderSingle) HasFutSettDate2() bool { + return m.Has(tag.FutSettDate2) +} + +//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200 +func (m NewOrderSingle) HasMaturityMonthYear() bool { + return m.Has(tag.MaturityMonthYear) +} + +//HasPutOrCall returns true if PutOrCall is present, Tag 201 +func (m NewOrderSingle) HasPutOrCall() bool { + return m.Has(tag.PutOrCall) +} + +//HasStrikePrice returns true if StrikePrice is present, Tag 202 +func (m NewOrderSingle) HasStrikePrice() bool { + return m.Has(tag.StrikePrice) +} + +//HasCoveredOrUncovered returns true if CoveredOrUncovered is present, Tag 203 +func (m NewOrderSingle) HasCoveredOrUncovered() bool { + return m.Has(tag.CoveredOrUncovered) +} + +//HasCustomerOrFirm returns true if CustomerOrFirm is present, Tag 204 +func (m NewOrderSingle) HasCustomerOrFirm() bool { + return m.Has(tag.CustomerOrFirm) +} + +//HasMaturityDay returns true if MaturityDay is present, Tag 205 +func (m NewOrderSingle) HasMaturityDay() bool { + return m.Has(tag.MaturityDay) +} + +//HasOptAttribute returns true if OptAttribute is present, Tag 206 +func (m NewOrderSingle) HasOptAttribute() bool { + return m.Has(tag.OptAttribute) +} + +//HasSecurityExchange returns true if SecurityExchange is present, Tag 207 +func (m NewOrderSingle) HasSecurityExchange() bool { + return m.Has(tag.SecurityExchange) +} + +//HasMaxShow returns true if MaxShow is present, Tag 210 +func (m NewOrderSingle) HasMaxShow() bool { + return m.Has(tag.MaxShow) +} + +//HasPegDifference returns true if PegDifference is present, Tag 211 +func (m NewOrderSingle) HasPegDifference() bool { + return m.Has(tag.PegDifference) +} + +//HasCouponRate returns true if CouponRate is present, Tag 223 +func (m NewOrderSingle) HasCouponRate() bool { + return m.Has(tag.CouponRate) +} + +//HasContractMultiplier returns true if ContractMultiplier is present, Tag 231 +func (m NewOrderSingle) HasContractMultiplier() bool { + return m.Has(tag.ContractMultiplier) +} + +//HasEncodedIssuerLen returns true if EncodedIssuerLen is present, Tag 348 +func (m NewOrderSingle) HasEncodedIssuerLen() bool { + return m.Has(tag.EncodedIssuerLen) +} + +//HasEncodedIssuer returns true if EncodedIssuer is present, Tag 349 +func (m NewOrderSingle) HasEncodedIssuer() bool { + return m.Has(tag.EncodedIssuer) +} + +//HasEncodedSecurityDescLen returns true if EncodedSecurityDescLen is present, Tag 350 +func (m NewOrderSingle) HasEncodedSecurityDescLen() bool { + return m.Has(tag.EncodedSecurityDescLen) +} + +//HasEncodedSecurityDesc returns true if EncodedSecurityDesc is present, Tag 351 +func (m NewOrderSingle) HasEncodedSecurityDesc() bool { + return m.Has(tag.EncodedSecurityDesc) +} + +//HasEncodedTextLen returns true if EncodedTextLen is present, Tag 354 +func (m NewOrderSingle) HasEncodedTextLen() bool { + return m.Has(tag.EncodedTextLen) +} + +//HasEncodedText returns true if EncodedText is present, Tag 355 +func (m NewOrderSingle) HasEncodedText() bool { + return m.Has(tag.EncodedText) +} + +//HasComplianceID returns true if ComplianceID is present, Tag 376 +func (m NewOrderSingle) HasComplianceID() bool { + return m.Has(tag.ComplianceID) +} + +//HasSolicitedFlag returns true if SolicitedFlag is present, Tag 377 +func (m NewOrderSingle) HasSolicitedFlag() bool { + return m.Has(tag.SolicitedFlag) +} + +//HasNoTradingSessions returns true if NoTradingSessions is present, Tag 386 +func (m NewOrderSingle) HasNoTradingSessions() bool { + return m.Has(tag.NoTradingSessions) +} + +//HasDiscretionInst returns true if DiscretionInst is present, Tag 388 +func (m NewOrderSingle) HasDiscretionInst() bool { + return m.Has(tag.DiscretionInst) +} + +//HasDiscretionOffset returns true if DiscretionOffset is present, Tag 389 +func (m NewOrderSingle) HasDiscretionOffset() bool { + return m.Has(tag.DiscretionOffset) +} + +//HasGTBookingInst returns true if GTBookingInst is present, Tag 427 +func (m NewOrderSingle) HasGTBookingInst() bool { + return m.Has(tag.GTBookingInst) +} + +//HasExpireDate returns true if ExpireDate is present, Tag 432 +func (m NewOrderSingle) HasExpireDate() bool { + return m.Has(tag.ExpireDate) +} + +//HasClearingFirm returns true if ClearingFirm is present, Tag 439 +func (m NewOrderSingle) HasClearingFirm() bool { + return m.Has(tag.ClearingFirm) +} + +//HasClearingAccount returns true if ClearingAccount is present, Tag 440 +func (m NewOrderSingle) HasClearingAccount() bool { + return m.Has(tag.ClearingAccount) +} + +//NoAllocs is a repeating group element, Tag 78 +type NoAllocs struct { + quickfix.Group +} + +//SetAllocAccount sets AllocAccount, Tag 79 +func (m NoAllocs) SetAllocAccount(v string) { + m.Set(field.NewAllocAccount(v)) +} + +//SetAllocShares sets AllocShares, Tag 80 +func (m NoAllocs) SetAllocShares(v float64) { + m.Set(field.NewAllocShares(v)) +} + +//GetAllocAccount gets AllocAccount, Tag 79 +func (m NoAllocs) GetAllocAccount() (f field.AllocAccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAllocShares gets AllocShares, Tag 80 +func (m NoAllocs) GetAllocShares() (f field.AllocSharesField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasAllocAccount returns true if AllocAccount is present, Tag 79 +func (m NoAllocs) HasAllocAccount() bool { + return m.Has(tag.AllocAccount) +} + +//HasAllocShares returns true if AllocShares is present, Tag 80 +func (m NoAllocs) HasAllocShares() bool { + return m.Has(tag.AllocShares) +} + +//NoAllocsRepeatingGroup is a repeating group, Tag 78 +type NoAllocsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoAllocsRepeatingGroup returns an initialized, NoAllocsRepeatingGroup +func NewNoAllocsRepeatingGroup() NoAllocsRepeatingGroup { + return NoAllocsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoAllocs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.AllocAccount), quickfix.GroupElement(tag.AllocShares)})} +} + +//Add create and append a new NoAllocs to this group +func (m NoAllocsRepeatingGroup) Add() NoAllocs { + g := m.RepeatingGroup.Add() + return NoAllocs{g} +} + +//Get returns the ith NoAllocs in the NoAllocsRepeatinGroup +func (m NoAllocsRepeatingGroup) Get(i int) NoAllocs { + return NoAllocs{m.RepeatingGroup.Get(i)} +} + +//NoTradingSessions is a repeating group element, Tag 386 +type NoTradingSessions struct { + quickfix.Group +} + +//SetTradingSessionID sets TradingSessionID, Tag 336 +func (m NoTradingSessions) SetTradingSessionID(v string) { + m.Set(field.NewTradingSessionID(v)) +} + +//GetTradingSessionID gets TradingSessionID, Tag 336 +func (m NoTradingSessions) GetTradingSessionID() (f field.TradingSessionIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasTradingSessionID returns true if TradingSessionID is present, Tag 336 +func (m NoTradingSessions) HasTradingSessionID() bool { + return m.Has(tag.TradingSessionID) +} + +//NoTradingSessionsRepeatingGroup is a repeating group, Tag 386 +type NoTradingSessionsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoTradingSessionsRepeatingGroup returns an initialized, NoTradingSessionsRepeatingGroup +func NewNoTradingSessionsRepeatingGroup() NoTradingSessionsRepeatingGroup { + return NoTradingSessionsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoTradingSessions, + quickfix.GroupTemplate{quickfix.GroupElement(tag.TradingSessionID)})} +} + +//Add create and append a new NoTradingSessions to this group +func (m NoTradingSessionsRepeatingGroup) Add() NoTradingSessions { + g := m.RepeatingGroup.Add() + return NoTradingSessions{g} +} + +//Get returns the ith NoTradingSessions in the NoTradingSessionsRepeatinGroup +func (m NoTradingSessionsRepeatingGroup) Get(i int) NoTradingSessions { + return NoTradingSessions{m.RepeatingGroup.Get(i)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix42/ordercancelrequest/OrderCancelRequest.generated.go b/vendor/github.com/quickfixgo/quickfix/fix42/ordercancelrequest/OrderCancelRequest.generated.go new file mode 100644 index 0000000..7f0bc38 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix42/ordercancelrequest/OrderCancelRequest.generated.go @@ -0,0 +1,626 @@ +package ordercancelrequest + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fix42" + "github.com/quickfixgo/quickfix/tag" +) + +//OrderCancelRequest is the fix42 OrderCancelRequest type, MsgType = F +type OrderCancelRequest struct { + fix42.Header + quickfix.Body + fix42.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a OrderCancelRequest from a quickfix.Message instance +func FromMessage(m quickfix.Message) OrderCancelRequest { + return OrderCancelRequest{ + Header: fix42.Header{Header: m.Header}, + Body: m.Body, + Trailer: fix42.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m OrderCancelRequest) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a OrderCancelRequest initialized with the required fields for OrderCancelRequest +func New(origclordid field.OrigClOrdIDField, clordid field.ClOrdIDField, symbol field.SymbolField, side field.SideField, transacttime field.TransactTimeField) (m OrderCancelRequest) { + m.Header = fix42.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("F")) + m.Set(origclordid) + m.Set(clordid) + m.Set(symbol) + m.Set(side) + m.Set(transacttime) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg OrderCancelRequest, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "FIX.4.2", "F", r +} + +//SetAccount sets Account, Tag 1 +func (m OrderCancelRequest) SetAccount(v string) { + m.Set(field.NewAccount(v)) +} + +//SetClOrdID sets ClOrdID, Tag 11 +func (m OrderCancelRequest) SetClOrdID(v string) { + m.Set(field.NewClOrdID(v)) +} + +//SetIDSource sets IDSource, Tag 22 +func (m OrderCancelRequest) SetIDSource(v string) { + m.Set(field.NewIDSource(v)) +} + +//SetOrderID sets OrderID, Tag 37 +func (m OrderCancelRequest) SetOrderID(v string) { + m.Set(field.NewOrderID(v)) +} + +//SetOrderQty sets OrderQty, Tag 38 +func (m OrderCancelRequest) SetOrderQty(v float64) { + m.Set(field.NewOrderQty(v)) +} + +//SetOrigClOrdID sets OrigClOrdID, Tag 41 +func (m OrderCancelRequest) SetOrigClOrdID(v string) { + m.Set(field.NewOrigClOrdID(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m OrderCancelRequest) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSide sets Side, Tag 54 +func (m OrderCancelRequest) SetSide(v string) { + m.Set(field.NewSide(v)) +} + +//SetSymbol sets Symbol, Tag 55 +func (m OrderCancelRequest) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetText sets Text, Tag 58 +func (m OrderCancelRequest) SetText(v string) { + m.Set(field.NewText(v)) +} + +//SetTransactTime sets TransactTime, Tag 60 +func (m OrderCancelRequest) SetTransactTime(v time.Time) { + m.Set(field.NewTransactTime(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m OrderCancelRequest) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetListID sets ListID, Tag 66 +func (m OrderCancelRequest) SetListID(v string) { + m.Set(field.NewListID(v)) +} + +//SetExecBroker sets ExecBroker, Tag 76 +func (m OrderCancelRequest) SetExecBroker(v string) { + m.Set(field.NewExecBroker(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m OrderCancelRequest) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m OrderCancelRequest) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetClientID sets ClientID, Tag 109 +func (m OrderCancelRequest) SetClientID(v string) { + m.Set(field.NewClientID(v)) +} + +//SetCashOrderQty sets CashOrderQty, Tag 152 +func (m OrderCancelRequest) SetCashOrderQty(v float64) { + m.Set(field.NewCashOrderQty(v)) +} + +//SetSecurityType sets SecurityType, Tag 167 +func (m OrderCancelRequest) SetSecurityType(v string) { + m.Set(field.NewSecurityType(v)) +} + +//SetMaturityMonthYear sets MaturityMonthYear, Tag 200 +func (m OrderCancelRequest) SetMaturityMonthYear(v string) { + m.Set(field.NewMaturityMonthYear(v)) +} + +//SetPutOrCall sets PutOrCall, Tag 201 +func (m OrderCancelRequest) SetPutOrCall(v int) { + m.Set(field.NewPutOrCall(v)) +} + +//SetStrikePrice sets StrikePrice, Tag 202 +func (m OrderCancelRequest) SetStrikePrice(v float64) { + m.Set(field.NewStrikePrice(v)) +} + +//SetMaturityDay sets MaturityDay, Tag 205 +func (m OrderCancelRequest) SetMaturityDay(v int) { + m.Set(field.NewMaturityDay(v)) +} + +//SetOptAttribute sets OptAttribute, Tag 206 +func (m OrderCancelRequest) SetOptAttribute(v string) { + m.Set(field.NewOptAttribute(v)) +} + +//SetSecurityExchange sets SecurityExchange, Tag 207 +func (m OrderCancelRequest) SetSecurityExchange(v string) { + m.Set(field.NewSecurityExchange(v)) +} + +//SetCouponRate sets CouponRate, Tag 223 +func (m OrderCancelRequest) SetCouponRate(v float64) { + m.Set(field.NewCouponRate(v)) +} + +//SetContractMultiplier sets ContractMultiplier, Tag 231 +func (m OrderCancelRequest) SetContractMultiplier(v float64) { + m.Set(field.NewContractMultiplier(v)) +} + +//SetEncodedIssuerLen sets EncodedIssuerLen, Tag 348 +func (m OrderCancelRequest) SetEncodedIssuerLen(v int) { + m.Set(field.NewEncodedIssuerLen(v)) +} + +//SetEncodedIssuer sets EncodedIssuer, Tag 349 +func (m OrderCancelRequest) SetEncodedIssuer(v string) { + m.Set(field.NewEncodedIssuer(v)) +} + +//SetEncodedSecurityDescLen sets EncodedSecurityDescLen, Tag 350 +func (m OrderCancelRequest) SetEncodedSecurityDescLen(v int) { + m.Set(field.NewEncodedSecurityDescLen(v)) +} + +//SetEncodedSecurityDesc sets EncodedSecurityDesc, Tag 351 +func (m OrderCancelRequest) SetEncodedSecurityDesc(v string) { + m.Set(field.NewEncodedSecurityDesc(v)) +} + +//SetEncodedTextLen sets EncodedTextLen, Tag 354 +func (m OrderCancelRequest) SetEncodedTextLen(v int) { + m.Set(field.NewEncodedTextLen(v)) +} + +//SetEncodedText sets EncodedText, Tag 355 +func (m OrderCancelRequest) SetEncodedText(v string) { + m.Set(field.NewEncodedText(v)) +} + +//SetComplianceID sets ComplianceID, Tag 376 +func (m OrderCancelRequest) SetComplianceID(v string) { + m.Set(field.NewComplianceID(v)) +} + +//SetSolicitedFlag sets SolicitedFlag, Tag 377 +func (m OrderCancelRequest) SetSolicitedFlag(v bool) { + m.Set(field.NewSolicitedFlag(v)) +} + +//GetAccount gets Account, Tag 1 +func (m OrderCancelRequest) GetAccount() (f field.AccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdID gets ClOrdID, Tag 11 +func (m OrderCancelRequest) GetClOrdID() (f field.ClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIDSource gets IDSource, Tag 22 +func (m OrderCancelRequest) GetIDSource() (f field.IDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderID gets OrderID, Tag 37 +func (m OrderCancelRequest) GetOrderID() (f field.OrderIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty gets OrderQty, Tag 38 +func (m OrderCancelRequest) GetOrderQty() (f field.OrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrigClOrdID gets OrigClOrdID, Tag 41 +func (m OrderCancelRequest) GetOrigClOrdID() (f field.OrigClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m OrderCancelRequest) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSide gets Side, Tag 54 +func (m OrderCancelRequest) GetSide() (f field.SideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbol gets Symbol, Tag 55 +func (m OrderCancelRequest) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetText gets Text, Tag 58 +func (m OrderCancelRequest) GetText() (f field.TextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTransactTime gets TransactTime, Tag 60 +func (m OrderCancelRequest) GetTransactTime() (f field.TransactTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m OrderCancelRequest) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetListID gets ListID, Tag 66 +func (m OrderCancelRequest) GetListID() (f field.ListIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecBroker gets ExecBroker, Tag 76 +func (m OrderCancelRequest) GetExecBroker() (f field.ExecBrokerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m OrderCancelRequest) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m OrderCancelRequest) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClientID gets ClientID, Tag 109 +func (m OrderCancelRequest) GetClientID() (f field.ClientIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashOrderQty gets CashOrderQty, Tag 152 +func (m OrderCancelRequest) GetCashOrderQty() (f field.CashOrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityType gets SecurityType, Tag 167 +func (m OrderCancelRequest) GetSecurityType() (f field.SecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityMonthYear gets MaturityMonthYear, Tag 200 +func (m OrderCancelRequest) GetMaturityMonthYear() (f field.MaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPutOrCall gets PutOrCall, Tag 201 +func (m OrderCancelRequest) GetPutOrCall() (f field.PutOrCallField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikePrice gets StrikePrice, Tag 202 +func (m OrderCancelRequest) GetStrikePrice() (f field.StrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityDay gets MaturityDay, Tag 205 +func (m OrderCancelRequest) GetMaturityDay() (f field.MaturityDayField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOptAttribute gets OptAttribute, Tag 206 +func (m OrderCancelRequest) GetOptAttribute() (f field.OptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityExchange gets SecurityExchange, Tag 207 +func (m OrderCancelRequest) GetSecurityExchange() (f field.SecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponRate gets CouponRate, Tag 223 +func (m OrderCancelRequest) GetCouponRate() (f field.CouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractMultiplier gets ContractMultiplier, Tag 231 +func (m OrderCancelRequest) GetContractMultiplier() (f field.ContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuerLen gets EncodedIssuerLen, Tag 348 +func (m OrderCancelRequest) GetEncodedIssuerLen() (f field.EncodedIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuer gets EncodedIssuer, Tag 349 +func (m OrderCancelRequest) GetEncodedIssuer() (f field.EncodedIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDescLen gets EncodedSecurityDescLen, Tag 350 +func (m OrderCancelRequest) GetEncodedSecurityDescLen() (f field.EncodedSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDesc gets EncodedSecurityDesc, Tag 351 +func (m OrderCancelRequest) GetEncodedSecurityDesc() (f field.EncodedSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedTextLen gets EncodedTextLen, Tag 354 +func (m OrderCancelRequest) GetEncodedTextLen() (f field.EncodedTextLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedText gets EncodedText, Tag 355 +func (m OrderCancelRequest) GetEncodedText() (f field.EncodedTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetComplianceID gets ComplianceID, Tag 376 +func (m OrderCancelRequest) GetComplianceID() (f field.ComplianceIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSolicitedFlag gets SolicitedFlag, Tag 377 +func (m OrderCancelRequest) GetSolicitedFlag() (f field.SolicitedFlagField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasAccount returns true if Account is present, Tag 1 +func (m OrderCancelRequest) HasAccount() bool { + return m.Has(tag.Account) +} + +//HasClOrdID returns true if ClOrdID is present, Tag 11 +func (m OrderCancelRequest) HasClOrdID() bool { + return m.Has(tag.ClOrdID) +} + +//HasIDSource returns true if IDSource is present, Tag 22 +func (m OrderCancelRequest) HasIDSource() bool { + return m.Has(tag.IDSource) +} + +//HasOrderID returns true if OrderID is present, Tag 37 +func (m OrderCancelRequest) HasOrderID() bool { + return m.Has(tag.OrderID) +} + +//HasOrderQty returns true if OrderQty is present, Tag 38 +func (m OrderCancelRequest) HasOrderQty() bool { + return m.Has(tag.OrderQty) +} + +//HasOrigClOrdID returns true if OrigClOrdID is present, Tag 41 +func (m OrderCancelRequest) HasOrigClOrdID() bool { + return m.Has(tag.OrigClOrdID) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m OrderCancelRequest) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSide returns true if Side is present, Tag 54 +func (m OrderCancelRequest) HasSide() bool { + return m.Has(tag.Side) +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m OrderCancelRequest) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasText returns true if Text is present, Tag 58 +func (m OrderCancelRequest) HasText() bool { + return m.Has(tag.Text) +} + +//HasTransactTime returns true if TransactTime is present, Tag 60 +func (m OrderCancelRequest) HasTransactTime() bool { + return m.Has(tag.TransactTime) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m OrderCancelRequest) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasListID returns true if ListID is present, Tag 66 +func (m OrderCancelRequest) HasListID() bool { + return m.Has(tag.ListID) +} + +//HasExecBroker returns true if ExecBroker is present, Tag 76 +func (m OrderCancelRequest) HasExecBroker() bool { + return m.Has(tag.ExecBroker) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m OrderCancelRequest) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m OrderCancelRequest) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasClientID returns true if ClientID is present, Tag 109 +func (m OrderCancelRequest) HasClientID() bool { + return m.Has(tag.ClientID) +} + +//HasCashOrderQty returns true if CashOrderQty is present, Tag 152 +func (m OrderCancelRequest) HasCashOrderQty() bool { + return m.Has(tag.CashOrderQty) +} + +//HasSecurityType returns true if SecurityType is present, Tag 167 +func (m OrderCancelRequest) HasSecurityType() bool { + return m.Has(tag.SecurityType) +} + +//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200 +func (m OrderCancelRequest) HasMaturityMonthYear() bool { + return m.Has(tag.MaturityMonthYear) +} + +//HasPutOrCall returns true if PutOrCall is present, Tag 201 +func (m OrderCancelRequest) HasPutOrCall() bool { + return m.Has(tag.PutOrCall) +} + +//HasStrikePrice returns true if StrikePrice is present, Tag 202 +func (m OrderCancelRequest) HasStrikePrice() bool { + return m.Has(tag.StrikePrice) +} + +//HasMaturityDay returns true if MaturityDay is present, Tag 205 +func (m OrderCancelRequest) HasMaturityDay() bool { + return m.Has(tag.MaturityDay) +} + +//HasOptAttribute returns true if OptAttribute is present, Tag 206 +func (m OrderCancelRequest) HasOptAttribute() bool { + return m.Has(tag.OptAttribute) +} + +//HasSecurityExchange returns true if SecurityExchange is present, Tag 207 +func (m OrderCancelRequest) HasSecurityExchange() bool { + return m.Has(tag.SecurityExchange) +} + +//HasCouponRate returns true if CouponRate is present, Tag 223 +func (m OrderCancelRequest) HasCouponRate() bool { + return m.Has(tag.CouponRate) +} + +//HasContractMultiplier returns true if ContractMultiplier is present, Tag 231 +func (m OrderCancelRequest) HasContractMultiplier() bool { + return m.Has(tag.ContractMultiplier) +} + +//HasEncodedIssuerLen returns true if EncodedIssuerLen is present, Tag 348 +func (m OrderCancelRequest) HasEncodedIssuerLen() bool { + return m.Has(tag.EncodedIssuerLen) +} + +//HasEncodedIssuer returns true if EncodedIssuer is present, Tag 349 +func (m OrderCancelRequest) HasEncodedIssuer() bool { + return m.Has(tag.EncodedIssuer) +} + +//HasEncodedSecurityDescLen returns true if EncodedSecurityDescLen is present, Tag 350 +func (m OrderCancelRequest) HasEncodedSecurityDescLen() bool { + return m.Has(tag.EncodedSecurityDescLen) +} + +//HasEncodedSecurityDesc returns true if EncodedSecurityDesc is present, Tag 351 +func (m OrderCancelRequest) HasEncodedSecurityDesc() bool { + return m.Has(tag.EncodedSecurityDesc) +} + +//HasEncodedTextLen returns true if EncodedTextLen is present, Tag 354 +func (m OrderCancelRequest) HasEncodedTextLen() bool { + return m.Has(tag.EncodedTextLen) +} + +//HasEncodedText returns true if EncodedText is present, Tag 355 +func (m OrderCancelRequest) HasEncodedText() bool { + return m.Has(tag.EncodedText) +} + +//HasComplianceID returns true if ComplianceID is present, Tag 376 +func (m OrderCancelRequest) HasComplianceID() bool { + return m.Has(tag.ComplianceID) +} + +//HasSolicitedFlag returns true if SolicitedFlag is present, Tag 377 +func (m OrderCancelRequest) HasSolicitedFlag() bool { + return m.Has(tag.SolicitedFlag) +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix42/trailer.generated.go b/vendor/github.com/quickfixgo/quickfix/fix42/trailer.generated.go new file mode 100644 index 0000000..2519e8c --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix42/trailer.generated.go @@ -0,0 +1,60 @@ +package fix42 + +import ( + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/tag" +) + +//Trailer is the fix42 Trailer type +type Trailer struct { + quickfix.Trailer +} + +//SetCheckSum sets CheckSum, Tag 10 +func (t Trailer) SetCheckSum(v string) { + t.Set(field.NewCheckSum(v)) +} + +//SetSignature sets Signature, Tag 89 +func (t Trailer) SetSignature(v string) { + t.Set(field.NewSignature(v)) +} + +//SetSignatureLength sets SignatureLength, Tag 93 +func (t Trailer) SetSignatureLength(v int) { + t.Set(field.NewSignatureLength(v)) +} + +//GetCheckSum gets CheckSum, Tag 10 +func (t Trailer) GetCheckSum() (f field.CheckSumField, err quickfix.MessageRejectError) { + err = t.Get(&f) + return +} + +//GetSignature gets Signature, Tag 89 +func (t Trailer) GetSignature() (f field.SignatureField, err quickfix.MessageRejectError) { + err = t.Get(&f) + return +} + +//GetSignatureLength gets SignatureLength, Tag 93 +func (t Trailer) GetSignatureLength() (f field.SignatureLengthField, err quickfix.MessageRejectError) { + err = t.Get(&f) + return +} + +//HasCheckSum returns true if CheckSum is present, Tag 10 +func (t Trailer) HasCheckSum() bool { + return t.Has(tag.CheckSum) +} + +//HasSignature returns true if Signature is present, Tag 89 +func (t Trailer) HasSignature() bool { + return t.Has(tag.Signature) +} + +//HasSignatureLength returns true if SignatureLength is present, Tag 93 +func (t Trailer) HasSignatureLength() bool { + return t.Has(tag.SignatureLength) +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix43/executionreport/ExecutionReport.generated.go b/vendor/github.com/quickfixgo/quickfix/fix43/executionreport/ExecutionReport.generated.go new file mode 100644 index 0000000..168345f --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix43/executionreport/ExecutionReport.generated.go @@ -0,0 +1,3885 @@ +package executionreport + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fix43" + "github.com/quickfixgo/quickfix/tag" +) + +//ExecutionReport is the fix43 ExecutionReport type, MsgType = 8 +type ExecutionReport struct { + fix43.Header + quickfix.Body + fix43.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a ExecutionReport from a quickfix.Message instance +func FromMessage(m quickfix.Message) ExecutionReport { + return ExecutionReport{ + Header: fix43.Header{Header: m.Header}, + Body: m.Body, + Trailer: fix43.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m ExecutionReport) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a ExecutionReport initialized with the required fields for ExecutionReport +func New(orderid field.OrderIDField, execid field.ExecIDField, exectype field.ExecTypeField, ordstatus field.OrdStatusField, side field.SideField, leavesqty field.LeavesQtyField, cumqty field.CumQtyField, avgpx field.AvgPxField) (m ExecutionReport) { + m.Header = fix43.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("8")) + m.Set(orderid) + m.Set(execid) + m.Set(exectype) + m.Set(ordstatus) + m.Set(side) + m.Set(leavesqty) + m.Set(cumqty) + m.Set(avgpx) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg ExecutionReport, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "FIX.4.3", "8", r +} + +//SetAccount sets Account, Tag 1 +func (m ExecutionReport) SetAccount(v string) { + m.Set(field.NewAccount(v)) +} + +//SetAvgPx sets AvgPx, Tag 6 +func (m ExecutionReport) SetAvgPx(v float64) { + m.Set(field.NewAvgPx(v)) +} + +//SetClOrdID sets ClOrdID, Tag 11 +func (m ExecutionReport) SetClOrdID(v string) { + m.Set(field.NewClOrdID(v)) +} + +//SetCommission sets Commission, Tag 12 +func (m ExecutionReport) SetCommission(v float64) { + m.Set(field.NewCommission(v)) +} + +//SetCommType sets CommType, Tag 13 +func (m ExecutionReport) SetCommType(v string) { + m.Set(field.NewCommType(v)) +} + +//SetCumQty sets CumQty, Tag 14 +func (m ExecutionReport) SetCumQty(v float64) { + m.Set(field.NewCumQty(v)) +} + +//SetCurrency sets Currency, Tag 15 +func (m ExecutionReport) SetCurrency(v string) { + m.Set(field.NewCurrency(v)) +} + +//SetExecID sets ExecID, Tag 17 +func (m ExecutionReport) SetExecID(v string) { + m.Set(field.NewExecID(v)) +} + +//SetExecInst sets ExecInst, Tag 18 +func (m ExecutionReport) SetExecInst(v string) { + m.Set(field.NewExecInst(v)) +} + +//SetExecRefID sets ExecRefID, Tag 19 +func (m ExecutionReport) SetExecRefID(v string) { + m.Set(field.NewExecRefID(v)) +} + +//SetHandlInst sets HandlInst, Tag 21 +func (m ExecutionReport) SetHandlInst(v string) { + m.Set(field.NewHandlInst(v)) +} + +//SetSecurityIDSource sets SecurityIDSource, Tag 22 +func (m ExecutionReport) SetSecurityIDSource(v string) { + m.Set(field.NewSecurityIDSource(v)) +} + +//SetLastCapacity sets LastCapacity, Tag 29 +func (m ExecutionReport) SetLastCapacity(v string) { + m.Set(field.NewLastCapacity(v)) +} + +//SetLastMkt sets LastMkt, Tag 30 +func (m ExecutionReport) SetLastMkt(v string) { + m.Set(field.NewLastMkt(v)) +} + +//SetLastPx sets LastPx, Tag 31 +func (m ExecutionReport) SetLastPx(v float64) { + m.Set(field.NewLastPx(v)) +} + +//SetLastQty sets LastQty, Tag 32 +func (m ExecutionReport) SetLastQty(v float64) { + m.Set(field.NewLastQty(v)) +} + +//SetOrderID sets OrderID, Tag 37 +func (m ExecutionReport) SetOrderID(v string) { + m.Set(field.NewOrderID(v)) +} + +//SetOrderQty sets OrderQty, Tag 38 +func (m ExecutionReport) SetOrderQty(v float64) { + m.Set(field.NewOrderQty(v)) +} + +//SetOrdStatus sets OrdStatus, Tag 39 +func (m ExecutionReport) SetOrdStatus(v string) { + m.Set(field.NewOrdStatus(v)) +} + +//SetOrdType sets OrdType, Tag 40 +func (m ExecutionReport) SetOrdType(v string) { + m.Set(field.NewOrdType(v)) +} + +//SetOrigClOrdID sets OrigClOrdID, Tag 41 +func (m ExecutionReport) SetOrigClOrdID(v string) { + m.Set(field.NewOrigClOrdID(v)) +} + +//SetPrice sets Price, Tag 44 +func (m ExecutionReport) SetPrice(v float64) { + m.Set(field.NewPrice(v)) +} + +//SetRule80A sets Rule80A, Tag 47 +func (m ExecutionReport) SetRule80A(v string) { + m.Set(field.NewRule80A(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m ExecutionReport) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSide sets Side, Tag 54 +func (m ExecutionReport) SetSide(v string) { + m.Set(field.NewSide(v)) +} + +//SetSymbol sets Symbol, Tag 55 +func (m ExecutionReport) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetText sets Text, Tag 58 +func (m ExecutionReport) SetText(v string) { + m.Set(field.NewText(v)) +} + +//SetTimeInForce sets TimeInForce, Tag 59 +func (m ExecutionReport) SetTimeInForce(v string) { + m.Set(field.NewTimeInForce(v)) +} + +//SetTransactTime sets TransactTime, Tag 60 +func (m ExecutionReport) SetTransactTime(v time.Time) { + m.Set(field.NewTransactTime(v)) +} + +//SetSettlmntTyp sets SettlmntTyp, Tag 63 +func (m ExecutionReport) SetSettlmntTyp(v string) { + m.Set(field.NewSettlmntTyp(v)) +} + +//SetFutSettDate sets FutSettDate, Tag 64 +func (m ExecutionReport) SetFutSettDate(v string) { + m.Set(field.NewFutSettDate(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m ExecutionReport) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetListID sets ListID, Tag 66 +func (m ExecutionReport) SetListID(v string) { + m.Set(field.NewListID(v)) +} + +//SetTradeDate sets TradeDate, Tag 75 +func (m ExecutionReport) SetTradeDate(v string) { + m.Set(field.NewTradeDate(v)) +} + +//SetPositionEffect sets PositionEffect, Tag 77 +func (m ExecutionReport) SetPositionEffect(v string) { + m.Set(field.NewPositionEffect(v)) +} + +//SetStopPx sets StopPx, Tag 99 +func (m ExecutionReport) SetStopPx(v float64) { + m.Set(field.NewStopPx(v)) +} + +//SetOrdRejReason sets OrdRejReason, Tag 103 +func (m ExecutionReport) SetOrdRejReason(v int) { + m.Set(field.NewOrdRejReason(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m ExecutionReport) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m ExecutionReport) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetMinQty sets MinQty, Tag 110 +func (m ExecutionReport) SetMinQty(v float64) { + m.Set(field.NewMinQty(v)) +} + +//SetMaxFloor sets MaxFloor, Tag 111 +func (m ExecutionReport) SetMaxFloor(v float64) { + m.Set(field.NewMaxFloor(v)) +} + +//SetReportToExch sets ReportToExch, Tag 113 +func (m ExecutionReport) SetReportToExch(v bool) { + m.Set(field.NewReportToExch(v)) +} + +//SetNetMoney sets NetMoney, Tag 118 +func (m ExecutionReport) SetNetMoney(v float64) { + m.Set(field.NewNetMoney(v)) +} + +//SetSettlCurrAmt sets SettlCurrAmt, Tag 119 +func (m ExecutionReport) SetSettlCurrAmt(v float64) { + m.Set(field.NewSettlCurrAmt(v)) +} + +//SetSettlCurrency sets SettlCurrency, Tag 120 +func (m ExecutionReport) SetSettlCurrency(v string) { + m.Set(field.NewSettlCurrency(v)) +} + +//SetExpireTime sets ExpireTime, Tag 126 +func (m ExecutionReport) SetExpireTime(v time.Time) { + m.Set(field.NewExpireTime(v)) +} + +//SetExecType sets ExecType, Tag 150 +func (m ExecutionReport) SetExecType(v string) { + m.Set(field.NewExecType(v)) +} + +//SetLeavesQty sets LeavesQty, Tag 151 +func (m ExecutionReport) SetLeavesQty(v float64) { + m.Set(field.NewLeavesQty(v)) +} + +//SetCashOrderQty sets CashOrderQty, Tag 152 +func (m ExecutionReport) SetCashOrderQty(v float64) { + m.Set(field.NewCashOrderQty(v)) +} + +//SetSettlCurrFxRate sets SettlCurrFxRate, Tag 155 +func (m ExecutionReport) SetSettlCurrFxRate(v float64) { + m.Set(field.NewSettlCurrFxRate(v)) +} + +//SetSettlCurrFxRateCalc sets SettlCurrFxRateCalc, Tag 156 +func (m ExecutionReport) SetSettlCurrFxRateCalc(v string) { + m.Set(field.NewSettlCurrFxRateCalc(v)) +} + +//SetNumDaysInterest sets NumDaysInterest, Tag 157 +func (m ExecutionReport) SetNumDaysInterest(v int) { + m.Set(field.NewNumDaysInterest(v)) +} + +//SetAccruedInterestRate sets AccruedInterestRate, Tag 158 +func (m ExecutionReport) SetAccruedInterestRate(v float64) { + m.Set(field.NewAccruedInterestRate(v)) +} + +//SetAccruedInterestAmt sets AccruedInterestAmt, Tag 159 +func (m ExecutionReport) SetAccruedInterestAmt(v float64) { + m.Set(field.NewAccruedInterestAmt(v)) +} + +//SetSecurityType sets SecurityType, Tag 167 +func (m ExecutionReport) SetSecurityType(v string) { + m.Set(field.NewSecurityType(v)) +} + +//SetEffectiveTime sets EffectiveTime, Tag 168 +func (m ExecutionReport) SetEffectiveTime(v time.Time) { + m.Set(field.NewEffectiveTime(v)) +} + +//SetOrderQty2 sets OrderQty2, Tag 192 +func (m ExecutionReport) SetOrderQty2(v float64) { + m.Set(field.NewOrderQty2(v)) +} + +//SetFutSettDate2 sets FutSettDate2, Tag 193 +func (m ExecutionReport) SetFutSettDate2(v string) { + m.Set(field.NewFutSettDate2(v)) +} + +//SetLastSpotRate sets LastSpotRate, Tag 194 +func (m ExecutionReport) SetLastSpotRate(v float64) { + m.Set(field.NewLastSpotRate(v)) +} + +//SetLastForwardPoints sets LastForwardPoints, Tag 195 +func (m ExecutionReport) SetLastForwardPoints(v float64) { + m.Set(field.NewLastForwardPoints(v)) +} + +//SetSecondaryOrderID sets SecondaryOrderID, Tag 198 +func (m ExecutionReport) SetSecondaryOrderID(v string) { + m.Set(field.NewSecondaryOrderID(v)) +} + +//SetMaturityMonthYear sets MaturityMonthYear, Tag 200 +func (m ExecutionReport) SetMaturityMonthYear(v string) { + m.Set(field.NewMaturityMonthYear(v)) +} + +//SetStrikePrice sets StrikePrice, Tag 202 +func (m ExecutionReport) SetStrikePrice(v float64) { + m.Set(field.NewStrikePrice(v)) +} + +//SetOptAttribute sets OptAttribute, Tag 206 +func (m ExecutionReport) SetOptAttribute(v string) { + m.Set(field.NewOptAttribute(v)) +} + +//SetSecurityExchange sets SecurityExchange, Tag 207 +func (m ExecutionReport) SetSecurityExchange(v string) { + m.Set(field.NewSecurityExchange(v)) +} + +//SetMaxShow sets MaxShow, Tag 210 +func (m ExecutionReport) SetMaxShow(v float64) { + m.Set(field.NewMaxShow(v)) +} + +//SetPegDifference sets PegDifference, Tag 211 +func (m ExecutionReport) SetPegDifference(v float64) { + m.Set(field.NewPegDifference(v)) +} + +//SetSpread sets Spread, Tag 218 +func (m ExecutionReport) SetSpread(v float64) { + m.Set(field.NewSpread(v)) +} + +//SetBenchmarkCurveCurrency sets BenchmarkCurveCurrency, Tag 220 +func (m ExecutionReport) SetBenchmarkCurveCurrency(v string) { + m.Set(field.NewBenchmarkCurveCurrency(v)) +} + +//SetBenchmarkCurveName sets BenchmarkCurveName, Tag 221 +func (m ExecutionReport) SetBenchmarkCurveName(v string) { + m.Set(field.NewBenchmarkCurveName(v)) +} + +//SetBenchmarkCurvePoint sets BenchmarkCurvePoint, Tag 222 +func (m ExecutionReport) SetBenchmarkCurvePoint(v string) { + m.Set(field.NewBenchmarkCurvePoint(v)) +} + +//SetCouponRate sets CouponRate, Tag 223 +func (m ExecutionReport) SetCouponRate(v float64) { + m.Set(field.NewCouponRate(v)) +} + +//SetCouponPaymentDate sets CouponPaymentDate, Tag 224 +func (m ExecutionReport) SetCouponPaymentDate(v string) { + m.Set(field.NewCouponPaymentDate(v)) +} + +//SetIssueDate sets IssueDate, Tag 225 +func (m ExecutionReport) SetIssueDate(v string) { + m.Set(field.NewIssueDate(v)) +} + +//SetRepurchaseTerm sets RepurchaseTerm, Tag 226 +func (m ExecutionReport) SetRepurchaseTerm(v int) { + m.Set(field.NewRepurchaseTerm(v)) +} + +//SetRepurchaseRate sets RepurchaseRate, Tag 227 +func (m ExecutionReport) SetRepurchaseRate(v float64) { + m.Set(field.NewRepurchaseRate(v)) +} + +//SetFactor sets Factor, Tag 228 +func (m ExecutionReport) SetFactor(v float64) { + m.Set(field.NewFactor(v)) +} + +//SetTradeOriginationDate sets TradeOriginationDate, Tag 229 +func (m ExecutionReport) SetTradeOriginationDate(v string) { + m.Set(field.NewTradeOriginationDate(v)) +} + +//SetExDate sets ExDate, Tag 230 +func (m ExecutionReport) SetExDate(v string) { + m.Set(field.NewExDate(v)) +} + +//SetContractMultiplier sets ContractMultiplier, Tag 231 +func (m ExecutionReport) SetContractMultiplier(v float64) { + m.Set(field.NewContractMultiplier(v)) +} + +//SetNoStipulations sets NoStipulations, Tag 232 +func (m ExecutionReport) SetNoStipulations(f NoStipulationsRepeatingGroup) { + m.SetGroup(f) +} + +//SetYieldType sets YieldType, Tag 235 +func (m ExecutionReport) SetYieldType(v string) { + m.Set(field.NewYieldType(v)) +} + +//SetYield sets Yield, Tag 236 +func (m ExecutionReport) SetYield(v float64) { + m.Set(field.NewYield(v)) +} + +//SetTotalTakedown sets TotalTakedown, Tag 237 +func (m ExecutionReport) SetTotalTakedown(v float64) { + m.Set(field.NewTotalTakedown(v)) +} + +//SetConcession sets Concession, Tag 238 +func (m ExecutionReport) SetConcession(v float64) { + m.Set(field.NewConcession(v)) +} + +//SetRepoCollateralSecurityType sets RepoCollateralSecurityType, Tag 239 +func (m ExecutionReport) SetRepoCollateralSecurityType(v int) { + m.Set(field.NewRepoCollateralSecurityType(v)) +} + +//SetRedemptionDate sets RedemptionDate, Tag 240 +func (m ExecutionReport) SetRedemptionDate(v string) { + m.Set(field.NewRedemptionDate(v)) +} + +//SetCreditRating sets CreditRating, Tag 255 +func (m ExecutionReport) SetCreditRating(v string) { + m.Set(field.NewCreditRating(v)) +} + +//SetTradedFlatSwitch sets TradedFlatSwitch, Tag 258 +func (m ExecutionReport) SetTradedFlatSwitch(v bool) { + m.Set(field.NewTradedFlatSwitch(v)) +} + +//SetBasisFeatureDate sets BasisFeatureDate, Tag 259 +func (m ExecutionReport) SetBasisFeatureDate(v string) { + m.Set(field.NewBasisFeatureDate(v)) +} + +//SetBasisFeaturePrice sets BasisFeaturePrice, Tag 260 +func (m ExecutionReport) SetBasisFeaturePrice(v float64) { + m.Set(field.NewBasisFeaturePrice(v)) +} + +//SetTradingSessionID sets TradingSessionID, Tag 336 +func (m ExecutionReport) SetTradingSessionID(v string) { + m.Set(field.NewTradingSessionID(v)) +} + +//SetEncodedIssuerLen sets EncodedIssuerLen, Tag 348 +func (m ExecutionReport) SetEncodedIssuerLen(v int) { + m.Set(field.NewEncodedIssuerLen(v)) +} + +//SetEncodedIssuer sets EncodedIssuer, Tag 349 +func (m ExecutionReport) SetEncodedIssuer(v string) { + m.Set(field.NewEncodedIssuer(v)) +} + +//SetEncodedSecurityDescLen sets EncodedSecurityDescLen, Tag 350 +func (m ExecutionReport) SetEncodedSecurityDescLen(v int) { + m.Set(field.NewEncodedSecurityDescLen(v)) +} + +//SetEncodedSecurityDesc sets EncodedSecurityDesc, Tag 351 +func (m ExecutionReport) SetEncodedSecurityDesc(v string) { + m.Set(field.NewEncodedSecurityDesc(v)) +} + +//SetEncodedTextLen sets EncodedTextLen, Tag 354 +func (m ExecutionReport) SetEncodedTextLen(v int) { + m.Set(field.NewEncodedTextLen(v)) +} + +//SetEncodedText sets EncodedText, Tag 355 +func (m ExecutionReport) SetEncodedText(v string) { + m.Set(field.NewEncodedText(v)) +} + +//SetComplianceID sets ComplianceID, Tag 376 +func (m ExecutionReport) SetComplianceID(v string) { + m.Set(field.NewComplianceID(v)) +} + +//SetSolicitedFlag sets SolicitedFlag, Tag 377 +func (m ExecutionReport) SetSolicitedFlag(v bool) { + m.Set(field.NewSolicitedFlag(v)) +} + +//SetExecRestatementReason sets ExecRestatementReason, Tag 378 +func (m ExecutionReport) SetExecRestatementReason(v int) { + m.Set(field.NewExecRestatementReason(v)) +} + +//SetGrossTradeAmt sets GrossTradeAmt, Tag 381 +func (m ExecutionReport) SetGrossTradeAmt(v float64) { + m.Set(field.NewGrossTradeAmt(v)) +} + +//SetNoContraBrokers sets NoContraBrokers, Tag 382 +func (m ExecutionReport) SetNoContraBrokers(f NoContraBrokersRepeatingGroup) { + m.SetGroup(f) +} + +//SetDiscretionInst sets DiscretionInst, Tag 388 +func (m ExecutionReport) SetDiscretionInst(v string) { + m.Set(field.NewDiscretionInst(v)) +} + +//SetDiscretionOffset sets DiscretionOffset, Tag 389 +func (m ExecutionReport) SetDiscretionOffset(v float64) { + m.Set(field.NewDiscretionOffset(v)) +} + +//SetPriceType sets PriceType, Tag 423 +func (m ExecutionReport) SetPriceType(v int) { + m.Set(field.NewPriceType(v)) +} + +//SetDayOrderQty sets DayOrderQty, Tag 424 +func (m ExecutionReport) SetDayOrderQty(v float64) { + m.Set(field.NewDayOrderQty(v)) +} + +//SetDayCumQty sets DayCumQty, Tag 425 +func (m ExecutionReport) SetDayCumQty(v float64) { + m.Set(field.NewDayCumQty(v)) +} + +//SetDayAvgPx sets DayAvgPx, Tag 426 +func (m ExecutionReport) SetDayAvgPx(v float64) { + m.Set(field.NewDayAvgPx(v)) +} + +//SetGTBookingInst sets GTBookingInst, Tag 427 +func (m ExecutionReport) SetGTBookingInst(v int) { + m.Set(field.NewGTBookingInst(v)) +} + +//SetExpireDate sets ExpireDate, Tag 432 +func (m ExecutionReport) SetExpireDate(v string) { + m.Set(field.NewExpireDate(v)) +} + +//SetMultiLegReportingType sets MultiLegReportingType, Tag 442 +func (m ExecutionReport) SetMultiLegReportingType(v string) { + m.Set(field.NewMultiLegReportingType(v)) +} + +//SetNoPartyIDs sets NoPartyIDs, Tag 453 +func (m ExecutionReport) SetNoPartyIDs(f NoPartyIDsRepeatingGroup) { + m.SetGroup(f) +} + +//SetNoSecurityAltID sets NoSecurityAltID, Tag 454 +func (m ExecutionReport) SetNoSecurityAltID(f NoSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetProduct sets Product, Tag 460 +func (m ExecutionReport) SetProduct(v int) { + m.Set(field.NewProduct(v)) +} + +//SetCFICode sets CFICode, Tag 461 +func (m ExecutionReport) SetCFICode(v string) { + m.Set(field.NewCFICode(v)) +} + +//SetQuantityType sets QuantityType, Tag 465 +func (m ExecutionReport) SetQuantityType(v int) { + m.Set(field.NewQuantityType(v)) +} + +//SetRoundingDirection sets RoundingDirection, Tag 468 +func (m ExecutionReport) SetRoundingDirection(v string) { + m.Set(field.NewRoundingDirection(v)) +} + +//SetRoundingModulus sets RoundingModulus, Tag 469 +func (m ExecutionReport) SetRoundingModulus(v float64) { + m.Set(field.NewRoundingModulus(v)) +} + +//SetCountryOfIssue sets CountryOfIssue, Tag 470 +func (m ExecutionReport) SetCountryOfIssue(v string) { + m.Set(field.NewCountryOfIssue(v)) +} + +//SetStateOrProvinceOfIssue sets StateOrProvinceOfIssue, Tag 471 +func (m ExecutionReport) SetStateOrProvinceOfIssue(v string) { + m.Set(field.NewStateOrProvinceOfIssue(v)) +} + +//SetLocaleOfIssue sets LocaleOfIssue, Tag 472 +func (m ExecutionReport) SetLocaleOfIssue(v string) { + m.Set(field.NewLocaleOfIssue(v)) +} + +//SetCommCurrency sets CommCurrency, Tag 479 +func (m ExecutionReport) SetCommCurrency(v string) { + m.Set(field.NewCommCurrency(v)) +} + +//SetCancellationRights sets CancellationRights, Tag 480 +func (m ExecutionReport) SetCancellationRights(v string) { + m.Set(field.NewCancellationRights(v)) +} + +//SetMoneyLaunderingStatus sets MoneyLaunderingStatus, Tag 481 +func (m ExecutionReport) SetMoneyLaunderingStatus(v string) { + m.Set(field.NewMoneyLaunderingStatus(v)) +} + +//SetTransBkdTime sets TransBkdTime, Tag 483 +func (m ExecutionReport) SetTransBkdTime(v time.Time) { + m.Set(field.NewTransBkdTime(v)) +} + +//SetExecPriceType sets ExecPriceType, Tag 484 +func (m ExecutionReport) SetExecPriceType(v string) { + m.Set(field.NewExecPriceType(v)) +} + +//SetExecPriceAdjustment sets ExecPriceAdjustment, Tag 485 +func (m ExecutionReport) SetExecPriceAdjustment(v float64) { + m.Set(field.NewExecPriceAdjustment(v)) +} + +//SetDesignation sets Designation, Tag 494 +func (m ExecutionReport) SetDesignation(v string) { + m.Set(field.NewDesignation(v)) +} + +//SetFundRenewWaiv sets FundRenewWaiv, Tag 497 +func (m ExecutionReport) SetFundRenewWaiv(v string) { + m.Set(field.NewFundRenewWaiv(v)) +} + +//SetRegistID sets RegistID, Tag 513 +func (m ExecutionReport) SetRegistID(v string) { + m.Set(field.NewRegistID(v)) +} + +//SetExecValuationPoint sets ExecValuationPoint, Tag 515 +func (m ExecutionReport) SetExecValuationPoint(v time.Time) { + m.Set(field.NewExecValuationPoint(v)) +} + +//SetOrderPercent sets OrderPercent, Tag 516 +func (m ExecutionReport) SetOrderPercent(v float64) { + m.Set(field.NewOrderPercent(v)) +} + +//SetNoContAmts sets NoContAmts, Tag 518 +func (m ExecutionReport) SetNoContAmts(f NoContAmtsRepeatingGroup) { + m.SetGroup(f) +} + +//SetSecondaryClOrdID sets SecondaryClOrdID, Tag 526 +func (m ExecutionReport) SetSecondaryClOrdID(v string) { + m.Set(field.NewSecondaryClOrdID(v)) +} + +//SetSecondaryExecID sets SecondaryExecID, Tag 527 +func (m ExecutionReport) SetSecondaryExecID(v string) { + m.Set(field.NewSecondaryExecID(v)) +} + +//SetOrderCapacity sets OrderCapacity, Tag 528 +func (m ExecutionReport) SetOrderCapacity(v string) { + m.Set(field.NewOrderCapacity(v)) +} + +//SetOrderRestrictions sets OrderRestrictions, Tag 529 +func (m ExecutionReport) SetOrderRestrictions(v string) { + m.Set(field.NewOrderRestrictions(v)) +} + +//SetMaturityDate sets MaturityDate, Tag 541 +func (m ExecutionReport) SetMaturityDate(v string) { + m.Set(field.NewMaturityDate(v)) +} + +//SetInstrRegistry sets InstrRegistry, Tag 543 +func (m ExecutionReport) SetInstrRegistry(v string) { + m.Set(field.NewInstrRegistry(v)) +} + +//SetCashMargin sets CashMargin, Tag 544 +func (m ExecutionReport) SetCashMargin(v string) { + m.Set(field.NewCashMargin(v)) +} + +//SetCrossID sets CrossID, Tag 548 +func (m ExecutionReport) SetCrossID(v string) { + m.Set(field.NewCrossID(v)) +} + +//SetCrossType sets CrossType, Tag 549 +func (m ExecutionReport) SetCrossType(v int) { + m.Set(field.NewCrossType(v)) +} + +//SetOrigCrossID sets OrigCrossID, Tag 551 +func (m ExecutionReport) SetOrigCrossID(v string) { + m.Set(field.NewOrigCrossID(v)) +} + +//SetNoLegs sets NoLegs, Tag 555 +func (m ExecutionReport) SetNoLegs(f NoLegsRepeatingGroup) { + m.SetGroup(f) +} + +//SetAccountType sets AccountType, Tag 581 +func (m ExecutionReport) SetAccountType(v int) { + m.Set(field.NewAccountType(v)) +} + +//SetCustOrderCapacity sets CustOrderCapacity, Tag 582 +func (m ExecutionReport) SetCustOrderCapacity(v int) { + m.Set(field.NewCustOrderCapacity(v)) +} + +//SetClOrdLinkID sets ClOrdLinkID, Tag 583 +func (m ExecutionReport) SetClOrdLinkID(v string) { + m.Set(field.NewClOrdLinkID(v)) +} + +//SetDayBookingInst sets DayBookingInst, Tag 589 +func (m ExecutionReport) SetDayBookingInst(v string) { + m.Set(field.NewDayBookingInst(v)) +} + +//SetBookingUnit sets BookingUnit, Tag 590 +func (m ExecutionReport) SetBookingUnit(v string) { + m.Set(field.NewBookingUnit(v)) +} + +//SetPreallocMethod sets PreallocMethod, Tag 591 +func (m ExecutionReport) SetPreallocMethod(v string) { + m.Set(field.NewPreallocMethod(v)) +} + +//SetTradingSessionSubID sets TradingSessionSubID, Tag 625 +func (m ExecutionReport) SetTradingSessionSubID(v string) { + m.Set(field.NewTradingSessionSubID(v)) +} + +//SetClearingFeeIndicator sets ClearingFeeIndicator, Tag 635 +func (m ExecutionReport) SetClearingFeeIndicator(v string) { + m.Set(field.NewClearingFeeIndicator(v)) +} + +//SetWorkingIndicator sets WorkingIndicator, Tag 636 +func (m ExecutionReport) SetWorkingIndicator(v bool) { + m.Set(field.NewWorkingIndicator(v)) +} + +//SetPriorityIndicator sets PriorityIndicator, Tag 638 +func (m ExecutionReport) SetPriorityIndicator(v int) { + m.Set(field.NewPriorityIndicator(v)) +} + +//SetPriceImprovement sets PriceImprovement, Tag 639 +func (m ExecutionReport) SetPriceImprovement(v float64) { + m.Set(field.NewPriceImprovement(v)) +} + +//SetLastForwardPoints2 sets LastForwardPoints2, Tag 641 +func (m ExecutionReport) SetLastForwardPoints2(v float64) { + m.Set(field.NewLastForwardPoints2(v)) +} + +//SetUnderlyingLastPx sets UnderlyingLastPx, Tag 651 +func (m ExecutionReport) SetUnderlyingLastPx(v float64) { + m.Set(field.NewUnderlyingLastPx(v)) +} + +//SetUnderlyingLastQty sets UnderlyingLastQty, Tag 652 +func (m ExecutionReport) SetUnderlyingLastQty(v float64) { + m.Set(field.NewUnderlyingLastQty(v)) +} + +//GetAccount gets Account, Tag 1 +func (m ExecutionReport) GetAccount() (f field.AccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAvgPx gets AvgPx, Tag 6 +func (m ExecutionReport) GetAvgPx() (f field.AvgPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdID gets ClOrdID, Tag 11 +func (m ExecutionReport) GetClOrdID() (f field.ClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommission gets Commission, Tag 12 +func (m ExecutionReport) GetCommission() (f field.CommissionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommType gets CommType, Tag 13 +func (m ExecutionReport) GetCommType() (f field.CommTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCumQty gets CumQty, Tag 14 +func (m ExecutionReport) GetCumQty() (f field.CumQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCurrency gets Currency, Tag 15 +func (m ExecutionReport) GetCurrency() (f field.CurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecID gets ExecID, Tag 17 +func (m ExecutionReport) GetExecID() (f field.ExecIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecInst gets ExecInst, Tag 18 +func (m ExecutionReport) GetExecInst() (f field.ExecInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecRefID gets ExecRefID, Tag 19 +func (m ExecutionReport) GetExecRefID() (f field.ExecRefIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetHandlInst gets HandlInst, Tag 21 +func (m ExecutionReport) GetHandlInst() (f field.HandlInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityIDSource gets SecurityIDSource, Tag 22 +func (m ExecutionReport) GetSecurityIDSource() (f field.SecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastCapacity gets LastCapacity, Tag 29 +func (m ExecutionReport) GetLastCapacity() (f field.LastCapacityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastMkt gets LastMkt, Tag 30 +func (m ExecutionReport) GetLastMkt() (f field.LastMktField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastPx gets LastPx, Tag 31 +func (m ExecutionReport) GetLastPx() (f field.LastPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastQty gets LastQty, Tag 32 +func (m ExecutionReport) GetLastQty() (f field.LastQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderID gets OrderID, Tag 37 +func (m ExecutionReport) GetOrderID() (f field.OrderIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty gets OrderQty, Tag 38 +func (m ExecutionReport) GetOrderQty() (f field.OrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdStatus gets OrdStatus, Tag 39 +func (m ExecutionReport) GetOrdStatus() (f field.OrdStatusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdType gets OrdType, Tag 40 +func (m ExecutionReport) GetOrdType() (f field.OrdTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrigClOrdID gets OrigClOrdID, Tag 41 +func (m ExecutionReport) GetOrigClOrdID() (f field.OrigClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrice gets Price, Tag 44 +func (m ExecutionReport) GetPrice() (f field.PriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRule80A gets Rule80A, Tag 47 +func (m ExecutionReport) GetRule80A() (f field.Rule80AField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m ExecutionReport) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSide gets Side, Tag 54 +func (m ExecutionReport) GetSide() (f field.SideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbol gets Symbol, Tag 55 +func (m ExecutionReport) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetText gets Text, Tag 58 +func (m ExecutionReport) GetText() (f field.TextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTimeInForce gets TimeInForce, Tag 59 +func (m ExecutionReport) GetTimeInForce() (f field.TimeInForceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTransactTime gets TransactTime, Tag 60 +func (m ExecutionReport) GetTransactTime() (f field.TransactTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlmntTyp gets SettlmntTyp, Tag 63 +func (m ExecutionReport) GetSettlmntTyp() (f field.SettlmntTypField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFutSettDate gets FutSettDate, Tag 64 +func (m ExecutionReport) GetFutSettDate() (f field.FutSettDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m ExecutionReport) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetListID gets ListID, Tag 66 +func (m ExecutionReport) GetListID() (f field.ListIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradeDate gets TradeDate, Tag 75 +func (m ExecutionReport) GetTradeDate() (f field.TradeDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPositionEffect gets PositionEffect, Tag 77 +func (m ExecutionReport) GetPositionEffect() (f field.PositionEffectField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStopPx gets StopPx, Tag 99 +func (m ExecutionReport) GetStopPx() (f field.StopPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdRejReason gets OrdRejReason, Tag 103 +func (m ExecutionReport) GetOrdRejReason() (f field.OrdRejReasonField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m ExecutionReport) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m ExecutionReport) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMinQty gets MinQty, Tag 110 +func (m ExecutionReport) GetMinQty() (f field.MinQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxFloor gets MaxFloor, Tag 111 +func (m ExecutionReport) GetMaxFloor() (f field.MaxFloorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetReportToExch gets ReportToExch, Tag 113 +func (m ExecutionReport) GetReportToExch() (f field.ReportToExchField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNetMoney gets NetMoney, Tag 118 +func (m ExecutionReport) GetNetMoney() (f field.NetMoneyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrAmt gets SettlCurrAmt, Tag 119 +func (m ExecutionReport) GetSettlCurrAmt() (f field.SettlCurrAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrency gets SettlCurrency, Tag 120 +func (m ExecutionReport) GetSettlCurrency() (f field.SettlCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireTime gets ExpireTime, Tag 126 +func (m ExecutionReport) GetExpireTime() (f field.ExpireTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecType gets ExecType, Tag 150 +func (m ExecutionReport) GetExecType() (f field.ExecTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLeavesQty gets LeavesQty, Tag 151 +func (m ExecutionReport) GetLeavesQty() (f field.LeavesQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashOrderQty gets CashOrderQty, Tag 152 +func (m ExecutionReport) GetCashOrderQty() (f field.CashOrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrFxRate gets SettlCurrFxRate, Tag 155 +func (m ExecutionReport) GetSettlCurrFxRate() (f field.SettlCurrFxRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrFxRateCalc gets SettlCurrFxRateCalc, Tag 156 +func (m ExecutionReport) GetSettlCurrFxRateCalc() (f field.SettlCurrFxRateCalcField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNumDaysInterest gets NumDaysInterest, Tag 157 +func (m ExecutionReport) GetNumDaysInterest() (f field.NumDaysInterestField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAccruedInterestRate gets AccruedInterestRate, Tag 158 +func (m ExecutionReport) GetAccruedInterestRate() (f field.AccruedInterestRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAccruedInterestAmt gets AccruedInterestAmt, Tag 159 +func (m ExecutionReport) GetAccruedInterestAmt() (f field.AccruedInterestAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityType gets SecurityType, Tag 167 +func (m ExecutionReport) GetSecurityType() (f field.SecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEffectiveTime gets EffectiveTime, Tag 168 +func (m ExecutionReport) GetEffectiveTime() (f field.EffectiveTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty2 gets OrderQty2, Tag 192 +func (m ExecutionReport) GetOrderQty2() (f field.OrderQty2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFutSettDate2 gets FutSettDate2, Tag 193 +func (m ExecutionReport) GetFutSettDate2() (f field.FutSettDate2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastSpotRate gets LastSpotRate, Tag 194 +func (m ExecutionReport) GetLastSpotRate() (f field.LastSpotRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastForwardPoints gets LastForwardPoints, Tag 195 +func (m ExecutionReport) GetLastForwardPoints() (f field.LastForwardPointsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecondaryOrderID gets SecondaryOrderID, Tag 198 +func (m ExecutionReport) GetSecondaryOrderID() (f field.SecondaryOrderIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityMonthYear gets MaturityMonthYear, Tag 200 +func (m ExecutionReport) GetMaturityMonthYear() (f field.MaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikePrice gets StrikePrice, Tag 202 +func (m ExecutionReport) GetStrikePrice() (f field.StrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOptAttribute gets OptAttribute, Tag 206 +func (m ExecutionReport) GetOptAttribute() (f field.OptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityExchange gets SecurityExchange, Tag 207 +func (m ExecutionReport) GetSecurityExchange() (f field.SecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxShow gets MaxShow, Tag 210 +func (m ExecutionReport) GetMaxShow() (f field.MaxShowField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegDifference gets PegDifference, Tag 211 +func (m ExecutionReport) GetPegDifference() (f field.PegDifferenceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSpread gets Spread, Tag 218 +func (m ExecutionReport) GetSpread() (f field.SpreadField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkCurveCurrency gets BenchmarkCurveCurrency, Tag 220 +func (m ExecutionReport) GetBenchmarkCurveCurrency() (f field.BenchmarkCurveCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkCurveName gets BenchmarkCurveName, Tag 221 +func (m ExecutionReport) GetBenchmarkCurveName() (f field.BenchmarkCurveNameField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkCurvePoint gets BenchmarkCurvePoint, Tag 222 +func (m ExecutionReport) GetBenchmarkCurvePoint() (f field.BenchmarkCurvePointField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponRate gets CouponRate, Tag 223 +func (m ExecutionReport) GetCouponRate() (f field.CouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponPaymentDate gets CouponPaymentDate, Tag 224 +func (m ExecutionReport) GetCouponPaymentDate() (f field.CouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssueDate gets IssueDate, Tag 225 +func (m ExecutionReport) GetIssueDate() (f field.IssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseTerm gets RepurchaseTerm, Tag 226 +func (m ExecutionReport) GetRepurchaseTerm() (f field.RepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseRate gets RepurchaseRate, Tag 227 +func (m ExecutionReport) GetRepurchaseRate() (f field.RepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFactor gets Factor, Tag 228 +func (m ExecutionReport) GetFactor() (f field.FactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradeOriginationDate gets TradeOriginationDate, Tag 229 +func (m ExecutionReport) GetTradeOriginationDate() (f field.TradeOriginationDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExDate gets ExDate, Tag 230 +func (m ExecutionReport) GetExDate() (f field.ExDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractMultiplier gets ContractMultiplier, Tag 231 +func (m ExecutionReport) GetContractMultiplier() (f field.ContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoStipulations gets NoStipulations, Tag 232 +func (m ExecutionReport) GetNoStipulations() (NoStipulationsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoStipulationsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetYieldType gets YieldType, Tag 235 +func (m ExecutionReport) GetYieldType() (f field.YieldTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYield gets Yield, Tag 236 +func (m ExecutionReport) GetYield() (f field.YieldField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTotalTakedown gets TotalTakedown, Tag 237 +func (m ExecutionReport) GetTotalTakedown() (f field.TotalTakedownField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetConcession gets Concession, Tag 238 +func (m ExecutionReport) GetConcession() (f field.ConcessionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepoCollateralSecurityType gets RepoCollateralSecurityType, Tag 239 +func (m ExecutionReport) GetRepoCollateralSecurityType() (f field.RepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRedemptionDate gets RedemptionDate, Tag 240 +func (m ExecutionReport) GetRedemptionDate() (f field.RedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCreditRating gets CreditRating, Tag 255 +func (m ExecutionReport) GetCreditRating() (f field.CreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradedFlatSwitch gets TradedFlatSwitch, Tag 258 +func (m ExecutionReport) GetTradedFlatSwitch() (f field.TradedFlatSwitchField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBasisFeatureDate gets BasisFeatureDate, Tag 259 +func (m ExecutionReport) GetBasisFeatureDate() (f field.BasisFeatureDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBasisFeaturePrice gets BasisFeaturePrice, Tag 260 +func (m ExecutionReport) GetBasisFeaturePrice() (f field.BasisFeaturePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradingSessionID gets TradingSessionID, Tag 336 +func (m ExecutionReport) GetTradingSessionID() (f field.TradingSessionIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuerLen gets EncodedIssuerLen, Tag 348 +func (m ExecutionReport) GetEncodedIssuerLen() (f field.EncodedIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuer gets EncodedIssuer, Tag 349 +func (m ExecutionReport) GetEncodedIssuer() (f field.EncodedIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDescLen gets EncodedSecurityDescLen, Tag 350 +func (m ExecutionReport) GetEncodedSecurityDescLen() (f field.EncodedSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDesc gets EncodedSecurityDesc, Tag 351 +func (m ExecutionReport) GetEncodedSecurityDesc() (f field.EncodedSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedTextLen gets EncodedTextLen, Tag 354 +func (m ExecutionReport) GetEncodedTextLen() (f field.EncodedTextLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedText gets EncodedText, Tag 355 +func (m ExecutionReport) GetEncodedText() (f field.EncodedTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetComplianceID gets ComplianceID, Tag 376 +func (m ExecutionReport) GetComplianceID() (f field.ComplianceIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSolicitedFlag gets SolicitedFlag, Tag 377 +func (m ExecutionReport) GetSolicitedFlag() (f field.SolicitedFlagField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecRestatementReason gets ExecRestatementReason, Tag 378 +func (m ExecutionReport) GetExecRestatementReason() (f field.ExecRestatementReasonField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetGrossTradeAmt gets GrossTradeAmt, Tag 381 +func (m ExecutionReport) GetGrossTradeAmt() (f field.GrossTradeAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoContraBrokers gets NoContraBrokers, Tag 382 +func (m ExecutionReport) GetNoContraBrokers() (NoContraBrokersRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoContraBrokersRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetDiscretionInst gets DiscretionInst, Tag 388 +func (m ExecutionReport) GetDiscretionInst() (f field.DiscretionInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionOffset gets DiscretionOffset, Tag 389 +func (m ExecutionReport) GetDiscretionOffset() (f field.DiscretionOffsetField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPriceType gets PriceType, Tag 423 +func (m ExecutionReport) GetPriceType() (f field.PriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDayOrderQty gets DayOrderQty, Tag 424 +func (m ExecutionReport) GetDayOrderQty() (f field.DayOrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDayCumQty gets DayCumQty, Tag 425 +func (m ExecutionReport) GetDayCumQty() (f field.DayCumQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDayAvgPx gets DayAvgPx, Tag 426 +func (m ExecutionReport) GetDayAvgPx() (f field.DayAvgPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetGTBookingInst gets GTBookingInst, Tag 427 +func (m ExecutionReport) GetGTBookingInst() (f field.GTBookingInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireDate gets ExpireDate, Tag 432 +func (m ExecutionReport) GetExpireDate() (f field.ExpireDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMultiLegReportingType gets MultiLegReportingType, Tag 442 +func (m ExecutionReport) GetMultiLegReportingType() (f field.MultiLegReportingTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoPartyIDs gets NoPartyIDs, Tag 453 +func (m ExecutionReport) GetNoPartyIDs() (NoPartyIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoPartyIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetNoSecurityAltID gets NoSecurityAltID, Tag 454 +func (m ExecutionReport) GetNoSecurityAltID() (NoSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetProduct gets Product, Tag 460 +func (m ExecutionReport) GetProduct() (f field.ProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCFICode gets CFICode, Tag 461 +func (m ExecutionReport) GetCFICode() (f field.CFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetQuantityType gets QuantityType, Tag 465 +func (m ExecutionReport) GetQuantityType() (f field.QuantityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRoundingDirection gets RoundingDirection, Tag 468 +func (m ExecutionReport) GetRoundingDirection() (f field.RoundingDirectionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRoundingModulus gets RoundingModulus, Tag 469 +func (m ExecutionReport) GetRoundingModulus() (f field.RoundingModulusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCountryOfIssue gets CountryOfIssue, Tag 470 +func (m ExecutionReport) GetCountryOfIssue() (f field.CountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStateOrProvinceOfIssue gets StateOrProvinceOfIssue, Tag 471 +func (m ExecutionReport) GetStateOrProvinceOfIssue() (f field.StateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLocaleOfIssue gets LocaleOfIssue, Tag 472 +func (m ExecutionReport) GetLocaleOfIssue() (f field.LocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommCurrency gets CommCurrency, Tag 479 +func (m ExecutionReport) GetCommCurrency() (f field.CommCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCancellationRights gets CancellationRights, Tag 480 +func (m ExecutionReport) GetCancellationRights() (f field.CancellationRightsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMoneyLaunderingStatus gets MoneyLaunderingStatus, Tag 481 +func (m ExecutionReport) GetMoneyLaunderingStatus() (f field.MoneyLaunderingStatusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTransBkdTime gets TransBkdTime, Tag 483 +func (m ExecutionReport) GetTransBkdTime() (f field.TransBkdTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecPriceType gets ExecPriceType, Tag 484 +func (m ExecutionReport) GetExecPriceType() (f field.ExecPriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecPriceAdjustment gets ExecPriceAdjustment, Tag 485 +func (m ExecutionReport) GetExecPriceAdjustment() (f field.ExecPriceAdjustmentField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDesignation gets Designation, Tag 494 +func (m ExecutionReport) GetDesignation() (f field.DesignationField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFundRenewWaiv gets FundRenewWaiv, Tag 497 +func (m ExecutionReport) GetFundRenewWaiv() (f field.FundRenewWaivField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRegistID gets RegistID, Tag 513 +func (m ExecutionReport) GetRegistID() (f field.RegistIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecValuationPoint gets ExecValuationPoint, Tag 515 +func (m ExecutionReport) GetExecValuationPoint() (f field.ExecValuationPointField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderPercent gets OrderPercent, Tag 516 +func (m ExecutionReport) GetOrderPercent() (f field.OrderPercentField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoContAmts gets NoContAmts, Tag 518 +func (m ExecutionReport) GetNoContAmts() (NoContAmtsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoContAmtsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetSecondaryClOrdID gets SecondaryClOrdID, Tag 526 +func (m ExecutionReport) GetSecondaryClOrdID() (f field.SecondaryClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecondaryExecID gets SecondaryExecID, Tag 527 +func (m ExecutionReport) GetSecondaryExecID() (f field.SecondaryExecIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderCapacity gets OrderCapacity, Tag 528 +func (m ExecutionReport) GetOrderCapacity() (f field.OrderCapacityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderRestrictions gets OrderRestrictions, Tag 529 +func (m ExecutionReport) GetOrderRestrictions() (f field.OrderRestrictionsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityDate gets MaturityDate, Tag 541 +func (m ExecutionReport) GetMaturityDate() (f field.MaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrRegistry gets InstrRegistry, Tag 543 +func (m ExecutionReport) GetInstrRegistry() (f field.InstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashMargin gets CashMargin, Tag 544 +func (m ExecutionReport) GetCashMargin() (f field.CashMarginField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCrossID gets CrossID, Tag 548 +func (m ExecutionReport) GetCrossID() (f field.CrossIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCrossType gets CrossType, Tag 549 +func (m ExecutionReport) GetCrossType() (f field.CrossTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrigCrossID gets OrigCrossID, Tag 551 +func (m ExecutionReport) GetOrigCrossID() (f field.OrigCrossIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoLegs gets NoLegs, Tag 555 +func (m ExecutionReport) GetNoLegs() (NoLegsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoLegsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetAccountType gets AccountType, Tag 581 +func (m ExecutionReport) GetAccountType() (f field.AccountTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCustOrderCapacity gets CustOrderCapacity, Tag 582 +func (m ExecutionReport) GetCustOrderCapacity() (f field.CustOrderCapacityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdLinkID gets ClOrdLinkID, Tag 583 +func (m ExecutionReport) GetClOrdLinkID() (f field.ClOrdLinkIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDayBookingInst gets DayBookingInst, Tag 589 +func (m ExecutionReport) GetDayBookingInst() (f field.DayBookingInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBookingUnit gets BookingUnit, Tag 590 +func (m ExecutionReport) GetBookingUnit() (f field.BookingUnitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPreallocMethod gets PreallocMethod, Tag 591 +func (m ExecutionReport) GetPreallocMethod() (f field.PreallocMethodField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradingSessionSubID gets TradingSessionSubID, Tag 625 +func (m ExecutionReport) GetTradingSessionSubID() (f field.TradingSessionSubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClearingFeeIndicator gets ClearingFeeIndicator, Tag 635 +func (m ExecutionReport) GetClearingFeeIndicator() (f field.ClearingFeeIndicatorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetWorkingIndicator gets WorkingIndicator, Tag 636 +func (m ExecutionReport) GetWorkingIndicator() (f field.WorkingIndicatorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPriorityIndicator gets PriorityIndicator, Tag 638 +func (m ExecutionReport) GetPriorityIndicator() (f field.PriorityIndicatorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPriceImprovement gets PriceImprovement, Tag 639 +func (m ExecutionReport) GetPriceImprovement() (f field.PriceImprovementField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastForwardPoints2 gets LastForwardPoints2, Tag 641 +func (m ExecutionReport) GetLastForwardPoints2() (f field.LastForwardPoints2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingLastPx gets UnderlyingLastPx, Tag 651 +func (m ExecutionReport) GetUnderlyingLastPx() (f field.UnderlyingLastPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingLastQty gets UnderlyingLastQty, Tag 652 +func (m ExecutionReport) GetUnderlyingLastQty() (f field.UnderlyingLastQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasAccount returns true if Account is present, Tag 1 +func (m ExecutionReport) HasAccount() bool { + return m.Has(tag.Account) +} + +//HasAvgPx returns true if AvgPx is present, Tag 6 +func (m ExecutionReport) HasAvgPx() bool { + return m.Has(tag.AvgPx) +} + +//HasClOrdID returns true if ClOrdID is present, Tag 11 +func (m ExecutionReport) HasClOrdID() bool { + return m.Has(tag.ClOrdID) +} + +//HasCommission returns true if Commission is present, Tag 12 +func (m ExecutionReport) HasCommission() bool { + return m.Has(tag.Commission) +} + +//HasCommType returns true if CommType is present, Tag 13 +func (m ExecutionReport) HasCommType() bool { + return m.Has(tag.CommType) +} + +//HasCumQty returns true if CumQty is present, Tag 14 +func (m ExecutionReport) HasCumQty() bool { + return m.Has(tag.CumQty) +} + +//HasCurrency returns true if Currency is present, Tag 15 +func (m ExecutionReport) HasCurrency() bool { + return m.Has(tag.Currency) +} + +//HasExecID returns true if ExecID is present, Tag 17 +func (m ExecutionReport) HasExecID() bool { + return m.Has(tag.ExecID) +} + +//HasExecInst returns true if ExecInst is present, Tag 18 +func (m ExecutionReport) HasExecInst() bool { + return m.Has(tag.ExecInst) +} + +//HasExecRefID returns true if ExecRefID is present, Tag 19 +func (m ExecutionReport) HasExecRefID() bool { + return m.Has(tag.ExecRefID) +} + +//HasHandlInst returns true if HandlInst is present, Tag 21 +func (m ExecutionReport) HasHandlInst() bool { + return m.Has(tag.HandlInst) +} + +//HasSecurityIDSource returns true if SecurityIDSource is present, Tag 22 +func (m ExecutionReport) HasSecurityIDSource() bool { + return m.Has(tag.SecurityIDSource) +} + +//HasLastCapacity returns true if LastCapacity is present, Tag 29 +func (m ExecutionReport) HasLastCapacity() bool { + return m.Has(tag.LastCapacity) +} + +//HasLastMkt returns true if LastMkt is present, Tag 30 +func (m ExecutionReport) HasLastMkt() bool { + return m.Has(tag.LastMkt) +} + +//HasLastPx returns true if LastPx is present, Tag 31 +func (m ExecutionReport) HasLastPx() bool { + return m.Has(tag.LastPx) +} + +//HasLastQty returns true if LastQty is present, Tag 32 +func (m ExecutionReport) HasLastQty() bool { + return m.Has(tag.LastQty) +} + +//HasOrderID returns true if OrderID is present, Tag 37 +func (m ExecutionReport) HasOrderID() bool { + return m.Has(tag.OrderID) +} + +//HasOrderQty returns true if OrderQty is present, Tag 38 +func (m ExecutionReport) HasOrderQty() bool { + return m.Has(tag.OrderQty) +} + +//HasOrdStatus returns true if OrdStatus is present, Tag 39 +func (m ExecutionReport) HasOrdStatus() bool { + return m.Has(tag.OrdStatus) +} + +//HasOrdType returns true if OrdType is present, Tag 40 +func (m ExecutionReport) HasOrdType() bool { + return m.Has(tag.OrdType) +} + +//HasOrigClOrdID returns true if OrigClOrdID is present, Tag 41 +func (m ExecutionReport) HasOrigClOrdID() bool { + return m.Has(tag.OrigClOrdID) +} + +//HasPrice returns true if Price is present, Tag 44 +func (m ExecutionReport) HasPrice() bool { + return m.Has(tag.Price) +} + +//HasRule80A returns true if Rule80A is present, Tag 47 +func (m ExecutionReport) HasRule80A() bool { + return m.Has(tag.Rule80A) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m ExecutionReport) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSide returns true if Side is present, Tag 54 +func (m ExecutionReport) HasSide() bool { + return m.Has(tag.Side) +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m ExecutionReport) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasText returns true if Text is present, Tag 58 +func (m ExecutionReport) HasText() bool { + return m.Has(tag.Text) +} + +//HasTimeInForce returns true if TimeInForce is present, Tag 59 +func (m ExecutionReport) HasTimeInForce() bool { + return m.Has(tag.TimeInForce) +} + +//HasTransactTime returns true if TransactTime is present, Tag 60 +func (m ExecutionReport) HasTransactTime() bool { + return m.Has(tag.TransactTime) +} + +//HasSettlmntTyp returns true if SettlmntTyp is present, Tag 63 +func (m ExecutionReport) HasSettlmntTyp() bool { + return m.Has(tag.SettlmntTyp) +} + +//HasFutSettDate returns true if FutSettDate is present, Tag 64 +func (m ExecutionReport) HasFutSettDate() bool { + return m.Has(tag.FutSettDate) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m ExecutionReport) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasListID returns true if ListID is present, Tag 66 +func (m ExecutionReport) HasListID() bool { + return m.Has(tag.ListID) +} + +//HasTradeDate returns true if TradeDate is present, Tag 75 +func (m ExecutionReport) HasTradeDate() bool { + return m.Has(tag.TradeDate) +} + +//HasPositionEffect returns true if PositionEffect is present, Tag 77 +func (m ExecutionReport) HasPositionEffect() bool { + return m.Has(tag.PositionEffect) +} + +//HasStopPx returns true if StopPx is present, Tag 99 +func (m ExecutionReport) HasStopPx() bool { + return m.Has(tag.StopPx) +} + +//HasOrdRejReason returns true if OrdRejReason is present, Tag 103 +func (m ExecutionReport) HasOrdRejReason() bool { + return m.Has(tag.OrdRejReason) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m ExecutionReport) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m ExecutionReport) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasMinQty returns true if MinQty is present, Tag 110 +func (m ExecutionReport) HasMinQty() bool { + return m.Has(tag.MinQty) +} + +//HasMaxFloor returns true if MaxFloor is present, Tag 111 +func (m ExecutionReport) HasMaxFloor() bool { + return m.Has(tag.MaxFloor) +} + +//HasReportToExch returns true if ReportToExch is present, Tag 113 +func (m ExecutionReport) HasReportToExch() bool { + return m.Has(tag.ReportToExch) +} + +//HasNetMoney returns true if NetMoney is present, Tag 118 +func (m ExecutionReport) HasNetMoney() bool { + return m.Has(tag.NetMoney) +} + +//HasSettlCurrAmt returns true if SettlCurrAmt is present, Tag 119 +func (m ExecutionReport) HasSettlCurrAmt() bool { + return m.Has(tag.SettlCurrAmt) +} + +//HasSettlCurrency returns true if SettlCurrency is present, Tag 120 +func (m ExecutionReport) HasSettlCurrency() bool { + return m.Has(tag.SettlCurrency) +} + +//HasExpireTime returns true if ExpireTime is present, Tag 126 +func (m ExecutionReport) HasExpireTime() bool { + return m.Has(tag.ExpireTime) +} + +//HasExecType returns true if ExecType is present, Tag 150 +func (m ExecutionReport) HasExecType() bool { + return m.Has(tag.ExecType) +} + +//HasLeavesQty returns true if LeavesQty is present, Tag 151 +func (m ExecutionReport) HasLeavesQty() bool { + return m.Has(tag.LeavesQty) +} + +//HasCashOrderQty returns true if CashOrderQty is present, Tag 152 +func (m ExecutionReport) HasCashOrderQty() bool { + return m.Has(tag.CashOrderQty) +} + +//HasSettlCurrFxRate returns true if SettlCurrFxRate is present, Tag 155 +func (m ExecutionReport) HasSettlCurrFxRate() bool { + return m.Has(tag.SettlCurrFxRate) +} + +//HasSettlCurrFxRateCalc returns true if SettlCurrFxRateCalc is present, Tag 156 +func (m ExecutionReport) HasSettlCurrFxRateCalc() bool { + return m.Has(tag.SettlCurrFxRateCalc) +} + +//HasNumDaysInterest returns true if NumDaysInterest is present, Tag 157 +func (m ExecutionReport) HasNumDaysInterest() bool { + return m.Has(tag.NumDaysInterest) +} + +//HasAccruedInterestRate returns true if AccruedInterestRate is present, Tag 158 +func (m ExecutionReport) HasAccruedInterestRate() bool { + return m.Has(tag.AccruedInterestRate) +} + +//HasAccruedInterestAmt returns true if AccruedInterestAmt is present, Tag 159 +func (m ExecutionReport) HasAccruedInterestAmt() bool { + return m.Has(tag.AccruedInterestAmt) +} + +//HasSecurityType returns true if SecurityType is present, Tag 167 +func (m ExecutionReport) HasSecurityType() bool { + return m.Has(tag.SecurityType) +} + +//HasEffectiveTime returns true if EffectiveTime is present, Tag 168 +func (m ExecutionReport) HasEffectiveTime() bool { + return m.Has(tag.EffectiveTime) +} + +//HasOrderQty2 returns true if OrderQty2 is present, Tag 192 +func (m ExecutionReport) HasOrderQty2() bool { + return m.Has(tag.OrderQty2) +} + +//HasFutSettDate2 returns true if FutSettDate2 is present, Tag 193 +func (m ExecutionReport) HasFutSettDate2() bool { + return m.Has(tag.FutSettDate2) +} + +//HasLastSpotRate returns true if LastSpotRate is present, Tag 194 +func (m ExecutionReport) HasLastSpotRate() bool { + return m.Has(tag.LastSpotRate) +} + +//HasLastForwardPoints returns true if LastForwardPoints is present, Tag 195 +func (m ExecutionReport) HasLastForwardPoints() bool { + return m.Has(tag.LastForwardPoints) +} + +//HasSecondaryOrderID returns true if SecondaryOrderID is present, Tag 198 +func (m ExecutionReport) HasSecondaryOrderID() bool { + return m.Has(tag.SecondaryOrderID) +} + +//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200 +func (m ExecutionReport) HasMaturityMonthYear() bool { + return m.Has(tag.MaturityMonthYear) +} + +//HasStrikePrice returns true if StrikePrice is present, Tag 202 +func (m ExecutionReport) HasStrikePrice() bool { + return m.Has(tag.StrikePrice) +} + +//HasOptAttribute returns true if OptAttribute is present, Tag 206 +func (m ExecutionReport) HasOptAttribute() bool { + return m.Has(tag.OptAttribute) +} + +//HasSecurityExchange returns true if SecurityExchange is present, Tag 207 +func (m ExecutionReport) HasSecurityExchange() bool { + return m.Has(tag.SecurityExchange) +} + +//HasMaxShow returns true if MaxShow is present, Tag 210 +func (m ExecutionReport) HasMaxShow() bool { + return m.Has(tag.MaxShow) +} + +//HasPegDifference returns true if PegDifference is present, Tag 211 +func (m ExecutionReport) HasPegDifference() bool { + return m.Has(tag.PegDifference) +} + +//HasSpread returns true if Spread is present, Tag 218 +func (m ExecutionReport) HasSpread() bool { + return m.Has(tag.Spread) +} + +//HasBenchmarkCurveCurrency returns true if BenchmarkCurveCurrency is present, Tag 220 +func (m ExecutionReport) HasBenchmarkCurveCurrency() bool { + return m.Has(tag.BenchmarkCurveCurrency) +} + +//HasBenchmarkCurveName returns true if BenchmarkCurveName is present, Tag 221 +func (m ExecutionReport) HasBenchmarkCurveName() bool { + return m.Has(tag.BenchmarkCurveName) +} + +//HasBenchmarkCurvePoint returns true if BenchmarkCurvePoint is present, Tag 222 +func (m ExecutionReport) HasBenchmarkCurvePoint() bool { + return m.Has(tag.BenchmarkCurvePoint) +} + +//HasCouponRate returns true if CouponRate is present, Tag 223 +func (m ExecutionReport) HasCouponRate() bool { + return m.Has(tag.CouponRate) +} + +//HasCouponPaymentDate returns true if CouponPaymentDate is present, Tag 224 +func (m ExecutionReport) HasCouponPaymentDate() bool { + return m.Has(tag.CouponPaymentDate) +} + +//HasIssueDate returns true if IssueDate is present, Tag 225 +func (m ExecutionReport) HasIssueDate() bool { + return m.Has(tag.IssueDate) +} + +//HasRepurchaseTerm returns true if RepurchaseTerm is present, Tag 226 +func (m ExecutionReport) HasRepurchaseTerm() bool { + return m.Has(tag.RepurchaseTerm) +} + +//HasRepurchaseRate returns true if RepurchaseRate is present, Tag 227 +func (m ExecutionReport) HasRepurchaseRate() bool { + return m.Has(tag.RepurchaseRate) +} + +//HasFactor returns true if Factor is present, Tag 228 +func (m ExecutionReport) HasFactor() bool { + return m.Has(tag.Factor) +} + +//HasTradeOriginationDate returns true if TradeOriginationDate is present, Tag 229 +func (m ExecutionReport) HasTradeOriginationDate() bool { + return m.Has(tag.TradeOriginationDate) +} + +//HasExDate returns true if ExDate is present, Tag 230 +func (m ExecutionReport) HasExDate() bool { + return m.Has(tag.ExDate) +} + +//HasContractMultiplier returns true if ContractMultiplier is present, Tag 231 +func (m ExecutionReport) HasContractMultiplier() bool { + return m.Has(tag.ContractMultiplier) +} + +//HasNoStipulations returns true if NoStipulations is present, Tag 232 +func (m ExecutionReport) HasNoStipulations() bool { + return m.Has(tag.NoStipulations) +} + +//HasYieldType returns true if YieldType is present, Tag 235 +func (m ExecutionReport) HasYieldType() bool { + return m.Has(tag.YieldType) +} + +//HasYield returns true if Yield is present, Tag 236 +func (m ExecutionReport) HasYield() bool { + return m.Has(tag.Yield) +} + +//HasTotalTakedown returns true if TotalTakedown is present, Tag 237 +func (m ExecutionReport) HasTotalTakedown() bool { + return m.Has(tag.TotalTakedown) +} + +//HasConcession returns true if Concession is present, Tag 238 +func (m ExecutionReport) HasConcession() bool { + return m.Has(tag.Concession) +} + +//HasRepoCollateralSecurityType returns true if RepoCollateralSecurityType is present, Tag 239 +func (m ExecutionReport) HasRepoCollateralSecurityType() bool { + return m.Has(tag.RepoCollateralSecurityType) +} + +//HasRedemptionDate returns true if RedemptionDate is present, Tag 240 +func (m ExecutionReport) HasRedemptionDate() bool { + return m.Has(tag.RedemptionDate) +} + +//HasCreditRating returns true if CreditRating is present, Tag 255 +func (m ExecutionReport) HasCreditRating() bool { + return m.Has(tag.CreditRating) +} + +//HasTradedFlatSwitch returns true if TradedFlatSwitch is present, Tag 258 +func (m ExecutionReport) HasTradedFlatSwitch() bool { + return m.Has(tag.TradedFlatSwitch) +} + +//HasBasisFeatureDate returns true if BasisFeatureDate is present, Tag 259 +func (m ExecutionReport) HasBasisFeatureDate() bool { + return m.Has(tag.BasisFeatureDate) +} + +//HasBasisFeaturePrice returns true if BasisFeaturePrice is present, Tag 260 +func (m ExecutionReport) HasBasisFeaturePrice() bool { + return m.Has(tag.BasisFeaturePrice) +} + +//HasTradingSessionID returns true if TradingSessionID is present, Tag 336 +func (m ExecutionReport) HasTradingSessionID() bool { + return m.Has(tag.TradingSessionID) +} + +//HasEncodedIssuerLen returns true if EncodedIssuerLen is present, Tag 348 +func (m ExecutionReport) HasEncodedIssuerLen() bool { + return m.Has(tag.EncodedIssuerLen) +} + +//HasEncodedIssuer returns true if EncodedIssuer is present, Tag 349 +func (m ExecutionReport) HasEncodedIssuer() bool { + return m.Has(tag.EncodedIssuer) +} + +//HasEncodedSecurityDescLen returns true if EncodedSecurityDescLen is present, Tag 350 +func (m ExecutionReport) HasEncodedSecurityDescLen() bool { + return m.Has(tag.EncodedSecurityDescLen) +} + +//HasEncodedSecurityDesc returns true if EncodedSecurityDesc is present, Tag 351 +func (m ExecutionReport) HasEncodedSecurityDesc() bool { + return m.Has(tag.EncodedSecurityDesc) +} + +//HasEncodedTextLen returns true if EncodedTextLen is present, Tag 354 +func (m ExecutionReport) HasEncodedTextLen() bool { + return m.Has(tag.EncodedTextLen) +} + +//HasEncodedText returns true if EncodedText is present, Tag 355 +func (m ExecutionReport) HasEncodedText() bool { + return m.Has(tag.EncodedText) +} + +//HasComplianceID returns true if ComplianceID is present, Tag 376 +func (m ExecutionReport) HasComplianceID() bool { + return m.Has(tag.ComplianceID) +} + +//HasSolicitedFlag returns true if SolicitedFlag is present, Tag 377 +func (m ExecutionReport) HasSolicitedFlag() bool { + return m.Has(tag.SolicitedFlag) +} + +//HasExecRestatementReason returns true if ExecRestatementReason is present, Tag 378 +func (m ExecutionReport) HasExecRestatementReason() bool { + return m.Has(tag.ExecRestatementReason) +} + +//HasGrossTradeAmt returns true if GrossTradeAmt is present, Tag 381 +func (m ExecutionReport) HasGrossTradeAmt() bool { + return m.Has(tag.GrossTradeAmt) +} + +//HasNoContraBrokers returns true if NoContraBrokers is present, Tag 382 +func (m ExecutionReport) HasNoContraBrokers() bool { + return m.Has(tag.NoContraBrokers) +} + +//HasDiscretionInst returns true if DiscretionInst is present, Tag 388 +func (m ExecutionReport) HasDiscretionInst() bool { + return m.Has(tag.DiscretionInst) +} + +//HasDiscretionOffset returns true if DiscretionOffset is present, Tag 389 +func (m ExecutionReport) HasDiscretionOffset() bool { + return m.Has(tag.DiscretionOffset) +} + +//HasPriceType returns true if PriceType is present, Tag 423 +func (m ExecutionReport) HasPriceType() bool { + return m.Has(tag.PriceType) +} + +//HasDayOrderQty returns true if DayOrderQty is present, Tag 424 +func (m ExecutionReport) HasDayOrderQty() bool { + return m.Has(tag.DayOrderQty) +} + +//HasDayCumQty returns true if DayCumQty is present, Tag 425 +func (m ExecutionReport) HasDayCumQty() bool { + return m.Has(tag.DayCumQty) +} + +//HasDayAvgPx returns true if DayAvgPx is present, Tag 426 +func (m ExecutionReport) HasDayAvgPx() bool { + return m.Has(tag.DayAvgPx) +} + +//HasGTBookingInst returns true if GTBookingInst is present, Tag 427 +func (m ExecutionReport) HasGTBookingInst() bool { + return m.Has(tag.GTBookingInst) +} + +//HasExpireDate returns true if ExpireDate is present, Tag 432 +func (m ExecutionReport) HasExpireDate() bool { + return m.Has(tag.ExpireDate) +} + +//HasMultiLegReportingType returns true if MultiLegReportingType is present, Tag 442 +func (m ExecutionReport) HasMultiLegReportingType() bool { + return m.Has(tag.MultiLegReportingType) +} + +//HasNoPartyIDs returns true if NoPartyIDs is present, Tag 453 +func (m ExecutionReport) HasNoPartyIDs() bool { + return m.Has(tag.NoPartyIDs) +} + +//HasNoSecurityAltID returns true if NoSecurityAltID is present, Tag 454 +func (m ExecutionReport) HasNoSecurityAltID() bool { + return m.Has(tag.NoSecurityAltID) +} + +//HasProduct returns true if Product is present, Tag 460 +func (m ExecutionReport) HasProduct() bool { + return m.Has(tag.Product) +} + +//HasCFICode returns true if CFICode is present, Tag 461 +func (m ExecutionReport) HasCFICode() bool { + return m.Has(tag.CFICode) +} + +//HasQuantityType returns true if QuantityType is present, Tag 465 +func (m ExecutionReport) HasQuantityType() bool { + return m.Has(tag.QuantityType) +} + +//HasRoundingDirection returns true if RoundingDirection is present, Tag 468 +func (m ExecutionReport) HasRoundingDirection() bool { + return m.Has(tag.RoundingDirection) +} + +//HasRoundingModulus returns true if RoundingModulus is present, Tag 469 +func (m ExecutionReport) HasRoundingModulus() bool { + return m.Has(tag.RoundingModulus) +} + +//HasCountryOfIssue returns true if CountryOfIssue is present, Tag 470 +func (m ExecutionReport) HasCountryOfIssue() bool { + return m.Has(tag.CountryOfIssue) +} + +//HasStateOrProvinceOfIssue returns true if StateOrProvinceOfIssue is present, Tag 471 +func (m ExecutionReport) HasStateOrProvinceOfIssue() bool { + return m.Has(tag.StateOrProvinceOfIssue) +} + +//HasLocaleOfIssue returns true if LocaleOfIssue is present, Tag 472 +func (m ExecutionReport) HasLocaleOfIssue() bool { + return m.Has(tag.LocaleOfIssue) +} + +//HasCommCurrency returns true if CommCurrency is present, Tag 479 +func (m ExecutionReport) HasCommCurrency() bool { + return m.Has(tag.CommCurrency) +} + +//HasCancellationRights returns true if CancellationRights is present, Tag 480 +func (m ExecutionReport) HasCancellationRights() bool { + return m.Has(tag.CancellationRights) +} + +//HasMoneyLaunderingStatus returns true if MoneyLaunderingStatus is present, Tag 481 +func (m ExecutionReport) HasMoneyLaunderingStatus() bool { + return m.Has(tag.MoneyLaunderingStatus) +} + +//HasTransBkdTime returns true if TransBkdTime is present, Tag 483 +func (m ExecutionReport) HasTransBkdTime() bool { + return m.Has(tag.TransBkdTime) +} + +//HasExecPriceType returns true if ExecPriceType is present, Tag 484 +func (m ExecutionReport) HasExecPriceType() bool { + return m.Has(tag.ExecPriceType) +} + +//HasExecPriceAdjustment returns true if ExecPriceAdjustment is present, Tag 485 +func (m ExecutionReport) HasExecPriceAdjustment() bool { + return m.Has(tag.ExecPriceAdjustment) +} + +//HasDesignation returns true if Designation is present, Tag 494 +func (m ExecutionReport) HasDesignation() bool { + return m.Has(tag.Designation) +} + +//HasFundRenewWaiv returns true if FundRenewWaiv is present, Tag 497 +func (m ExecutionReport) HasFundRenewWaiv() bool { + return m.Has(tag.FundRenewWaiv) +} + +//HasRegistID returns true if RegistID is present, Tag 513 +func (m ExecutionReport) HasRegistID() bool { + return m.Has(tag.RegistID) +} + +//HasExecValuationPoint returns true if ExecValuationPoint is present, Tag 515 +func (m ExecutionReport) HasExecValuationPoint() bool { + return m.Has(tag.ExecValuationPoint) +} + +//HasOrderPercent returns true if OrderPercent is present, Tag 516 +func (m ExecutionReport) HasOrderPercent() bool { + return m.Has(tag.OrderPercent) +} + +//HasNoContAmts returns true if NoContAmts is present, Tag 518 +func (m ExecutionReport) HasNoContAmts() bool { + return m.Has(tag.NoContAmts) +} + +//HasSecondaryClOrdID returns true if SecondaryClOrdID is present, Tag 526 +func (m ExecutionReport) HasSecondaryClOrdID() bool { + return m.Has(tag.SecondaryClOrdID) +} + +//HasSecondaryExecID returns true if SecondaryExecID is present, Tag 527 +func (m ExecutionReport) HasSecondaryExecID() bool { + return m.Has(tag.SecondaryExecID) +} + +//HasOrderCapacity returns true if OrderCapacity is present, Tag 528 +func (m ExecutionReport) HasOrderCapacity() bool { + return m.Has(tag.OrderCapacity) +} + +//HasOrderRestrictions returns true if OrderRestrictions is present, Tag 529 +func (m ExecutionReport) HasOrderRestrictions() bool { + return m.Has(tag.OrderRestrictions) +} + +//HasMaturityDate returns true if MaturityDate is present, Tag 541 +func (m ExecutionReport) HasMaturityDate() bool { + return m.Has(tag.MaturityDate) +} + +//HasInstrRegistry returns true if InstrRegistry is present, Tag 543 +func (m ExecutionReport) HasInstrRegistry() bool { + return m.Has(tag.InstrRegistry) +} + +//HasCashMargin returns true if CashMargin is present, Tag 544 +func (m ExecutionReport) HasCashMargin() bool { + return m.Has(tag.CashMargin) +} + +//HasCrossID returns true if CrossID is present, Tag 548 +func (m ExecutionReport) HasCrossID() bool { + return m.Has(tag.CrossID) +} + +//HasCrossType returns true if CrossType is present, Tag 549 +func (m ExecutionReport) HasCrossType() bool { + return m.Has(tag.CrossType) +} + +//HasOrigCrossID returns true if OrigCrossID is present, Tag 551 +func (m ExecutionReport) HasOrigCrossID() bool { + return m.Has(tag.OrigCrossID) +} + +//HasNoLegs returns true if NoLegs is present, Tag 555 +func (m ExecutionReport) HasNoLegs() bool { + return m.Has(tag.NoLegs) +} + +//HasAccountType returns true if AccountType is present, Tag 581 +func (m ExecutionReport) HasAccountType() bool { + return m.Has(tag.AccountType) +} + +//HasCustOrderCapacity returns true if CustOrderCapacity is present, Tag 582 +func (m ExecutionReport) HasCustOrderCapacity() bool { + return m.Has(tag.CustOrderCapacity) +} + +//HasClOrdLinkID returns true if ClOrdLinkID is present, Tag 583 +func (m ExecutionReport) HasClOrdLinkID() bool { + return m.Has(tag.ClOrdLinkID) +} + +//HasDayBookingInst returns true if DayBookingInst is present, Tag 589 +func (m ExecutionReport) HasDayBookingInst() bool { + return m.Has(tag.DayBookingInst) +} + +//HasBookingUnit returns true if BookingUnit is present, Tag 590 +func (m ExecutionReport) HasBookingUnit() bool { + return m.Has(tag.BookingUnit) +} + +//HasPreallocMethod returns true if PreallocMethod is present, Tag 591 +func (m ExecutionReport) HasPreallocMethod() bool { + return m.Has(tag.PreallocMethod) +} + +//HasTradingSessionSubID returns true if TradingSessionSubID is present, Tag 625 +func (m ExecutionReport) HasTradingSessionSubID() bool { + return m.Has(tag.TradingSessionSubID) +} + +//HasClearingFeeIndicator returns true if ClearingFeeIndicator is present, Tag 635 +func (m ExecutionReport) HasClearingFeeIndicator() bool { + return m.Has(tag.ClearingFeeIndicator) +} + +//HasWorkingIndicator returns true if WorkingIndicator is present, Tag 636 +func (m ExecutionReport) HasWorkingIndicator() bool { + return m.Has(tag.WorkingIndicator) +} + +//HasPriorityIndicator returns true if PriorityIndicator is present, Tag 638 +func (m ExecutionReport) HasPriorityIndicator() bool { + return m.Has(tag.PriorityIndicator) +} + +//HasPriceImprovement returns true if PriceImprovement is present, Tag 639 +func (m ExecutionReport) HasPriceImprovement() bool { + return m.Has(tag.PriceImprovement) +} + +//HasLastForwardPoints2 returns true if LastForwardPoints2 is present, Tag 641 +func (m ExecutionReport) HasLastForwardPoints2() bool { + return m.Has(tag.LastForwardPoints2) +} + +//HasUnderlyingLastPx returns true if UnderlyingLastPx is present, Tag 651 +func (m ExecutionReport) HasUnderlyingLastPx() bool { + return m.Has(tag.UnderlyingLastPx) +} + +//HasUnderlyingLastQty returns true if UnderlyingLastQty is present, Tag 652 +func (m ExecutionReport) HasUnderlyingLastQty() bool { + return m.Has(tag.UnderlyingLastQty) +} + +//NoStipulations is a repeating group element, Tag 232 +type NoStipulations struct { + quickfix.Group +} + +//SetStipulationType sets StipulationType, Tag 233 +func (m NoStipulations) SetStipulationType(v string) { + m.Set(field.NewStipulationType(v)) +} + +//SetStipulationValue sets StipulationValue, Tag 234 +func (m NoStipulations) SetStipulationValue(v string) { + m.Set(field.NewStipulationValue(v)) +} + +//GetStipulationType gets StipulationType, Tag 233 +func (m NoStipulations) GetStipulationType() (f field.StipulationTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStipulationValue gets StipulationValue, Tag 234 +func (m NoStipulations) GetStipulationValue() (f field.StipulationValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasStipulationType returns true if StipulationType is present, Tag 233 +func (m NoStipulations) HasStipulationType() bool { + return m.Has(tag.StipulationType) +} + +//HasStipulationValue returns true if StipulationValue is present, Tag 234 +func (m NoStipulations) HasStipulationValue() bool { + return m.Has(tag.StipulationValue) +} + +//NoStipulationsRepeatingGroup is a repeating group, Tag 232 +type NoStipulationsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoStipulationsRepeatingGroup returns an initialized, NoStipulationsRepeatingGroup +func NewNoStipulationsRepeatingGroup() NoStipulationsRepeatingGroup { + return NoStipulationsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoStipulations, + quickfix.GroupTemplate{quickfix.GroupElement(tag.StipulationType), quickfix.GroupElement(tag.StipulationValue)})} +} + +//Add create and append a new NoStipulations to this group +func (m NoStipulationsRepeatingGroup) Add() NoStipulations { + g := m.RepeatingGroup.Add() + return NoStipulations{g} +} + +//Get returns the ith NoStipulations in the NoStipulationsRepeatinGroup +func (m NoStipulationsRepeatingGroup) Get(i int) NoStipulations { + return NoStipulations{m.RepeatingGroup.Get(i)} +} + +//NoContraBrokers is a repeating group element, Tag 382 +type NoContraBrokers struct { + quickfix.Group +} + +//SetContraBroker sets ContraBroker, Tag 375 +func (m NoContraBrokers) SetContraBroker(v string) { + m.Set(field.NewContraBroker(v)) +} + +//SetContraTrader sets ContraTrader, Tag 337 +func (m NoContraBrokers) SetContraTrader(v string) { + m.Set(field.NewContraTrader(v)) +} + +//SetContraTradeQty sets ContraTradeQty, Tag 437 +func (m NoContraBrokers) SetContraTradeQty(v float64) { + m.Set(field.NewContraTradeQty(v)) +} + +//SetContraTradeTime sets ContraTradeTime, Tag 438 +func (m NoContraBrokers) SetContraTradeTime(v time.Time) { + m.Set(field.NewContraTradeTime(v)) +} + +//SetContraLegRefID sets ContraLegRefID, Tag 655 +func (m NoContraBrokers) SetContraLegRefID(v string) { + m.Set(field.NewContraLegRefID(v)) +} + +//GetContraBroker gets ContraBroker, Tag 375 +func (m NoContraBrokers) GetContraBroker() (f field.ContraBrokerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContraTrader gets ContraTrader, Tag 337 +func (m NoContraBrokers) GetContraTrader() (f field.ContraTraderField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContraTradeQty gets ContraTradeQty, Tag 437 +func (m NoContraBrokers) GetContraTradeQty() (f field.ContraTradeQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContraTradeTime gets ContraTradeTime, Tag 438 +func (m NoContraBrokers) GetContraTradeTime() (f field.ContraTradeTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContraLegRefID gets ContraLegRefID, Tag 655 +func (m NoContraBrokers) GetContraLegRefID() (f field.ContraLegRefIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasContraBroker returns true if ContraBroker is present, Tag 375 +func (m NoContraBrokers) HasContraBroker() bool { + return m.Has(tag.ContraBroker) +} + +//HasContraTrader returns true if ContraTrader is present, Tag 337 +func (m NoContraBrokers) HasContraTrader() bool { + return m.Has(tag.ContraTrader) +} + +//HasContraTradeQty returns true if ContraTradeQty is present, Tag 437 +func (m NoContraBrokers) HasContraTradeQty() bool { + return m.Has(tag.ContraTradeQty) +} + +//HasContraTradeTime returns true if ContraTradeTime is present, Tag 438 +func (m NoContraBrokers) HasContraTradeTime() bool { + return m.Has(tag.ContraTradeTime) +} + +//HasContraLegRefID returns true if ContraLegRefID is present, Tag 655 +func (m NoContraBrokers) HasContraLegRefID() bool { + return m.Has(tag.ContraLegRefID) +} + +//NoContraBrokersRepeatingGroup is a repeating group, Tag 382 +type NoContraBrokersRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoContraBrokersRepeatingGroup returns an initialized, NoContraBrokersRepeatingGroup +func NewNoContraBrokersRepeatingGroup() NoContraBrokersRepeatingGroup { + return NoContraBrokersRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoContraBrokers, + quickfix.GroupTemplate{quickfix.GroupElement(tag.ContraBroker), quickfix.GroupElement(tag.ContraTrader), quickfix.GroupElement(tag.ContraTradeQty), quickfix.GroupElement(tag.ContraTradeTime), quickfix.GroupElement(tag.ContraLegRefID)})} +} + +//Add create and append a new NoContraBrokers to this group +func (m NoContraBrokersRepeatingGroup) Add() NoContraBrokers { + g := m.RepeatingGroup.Add() + return NoContraBrokers{g} +} + +//Get returns the ith NoContraBrokers in the NoContraBrokersRepeatinGroup +func (m NoContraBrokersRepeatingGroup) Get(i int) NoContraBrokers { + return NoContraBrokers{m.RepeatingGroup.Get(i)} +} + +//NoPartyIDs is a repeating group element, Tag 453 +type NoPartyIDs struct { + quickfix.Group +} + +//SetPartyID sets PartyID, Tag 448 +func (m NoPartyIDs) SetPartyID(v string) { + m.Set(field.NewPartyID(v)) +} + +//SetPartyIDSource sets PartyIDSource, Tag 447 +func (m NoPartyIDs) SetPartyIDSource(v string) { + m.Set(field.NewPartyIDSource(v)) +} + +//SetPartyRole sets PartyRole, Tag 452 +func (m NoPartyIDs) SetPartyRole(v int) { + m.Set(field.NewPartyRole(v)) +} + +//SetPartySubID sets PartySubID, Tag 523 +func (m NoPartyIDs) SetPartySubID(v string) { + m.Set(field.NewPartySubID(v)) +} + +//GetPartyID gets PartyID, Tag 448 +func (m NoPartyIDs) GetPartyID() (f field.PartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartyIDSource gets PartyIDSource, Tag 447 +func (m NoPartyIDs) GetPartyIDSource() (f field.PartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartyRole gets PartyRole, Tag 452 +func (m NoPartyIDs) GetPartyRole() (f field.PartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartySubID gets PartySubID, Tag 523 +func (m NoPartyIDs) GetPartySubID() (f field.PartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasPartyID returns true if PartyID is present, Tag 448 +func (m NoPartyIDs) HasPartyID() bool { + return m.Has(tag.PartyID) +} + +//HasPartyIDSource returns true if PartyIDSource is present, Tag 447 +func (m NoPartyIDs) HasPartyIDSource() bool { + return m.Has(tag.PartyIDSource) +} + +//HasPartyRole returns true if PartyRole is present, Tag 452 +func (m NoPartyIDs) HasPartyRole() bool { + return m.Has(tag.PartyRole) +} + +//HasPartySubID returns true if PartySubID is present, Tag 523 +func (m NoPartyIDs) HasPartySubID() bool { + return m.Has(tag.PartySubID) +} + +//NoPartyIDsRepeatingGroup is a repeating group, Tag 453 +type NoPartyIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoPartyIDsRepeatingGroup returns an initialized, NoPartyIDsRepeatingGroup +func NewNoPartyIDsRepeatingGroup() NoPartyIDsRepeatingGroup { + return NoPartyIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoPartyIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.PartyID), quickfix.GroupElement(tag.PartyIDSource), quickfix.GroupElement(tag.PartyRole), quickfix.GroupElement(tag.PartySubID)})} +} + +//Add create and append a new NoPartyIDs to this group +func (m NoPartyIDsRepeatingGroup) Add() NoPartyIDs { + g := m.RepeatingGroup.Add() + return NoPartyIDs{g} +} + +//Get returns the ith NoPartyIDs in the NoPartyIDsRepeatinGroup +func (m NoPartyIDsRepeatingGroup) Get(i int) NoPartyIDs { + return NoPartyIDs{m.RepeatingGroup.Get(i)} +} + +//NoSecurityAltID is a repeating group element, Tag 454 +type NoSecurityAltID struct { + quickfix.Group +} + +//SetSecurityAltID sets SecurityAltID, Tag 455 +func (m NoSecurityAltID) SetSecurityAltID(v string) { + m.Set(field.NewSecurityAltID(v)) +} + +//SetSecurityAltIDSource sets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) SetSecurityAltIDSource(v string) { + m.Set(field.NewSecurityAltIDSource(v)) +} + +//GetSecurityAltID gets SecurityAltID, Tag 455 +func (m NoSecurityAltID) GetSecurityAltID() (f field.SecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityAltIDSource gets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) GetSecurityAltIDSource() (f field.SecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasSecurityAltID returns true if SecurityAltID is present, Tag 455 +func (m NoSecurityAltID) HasSecurityAltID() bool { + return m.Has(tag.SecurityAltID) +} + +//HasSecurityAltIDSource returns true if SecurityAltIDSource is present, Tag 456 +func (m NoSecurityAltID) HasSecurityAltIDSource() bool { + return m.Has(tag.SecurityAltIDSource) +} + +//NoSecurityAltIDRepeatingGroup is a repeating group, Tag 454 +type NoSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoSecurityAltIDRepeatingGroup returns an initialized, NoSecurityAltIDRepeatingGroup +func NewNoSecurityAltIDRepeatingGroup() NoSecurityAltIDRepeatingGroup { + return NoSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.SecurityAltID), quickfix.GroupElement(tag.SecurityAltIDSource)})} +} + +//Add create and append a new NoSecurityAltID to this group +func (m NoSecurityAltIDRepeatingGroup) Add() NoSecurityAltID { + g := m.RepeatingGroup.Add() + return NoSecurityAltID{g} +} + +//Get returns the ith NoSecurityAltID in the NoSecurityAltIDRepeatinGroup +func (m NoSecurityAltIDRepeatingGroup) Get(i int) NoSecurityAltID { + return NoSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoContAmts is a repeating group element, Tag 518 +type NoContAmts struct { + quickfix.Group +} + +//SetContAmtType sets ContAmtType, Tag 519 +func (m NoContAmts) SetContAmtType(v int) { + m.Set(field.NewContAmtType(v)) +} + +//SetContAmtValue sets ContAmtValue, Tag 520 +func (m NoContAmts) SetContAmtValue(v float64) { + m.Set(field.NewContAmtValue(v)) +} + +//SetContAmtCurr sets ContAmtCurr, Tag 521 +func (m NoContAmts) SetContAmtCurr(v string) { + m.Set(field.NewContAmtCurr(v)) +} + +//GetContAmtType gets ContAmtType, Tag 519 +func (m NoContAmts) GetContAmtType() (f field.ContAmtTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContAmtValue gets ContAmtValue, Tag 520 +func (m NoContAmts) GetContAmtValue() (f field.ContAmtValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContAmtCurr gets ContAmtCurr, Tag 521 +func (m NoContAmts) GetContAmtCurr() (f field.ContAmtCurrField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasContAmtType returns true if ContAmtType is present, Tag 519 +func (m NoContAmts) HasContAmtType() bool { + return m.Has(tag.ContAmtType) +} + +//HasContAmtValue returns true if ContAmtValue is present, Tag 520 +func (m NoContAmts) HasContAmtValue() bool { + return m.Has(tag.ContAmtValue) +} + +//HasContAmtCurr returns true if ContAmtCurr is present, Tag 521 +func (m NoContAmts) HasContAmtCurr() bool { + return m.Has(tag.ContAmtCurr) +} + +//NoContAmtsRepeatingGroup is a repeating group, Tag 518 +type NoContAmtsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoContAmtsRepeatingGroup returns an initialized, NoContAmtsRepeatingGroup +func NewNoContAmtsRepeatingGroup() NoContAmtsRepeatingGroup { + return NoContAmtsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoContAmts, + quickfix.GroupTemplate{quickfix.GroupElement(tag.ContAmtType), quickfix.GroupElement(tag.ContAmtValue), quickfix.GroupElement(tag.ContAmtCurr)})} +} + +//Add create and append a new NoContAmts to this group +func (m NoContAmtsRepeatingGroup) Add() NoContAmts { + g := m.RepeatingGroup.Add() + return NoContAmts{g} +} + +//Get returns the ith NoContAmts in the NoContAmtsRepeatinGroup +func (m NoContAmtsRepeatingGroup) Get(i int) NoContAmts { + return NoContAmts{m.RepeatingGroup.Get(i)} +} + +//NoLegs is a repeating group element, Tag 555 +type NoLegs struct { + quickfix.Group +} + +//SetLegSymbol sets LegSymbol, Tag 600 +func (m NoLegs) SetLegSymbol(v string) { + m.Set(field.NewLegSymbol(v)) +} + +//SetLegSymbolSfx sets LegSymbolSfx, Tag 601 +func (m NoLegs) SetLegSymbolSfx(v string) { + m.Set(field.NewLegSymbolSfx(v)) +} + +//SetLegSecurityID sets LegSecurityID, Tag 602 +func (m NoLegs) SetLegSecurityID(v string) { + m.Set(field.NewLegSecurityID(v)) +} + +//SetLegSecurityIDSource sets LegSecurityIDSource, Tag 603 +func (m NoLegs) SetLegSecurityIDSource(v string) { + m.Set(field.NewLegSecurityIDSource(v)) +} + +//SetNoLegSecurityAltID sets NoLegSecurityAltID, Tag 604 +func (m NoLegs) SetNoLegSecurityAltID(f NoLegSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetLegProduct sets LegProduct, Tag 607 +func (m NoLegs) SetLegProduct(v int) { + m.Set(field.NewLegProduct(v)) +} + +//SetLegCFICode sets LegCFICode, Tag 608 +func (m NoLegs) SetLegCFICode(v string) { + m.Set(field.NewLegCFICode(v)) +} + +//SetLegSecurityType sets LegSecurityType, Tag 609 +func (m NoLegs) SetLegSecurityType(v string) { + m.Set(field.NewLegSecurityType(v)) +} + +//SetLegMaturityMonthYear sets LegMaturityMonthYear, Tag 610 +func (m NoLegs) SetLegMaturityMonthYear(v string) { + m.Set(field.NewLegMaturityMonthYear(v)) +} + +//SetLegMaturityDate sets LegMaturityDate, Tag 611 +func (m NoLegs) SetLegMaturityDate(v string) { + m.Set(field.NewLegMaturityDate(v)) +} + +//SetLegCouponPaymentDate sets LegCouponPaymentDate, Tag 248 +func (m NoLegs) SetLegCouponPaymentDate(v string) { + m.Set(field.NewLegCouponPaymentDate(v)) +} + +//SetLegIssueDate sets LegIssueDate, Tag 249 +func (m NoLegs) SetLegIssueDate(v string) { + m.Set(field.NewLegIssueDate(v)) +} + +//SetLegRepoCollateralSecurityType sets LegRepoCollateralSecurityType, Tag 250 +func (m NoLegs) SetLegRepoCollateralSecurityType(v int) { + m.Set(field.NewLegRepoCollateralSecurityType(v)) +} + +//SetLegRepurchaseTerm sets LegRepurchaseTerm, Tag 251 +func (m NoLegs) SetLegRepurchaseTerm(v int) { + m.Set(field.NewLegRepurchaseTerm(v)) +} + +//SetLegRepurchaseRate sets LegRepurchaseRate, Tag 252 +func (m NoLegs) SetLegRepurchaseRate(v float64) { + m.Set(field.NewLegRepurchaseRate(v)) +} + +//SetLegFactor sets LegFactor, Tag 253 +func (m NoLegs) SetLegFactor(v float64) { + m.Set(field.NewLegFactor(v)) +} + +//SetLegCreditRating sets LegCreditRating, Tag 257 +func (m NoLegs) SetLegCreditRating(v string) { + m.Set(field.NewLegCreditRating(v)) +} + +//SetLegInstrRegistry sets LegInstrRegistry, Tag 599 +func (m NoLegs) SetLegInstrRegistry(v string) { + m.Set(field.NewLegInstrRegistry(v)) +} + +//SetLegCountryOfIssue sets LegCountryOfIssue, Tag 596 +func (m NoLegs) SetLegCountryOfIssue(v string) { + m.Set(field.NewLegCountryOfIssue(v)) +} + +//SetLegStateOrProvinceOfIssue sets LegStateOrProvinceOfIssue, Tag 597 +func (m NoLegs) SetLegStateOrProvinceOfIssue(v string) { + m.Set(field.NewLegStateOrProvinceOfIssue(v)) +} + +//SetLegLocaleOfIssue sets LegLocaleOfIssue, Tag 598 +func (m NoLegs) SetLegLocaleOfIssue(v string) { + m.Set(field.NewLegLocaleOfIssue(v)) +} + +//SetLegRedemptionDate sets LegRedemptionDate, Tag 254 +func (m NoLegs) SetLegRedemptionDate(v string) { + m.Set(field.NewLegRedemptionDate(v)) +} + +//SetLegStrikePrice sets LegStrikePrice, Tag 612 +func (m NoLegs) SetLegStrikePrice(v float64) { + m.Set(field.NewLegStrikePrice(v)) +} + +//SetLegOptAttribute sets LegOptAttribute, Tag 613 +func (m NoLegs) SetLegOptAttribute(v string) { + m.Set(field.NewLegOptAttribute(v)) +} + +//SetLegContractMultiplier sets LegContractMultiplier, Tag 614 +func (m NoLegs) SetLegContractMultiplier(v float64) { + m.Set(field.NewLegContractMultiplier(v)) +} + +//SetLegCouponRate sets LegCouponRate, Tag 615 +func (m NoLegs) SetLegCouponRate(v float64) { + m.Set(field.NewLegCouponRate(v)) +} + +//SetLegSecurityExchange sets LegSecurityExchange, Tag 616 +func (m NoLegs) SetLegSecurityExchange(v string) { + m.Set(field.NewLegSecurityExchange(v)) +} + +//SetLegIssuer sets LegIssuer, Tag 617 +func (m NoLegs) SetLegIssuer(v string) { + m.Set(field.NewLegIssuer(v)) +} + +//SetEncodedLegIssuerLen sets EncodedLegIssuerLen, Tag 618 +func (m NoLegs) SetEncodedLegIssuerLen(v int) { + m.Set(field.NewEncodedLegIssuerLen(v)) +} + +//SetEncodedLegIssuer sets EncodedLegIssuer, Tag 619 +func (m NoLegs) SetEncodedLegIssuer(v string) { + m.Set(field.NewEncodedLegIssuer(v)) +} + +//SetLegSecurityDesc sets LegSecurityDesc, Tag 620 +func (m NoLegs) SetLegSecurityDesc(v string) { + m.Set(field.NewLegSecurityDesc(v)) +} + +//SetEncodedLegSecurityDescLen sets EncodedLegSecurityDescLen, Tag 621 +func (m NoLegs) SetEncodedLegSecurityDescLen(v int) { + m.Set(field.NewEncodedLegSecurityDescLen(v)) +} + +//SetEncodedLegSecurityDesc sets EncodedLegSecurityDesc, Tag 622 +func (m NoLegs) SetEncodedLegSecurityDesc(v string) { + m.Set(field.NewEncodedLegSecurityDesc(v)) +} + +//SetLegRatioQty sets LegRatioQty, Tag 623 +func (m NoLegs) SetLegRatioQty(v float64) { + m.Set(field.NewLegRatioQty(v)) +} + +//SetLegSide sets LegSide, Tag 624 +func (m NoLegs) SetLegSide(v string) { + m.Set(field.NewLegSide(v)) +} + +//SetLegPositionEffect sets LegPositionEffect, Tag 564 +func (m NoLegs) SetLegPositionEffect(v string) { + m.Set(field.NewLegPositionEffect(v)) +} + +//SetLegCoveredOrUncovered sets LegCoveredOrUncovered, Tag 565 +func (m NoLegs) SetLegCoveredOrUncovered(v int) { + m.Set(field.NewLegCoveredOrUncovered(v)) +} + +//SetNoNestedPartyIDs sets NoNestedPartyIDs, Tag 539 +func (m NoLegs) SetNoNestedPartyIDs(f NoNestedPartyIDsRepeatingGroup) { + m.SetGroup(f) +} + +//SetLegRefID sets LegRefID, Tag 654 +func (m NoLegs) SetLegRefID(v string) { + m.Set(field.NewLegRefID(v)) +} + +//SetLegPrice sets LegPrice, Tag 566 +func (m NoLegs) SetLegPrice(v float64) { + m.Set(field.NewLegPrice(v)) +} + +//SetLegSettlmntTyp sets LegSettlmntTyp, Tag 587 +func (m NoLegs) SetLegSettlmntTyp(v string) { + m.Set(field.NewLegSettlmntTyp(v)) +} + +//SetLegFutSettDate sets LegFutSettDate, Tag 588 +func (m NoLegs) SetLegFutSettDate(v string) { + m.Set(field.NewLegFutSettDate(v)) +} + +//SetLegLastPx sets LegLastPx, Tag 637 +func (m NoLegs) SetLegLastPx(v float64) { + m.Set(field.NewLegLastPx(v)) +} + +//GetLegSymbol gets LegSymbol, Tag 600 +func (m NoLegs) GetLegSymbol() (f field.LegSymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSymbolSfx gets LegSymbolSfx, Tag 601 +func (m NoLegs) GetLegSymbolSfx() (f field.LegSymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityID gets LegSecurityID, Tag 602 +func (m NoLegs) GetLegSecurityID() (f field.LegSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityIDSource gets LegSecurityIDSource, Tag 603 +func (m NoLegs) GetLegSecurityIDSource() (f field.LegSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoLegSecurityAltID gets NoLegSecurityAltID, Tag 604 +func (m NoLegs) GetNoLegSecurityAltID() (NoLegSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoLegSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetLegProduct gets LegProduct, Tag 607 +func (m NoLegs) GetLegProduct() (f field.LegProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCFICode gets LegCFICode, Tag 608 +func (m NoLegs) GetLegCFICode() (f field.LegCFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityType gets LegSecurityType, Tag 609 +func (m NoLegs) GetLegSecurityType() (f field.LegSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegMaturityMonthYear gets LegMaturityMonthYear, Tag 610 +func (m NoLegs) GetLegMaturityMonthYear() (f field.LegMaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegMaturityDate gets LegMaturityDate, Tag 611 +func (m NoLegs) GetLegMaturityDate() (f field.LegMaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCouponPaymentDate gets LegCouponPaymentDate, Tag 248 +func (m NoLegs) GetLegCouponPaymentDate() (f field.LegCouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegIssueDate gets LegIssueDate, Tag 249 +func (m NoLegs) GetLegIssueDate() (f field.LegIssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRepoCollateralSecurityType gets LegRepoCollateralSecurityType, Tag 250 +func (m NoLegs) GetLegRepoCollateralSecurityType() (f field.LegRepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRepurchaseTerm gets LegRepurchaseTerm, Tag 251 +func (m NoLegs) GetLegRepurchaseTerm() (f field.LegRepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRepurchaseRate gets LegRepurchaseRate, Tag 252 +func (m NoLegs) GetLegRepurchaseRate() (f field.LegRepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegFactor gets LegFactor, Tag 253 +func (m NoLegs) GetLegFactor() (f field.LegFactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCreditRating gets LegCreditRating, Tag 257 +func (m NoLegs) GetLegCreditRating() (f field.LegCreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegInstrRegistry gets LegInstrRegistry, Tag 599 +func (m NoLegs) GetLegInstrRegistry() (f field.LegInstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCountryOfIssue gets LegCountryOfIssue, Tag 596 +func (m NoLegs) GetLegCountryOfIssue() (f field.LegCountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegStateOrProvinceOfIssue gets LegStateOrProvinceOfIssue, Tag 597 +func (m NoLegs) GetLegStateOrProvinceOfIssue() (f field.LegStateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegLocaleOfIssue gets LegLocaleOfIssue, Tag 598 +func (m NoLegs) GetLegLocaleOfIssue() (f field.LegLocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRedemptionDate gets LegRedemptionDate, Tag 254 +func (m NoLegs) GetLegRedemptionDate() (f field.LegRedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegStrikePrice gets LegStrikePrice, Tag 612 +func (m NoLegs) GetLegStrikePrice() (f field.LegStrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegOptAttribute gets LegOptAttribute, Tag 613 +func (m NoLegs) GetLegOptAttribute() (f field.LegOptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegContractMultiplier gets LegContractMultiplier, Tag 614 +func (m NoLegs) GetLegContractMultiplier() (f field.LegContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCouponRate gets LegCouponRate, Tag 615 +func (m NoLegs) GetLegCouponRate() (f field.LegCouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityExchange gets LegSecurityExchange, Tag 616 +func (m NoLegs) GetLegSecurityExchange() (f field.LegSecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegIssuer gets LegIssuer, Tag 617 +func (m NoLegs) GetLegIssuer() (f field.LegIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegIssuerLen gets EncodedLegIssuerLen, Tag 618 +func (m NoLegs) GetEncodedLegIssuerLen() (f field.EncodedLegIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegIssuer gets EncodedLegIssuer, Tag 619 +func (m NoLegs) GetEncodedLegIssuer() (f field.EncodedLegIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityDesc gets LegSecurityDesc, Tag 620 +func (m NoLegs) GetLegSecurityDesc() (f field.LegSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegSecurityDescLen gets EncodedLegSecurityDescLen, Tag 621 +func (m NoLegs) GetEncodedLegSecurityDescLen() (f field.EncodedLegSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegSecurityDesc gets EncodedLegSecurityDesc, Tag 622 +func (m NoLegs) GetEncodedLegSecurityDesc() (f field.EncodedLegSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRatioQty gets LegRatioQty, Tag 623 +func (m NoLegs) GetLegRatioQty() (f field.LegRatioQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSide gets LegSide, Tag 624 +func (m NoLegs) GetLegSide() (f field.LegSideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegPositionEffect gets LegPositionEffect, Tag 564 +func (m NoLegs) GetLegPositionEffect() (f field.LegPositionEffectField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCoveredOrUncovered gets LegCoveredOrUncovered, Tag 565 +func (m NoLegs) GetLegCoveredOrUncovered() (f field.LegCoveredOrUncoveredField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoNestedPartyIDs gets NoNestedPartyIDs, Tag 539 +func (m NoLegs) GetNoNestedPartyIDs() (NoNestedPartyIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoNestedPartyIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetLegRefID gets LegRefID, Tag 654 +func (m NoLegs) GetLegRefID() (f field.LegRefIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegPrice gets LegPrice, Tag 566 +func (m NoLegs) GetLegPrice() (f field.LegPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSettlmntTyp gets LegSettlmntTyp, Tag 587 +func (m NoLegs) GetLegSettlmntTyp() (f field.LegSettlmntTypField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegFutSettDate gets LegFutSettDate, Tag 588 +func (m NoLegs) GetLegFutSettDate() (f field.LegFutSettDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegLastPx gets LegLastPx, Tag 637 +func (m NoLegs) GetLegLastPx() (f field.LegLastPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasLegSymbol returns true if LegSymbol is present, Tag 600 +func (m NoLegs) HasLegSymbol() bool { + return m.Has(tag.LegSymbol) +} + +//HasLegSymbolSfx returns true if LegSymbolSfx is present, Tag 601 +func (m NoLegs) HasLegSymbolSfx() bool { + return m.Has(tag.LegSymbolSfx) +} + +//HasLegSecurityID returns true if LegSecurityID is present, Tag 602 +func (m NoLegs) HasLegSecurityID() bool { + return m.Has(tag.LegSecurityID) +} + +//HasLegSecurityIDSource returns true if LegSecurityIDSource is present, Tag 603 +func (m NoLegs) HasLegSecurityIDSource() bool { + return m.Has(tag.LegSecurityIDSource) +} + +//HasNoLegSecurityAltID returns true if NoLegSecurityAltID is present, Tag 604 +func (m NoLegs) HasNoLegSecurityAltID() bool { + return m.Has(tag.NoLegSecurityAltID) +} + +//HasLegProduct returns true if LegProduct is present, Tag 607 +func (m NoLegs) HasLegProduct() bool { + return m.Has(tag.LegProduct) +} + +//HasLegCFICode returns true if LegCFICode is present, Tag 608 +func (m NoLegs) HasLegCFICode() bool { + return m.Has(tag.LegCFICode) +} + +//HasLegSecurityType returns true if LegSecurityType is present, Tag 609 +func (m NoLegs) HasLegSecurityType() bool { + return m.Has(tag.LegSecurityType) +} + +//HasLegMaturityMonthYear returns true if LegMaturityMonthYear is present, Tag 610 +func (m NoLegs) HasLegMaturityMonthYear() bool { + return m.Has(tag.LegMaturityMonthYear) +} + +//HasLegMaturityDate returns true if LegMaturityDate is present, Tag 611 +func (m NoLegs) HasLegMaturityDate() bool { + return m.Has(tag.LegMaturityDate) +} + +//HasLegCouponPaymentDate returns true if LegCouponPaymentDate is present, Tag 248 +func (m NoLegs) HasLegCouponPaymentDate() bool { + return m.Has(tag.LegCouponPaymentDate) +} + +//HasLegIssueDate returns true if LegIssueDate is present, Tag 249 +func (m NoLegs) HasLegIssueDate() bool { + return m.Has(tag.LegIssueDate) +} + +//HasLegRepoCollateralSecurityType returns true if LegRepoCollateralSecurityType is present, Tag 250 +func (m NoLegs) HasLegRepoCollateralSecurityType() bool { + return m.Has(tag.LegRepoCollateralSecurityType) +} + +//HasLegRepurchaseTerm returns true if LegRepurchaseTerm is present, Tag 251 +func (m NoLegs) HasLegRepurchaseTerm() bool { + return m.Has(tag.LegRepurchaseTerm) +} + +//HasLegRepurchaseRate returns true if LegRepurchaseRate is present, Tag 252 +func (m NoLegs) HasLegRepurchaseRate() bool { + return m.Has(tag.LegRepurchaseRate) +} + +//HasLegFactor returns true if LegFactor is present, Tag 253 +func (m NoLegs) HasLegFactor() bool { + return m.Has(tag.LegFactor) +} + +//HasLegCreditRating returns true if LegCreditRating is present, Tag 257 +func (m NoLegs) HasLegCreditRating() bool { + return m.Has(tag.LegCreditRating) +} + +//HasLegInstrRegistry returns true if LegInstrRegistry is present, Tag 599 +func (m NoLegs) HasLegInstrRegistry() bool { + return m.Has(tag.LegInstrRegistry) +} + +//HasLegCountryOfIssue returns true if LegCountryOfIssue is present, Tag 596 +func (m NoLegs) HasLegCountryOfIssue() bool { + return m.Has(tag.LegCountryOfIssue) +} + +//HasLegStateOrProvinceOfIssue returns true if LegStateOrProvinceOfIssue is present, Tag 597 +func (m NoLegs) HasLegStateOrProvinceOfIssue() bool { + return m.Has(tag.LegStateOrProvinceOfIssue) +} + +//HasLegLocaleOfIssue returns true if LegLocaleOfIssue is present, Tag 598 +func (m NoLegs) HasLegLocaleOfIssue() bool { + return m.Has(tag.LegLocaleOfIssue) +} + +//HasLegRedemptionDate returns true if LegRedemptionDate is present, Tag 254 +func (m NoLegs) HasLegRedemptionDate() bool { + return m.Has(tag.LegRedemptionDate) +} + +//HasLegStrikePrice returns true if LegStrikePrice is present, Tag 612 +func (m NoLegs) HasLegStrikePrice() bool { + return m.Has(tag.LegStrikePrice) +} + +//HasLegOptAttribute returns true if LegOptAttribute is present, Tag 613 +func (m NoLegs) HasLegOptAttribute() bool { + return m.Has(tag.LegOptAttribute) +} + +//HasLegContractMultiplier returns true if LegContractMultiplier is present, Tag 614 +func (m NoLegs) HasLegContractMultiplier() bool { + return m.Has(tag.LegContractMultiplier) +} + +//HasLegCouponRate returns true if LegCouponRate is present, Tag 615 +func (m NoLegs) HasLegCouponRate() bool { + return m.Has(tag.LegCouponRate) +} + +//HasLegSecurityExchange returns true if LegSecurityExchange is present, Tag 616 +func (m NoLegs) HasLegSecurityExchange() bool { + return m.Has(tag.LegSecurityExchange) +} + +//HasLegIssuer returns true if LegIssuer is present, Tag 617 +func (m NoLegs) HasLegIssuer() bool { + return m.Has(tag.LegIssuer) +} + +//HasEncodedLegIssuerLen returns true if EncodedLegIssuerLen is present, Tag 618 +func (m NoLegs) HasEncodedLegIssuerLen() bool { + return m.Has(tag.EncodedLegIssuerLen) +} + +//HasEncodedLegIssuer returns true if EncodedLegIssuer is present, Tag 619 +func (m NoLegs) HasEncodedLegIssuer() bool { + return m.Has(tag.EncodedLegIssuer) +} + +//HasLegSecurityDesc returns true if LegSecurityDesc is present, Tag 620 +func (m NoLegs) HasLegSecurityDesc() bool { + return m.Has(tag.LegSecurityDesc) +} + +//HasEncodedLegSecurityDescLen returns true if EncodedLegSecurityDescLen is present, Tag 621 +func (m NoLegs) HasEncodedLegSecurityDescLen() bool { + return m.Has(tag.EncodedLegSecurityDescLen) +} + +//HasEncodedLegSecurityDesc returns true if EncodedLegSecurityDesc is present, Tag 622 +func (m NoLegs) HasEncodedLegSecurityDesc() bool { + return m.Has(tag.EncodedLegSecurityDesc) +} + +//HasLegRatioQty returns true if LegRatioQty is present, Tag 623 +func (m NoLegs) HasLegRatioQty() bool { + return m.Has(tag.LegRatioQty) +} + +//HasLegSide returns true if LegSide is present, Tag 624 +func (m NoLegs) HasLegSide() bool { + return m.Has(tag.LegSide) +} + +//HasLegPositionEffect returns true if LegPositionEffect is present, Tag 564 +func (m NoLegs) HasLegPositionEffect() bool { + return m.Has(tag.LegPositionEffect) +} + +//HasLegCoveredOrUncovered returns true if LegCoveredOrUncovered is present, Tag 565 +func (m NoLegs) HasLegCoveredOrUncovered() bool { + return m.Has(tag.LegCoveredOrUncovered) +} + +//HasNoNestedPartyIDs returns true if NoNestedPartyIDs is present, Tag 539 +func (m NoLegs) HasNoNestedPartyIDs() bool { + return m.Has(tag.NoNestedPartyIDs) +} + +//HasLegRefID returns true if LegRefID is present, Tag 654 +func (m NoLegs) HasLegRefID() bool { + return m.Has(tag.LegRefID) +} + +//HasLegPrice returns true if LegPrice is present, Tag 566 +func (m NoLegs) HasLegPrice() bool { + return m.Has(tag.LegPrice) +} + +//HasLegSettlmntTyp returns true if LegSettlmntTyp is present, Tag 587 +func (m NoLegs) HasLegSettlmntTyp() bool { + return m.Has(tag.LegSettlmntTyp) +} + +//HasLegFutSettDate returns true if LegFutSettDate is present, Tag 588 +func (m NoLegs) HasLegFutSettDate() bool { + return m.Has(tag.LegFutSettDate) +} + +//HasLegLastPx returns true if LegLastPx is present, Tag 637 +func (m NoLegs) HasLegLastPx() bool { + return m.Has(tag.LegLastPx) +} + +//NoLegSecurityAltID is a repeating group element, Tag 604 +type NoLegSecurityAltID struct { + quickfix.Group +} + +//SetLegSecurityAltID sets LegSecurityAltID, Tag 605 +func (m NoLegSecurityAltID) SetLegSecurityAltID(v string) { + m.Set(field.NewLegSecurityAltID(v)) +} + +//SetLegSecurityAltIDSource sets LegSecurityAltIDSource, Tag 606 +func (m NoLegSecurityAltID) SetLegSecurityAltIDSource(v string) { + m.Set(field.NewLegSecurityAltIDSource(v)) +} + +//GetLegSecurityAltID gets LegSecurityAltID, Tag 605 +func (m NoLegSecurityAltID) GetLegSecurityAltID() (f field.LegSecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityAltIDSource gets LegSecurityAltIDSource, Tag 606 +func (m NoLegSecurityAltID) GetLegSecurityAltIDSource() (f field.LegSecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasLegSecurityAltID returns true if LegSecurityAltID is present, Tag 605 +func (m NoLegSecurityAltID) HasLegSecurityAltID() bool { + return m.Has(tag.LegSecurityAltID) +} + +//HasLegSecurityAltIDSource returns true if LegSecurityAltIDSource is present, Tag 606 +func (m NoLegSecurityAltID) HasLegSecurityAltIDSource() bool { + return m.Has(tag.LegSecurityAltIDSource) +} + +//NoLegSecurityAltIDRepeatingGroup is a repeating group, Tag 604 +type NoLegSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoLegSecurityAltIDRepeatingGroup returns an initialized, NoLegSecurityAltIDRepeatingGroup +func NewNoLegSecurityAltIDRepeatingGroup() NoLegSecurityAltIDRepeatingGroup { + return NoLegSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoLegSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.LegSecurityAltID), quickfix.GroupElement(tag.LegSecurityAltIDSource)})} +} + +//Add create and append a new NoLegSecurityAltID to this group +func (m NoLegSecurityAltIDRepeatingGroup) Add() NoLegSecurityAltID { + g := m.RepeatingGroup.Add() + return NoLegSecurityAltID{g} +} + +//Get returns the ith NoLegSecurityAltID in the NoLegSecurityAltIDRepeatinGroup +func (m NoLegSecurityAltIDRepeatingGroup) Get(i int) NoLegSecurityAltID { + return NoLegSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoNestedPartyIDs is a repeating group element, Tag 539 +type NoNestedPartyIDs struct { + quickfix.Group +} + +//SetNestedPartyID sets NestedPartyID, Tag 524 +func (m NoNestedPartyIDs) SetNestedPartyID(v string) { + m.Set(field.NewNestedPartyID(v)) +} + +//SetNestedPartyIDSource sets NestedPartyIDSource, Tag 525 +func (m NoNestedPartyIDs) SetNestedPartyIDSource(v string) { + m.Set(field.NewNestedPartyIDSource(v)) +} + +//SetNestedPartyRole sets NestedPartyRole, Tag 538 +func (m NoNestedPartyIDs) SetNestedPartyRole(v int) { + m.Set(field.NewNestedPartyRole(v)) +} + +//SetNestedPartySubID sets NestedPartySubID, Tag 545 +func (m NoNestedPartyIDs) SetNestedPartySubID(v string) { + m.Set(field.NewNestedPartySubID(v)) +} + +//GetNestedPartyID gets NestedPartyID, Tag 524 +func (m NoNestedPartyIDs) GetNestedPartyID() (f field.NestedPartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNestedPartyIDSource gets NestedPartyIDSource, Tag 525 +func (m NoNestedPartyIDs) GetNestedPartyIDSource() (f field.NestedPartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNestedPartyRole gets NestedPartyRole, Tag 538 +func (m NoNestedPartyIDs) GetNestedPartyRole() (f field.NestedPartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNestedPartySubID gets NestedPartySubID, Tag 545 +func (m NoNestedPartyIDs) GetNestedPartySubID() (f field.NestedPartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasNestedPartyID returns true if NestedPartyID is present, Tag 524 +func (m NoNestedPartyIDs) HasNestedPartyID() bool { + return m.Has(tag.NestedPartyID) +} + +//HasNestedPartyIDSource returns true if NestedPartyIDSource is present, Tag 525 +func (m NoNestedPartyIDs) HasNestedPartyIDSource() bool { + return m.Has(tag.NestedPartyIDSource) +} + +//HasNestedPartyRole returns true if NestedPartyRole is present, Tag 538 +func (m NoNestedPartyIDs) HasNestedPartyRole() bool { + return m.Has(tag.NestedPartyRole) +} + +//HasNestedPartySubID returns true if NestedPartySubID is present, Tag 545 +func (m NoNestedPartyIDs) HasNestedPartySubID() bool { + return m.Has(tag.NestedPartySubID) +} + +//NoNestedPartyIDsRepeatingGroup is a repeating group, Tag 539 +type NoNestedPartyIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoNestedPartyIDsRepeatingGroup returns an initialized, NoNestedPartyIDsRepeatingGroup +func NewNoNestedPartyIDsRepeatingGroup() NoNestedPartyIDsRepeatingGroup { + return NoNestedPartyIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoNestedPartyIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.NestedPartyID), quickfix.GroupElement(tag.NestedPartyIDSource), quickfix.GroupElement(tag.NestedPartyRole), quickfix.GroupElement(tag.NestedPartySubID)})} +} + +//Add create and append a new NoNestedPartyIDs to this group +func (m NoNestedPartyIDsRepeatingGroup) Add() NoNestedPartyIDs { + g := m.RepeatingGroup.Add() + return NoNestedPartyIDs{g} +} + +//Get returns the ith NoNestedPartyIDs in the NoNestedPartyIDsRepeatinGroup +func (m NoNestedPartyIDsRepeatingGroup) Get(i int) NoNestedPartyIDs { + return NoNestedPartyIDs{m.RepeatingGroup.Get(i)} +} + +//NoLegsRepeatingGroup is a repeating group, Tag 555 +type NoLegsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoLegsRepeatingGroup returns an initialized, NoLegsRepeatingGroup +func NewNoLegsRepeatingGroup() NoLegsRepeatingGroup { + return NoLegsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoLegs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.LegSymbol), quickfix.GroupElement(tag.LegSymbolSfx), quickfix.GroupElement(tag.LegSecurityID), quickfix.GroupElement(tag.LegSecurityIDSource), NewNoLegSecurityAltIDRepeatingGroup(), quickfix.GroupElement(tag.LegProduct), quickfix.GroupElement(tag.LegCFICode), quickfix.GroupElement(tag.LegSecurityType), quickfix.GroupElement(tag.LegMaturityMonthYear), quickfix.GroupElement(tag.LegMaturityDate), quickfix.GroupElement(tag.LegCouponPaymentDate), quickfix.GroupElement(tag.LegIssueDate), quickfix.GroupElement(tag.LegRepoCollateralSecurityType), quickfix.GroupElement(tag.LegRepurchaseTerm), quickfix.GroupElement(tag.LegRepurchaseRate), quickfix.GroupElement(tag.LegFactor), quickfix.GroupElement(tag.LegCreditRating), quickfix.GroupElement(tag.LegInstrRegistry), quickfix.GroupElement(tag.LegCountryOfIssue), quickfix.GroupElement(tag.LegStateOrProvinceOfIssue), quickfix.GroupElement(tag.LegLocaleOfIssue), quickfix.GroupElement(tag.LegRedemptionDate), quickfix.GroupElement(tag.LegStrikePrice), quickfix.GroupElement(tag.LegOptAttribute), quickfix.GroupElement(tag.LegContractMultiplier), quickfix.GroupElement(tag.LegCouponRate), quickfix.GroupElement(tag.LegSecurityExchange), quickfix.GroupElement(tag.LegIssuer), quickfix.GroupElement(tag.EncodedLegIssuerLen), quickfix.GroupElement(tag.EncodedLegIssuer), quickfix.GroupElement(tag.LegSecurityDesc), quickfix.GroupElement(tag.EncodedLegSecurityDescLen), quickfix.GroupElement(tag.EncodedLegSecurityDesc), quickfix.GroupElement(tag.LegRatioQty), quickfix.GroupElement(tag.LegSide), quickfix.GroupElement(tag.LegPositionEffect), quickfix.GroupElement(tag.LegCoveredOrUncovered), NewNoNestedPartyIDsRepeatingGroup(), quickfix.GroupElement(tag.LegRefID), quickfix.GroupElement(tag.LegPrice), quickfix.GroupElement(tag.LegSettlmntTyp), quickfix.GroupElement(tag.LegFutSettDate), quickfix.GroupElement(tag.LegLastPx)})} +} + +//Add create and append a new NoLegs to this group +func (m NoLegsRepeatingGroup) Add() NoLegs { + g := m.RepeatingGroup.Add() + return NoLegs{g} +} + +//Get returns the ith NoLegs in the NoLegsRepeatinGroup +func (m NoLegsRepeatingGroup) Get(i int) NoLegs { + return NoLegs{m.RepeatingGroup.Get(i)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix43/header.generated.go b/vendor/github.com/quickfixgo/quickfix/fix43/header.generated.go new file mode 100644 index 0000000..6c2f1d2 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix43/header.generated.go @@ -0,0 +1,546 @@ +package fix43 + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/tag" +) + +//Header is the fix43 Header type +type Header struct { + quickfix.Header +} + +//NewHeader returns a new, initialized Header instance +func NewHeader() (h Header) { + h.Init() + h.SetBeginString("FIX.4.3") + return +} + +//SetBeginString sets BeginString, Tag 8 +func (h Header) SetBeginString(v string) { + h.Set(field.NewBeginString(v)) +} + +//SetBodyLength sets BodyLength, Tag 9 +func (h Header) SetBodyLength(v int) { + h.Set(field.NewBodyLength(v)) +} + +//SetMsgSeqNum sets MsgSeqNum, Tag 34 +func (h Header) SetMsgSeqNum(v int) { + h.Set(field.NewMsgSeqNum(v)) +} + +//SetMsgType sets MsgType, Tag 35 +func (h Header) SetMsgType(v string) { + h.Set(field.NewMsgType(v)) +} + +//SetPossDupFlag sets PossDupFlag, Tag 43 +func (h Header) SetPossDupFlag(v bool) { + h.Set(field.NewPossDupFlag(v)) +} + +//SetSenderCompID sets SenderCompID, Tag 49 +func (h Header) SetSenderCompID(v string) { + h.Set(field.NewSenderCompID(v)) +} + +//SetSenderSubID sets SenderSubID, Tag 50 +func (h Header) SetSenderSubID(v string) { + h.Set(field.NewSenderSubID(v)) +} + +//SetSendingTime sets SendingTime, Tag 52 +func (h Header) SetSendingTime(v time.Time) { + h.Set(field.NewSendingTime(v)) +} + +//SetTargetCompID sets TargetCompID, Tag 56 +func (h Header) SetTargetCompID(v string) { + h.Set(field.NewTargetCompID(v)) +} + +//SetTargetSubID sets TargetSubID, Tag 57 +func (h Header) SetTargetSubID(v string) { + h.Set(field.NewTargetSubID(v)) +} + +//SetSecureDataLen sets SecureDataLen, Tag 90 +func (h Header) SetSecureDataLen(v int) { + h.Set(field.NewSecureDataLen(v)) +} + +//SetSecureData sets SecureData, Tag 91 +func (h Header) SetSecureData(v string) { + h.Set(field.NewSecureData(v)) +} + +//SetPossResend sets PossResend, Tag 97 +func (h Header) SetPossResend(v bool) { + h.Set(field.NewPossResend(v)) +} + +//SetOnBehalfOfCompID sets OnBehalfOfCompID, Tag 115 +func (h Header) SetOnBehalfOfCompID(v string) { + h.Set(field.NewOnBehalfOfCompID(v)) +} + +//SetOnBehalfOfSubID sets OnBehalfOfSubID, Tag 116 +func (h Header) SetOnBehalfOfSubID(v string) { + h.Set(field.NewOnBehalfOfSubID(v)) +} + +//SetOrigSendingTime sets OrigSendingTime, Tag 122 +func (h Header) SetOrigSendingTime(v time.Time) { + h.Set(field.NewOrigSendingTime(v)) +} + +//SetDeliverToCompID sets DeliverToCompID, Tag 128 +func (h Header) SetDeliverToCompID(v string) { + h.Set(field.NewDeliverToCompID(v)) +} + +//SetDeliverToSubID sets DeliverToSubID, Tag 129 +func (h Header) SetDeliverToSubID(v string) { + h.Set(field.NewDeliverToSubID(v)) +} + +//SetSenderLocationID sets SenderLocationID, Tag 142 +func (h Header) SetSenderLocationID(v string) { + h.Set(field.NewSenderLocationID(v)) +} + +//SetTargetLocationID sets TargetLocationID, Tag 143 +func (h Header) SetTargetLocationID(v string) { + h.Set(field.NewTargetLocationID(v)) +} + +//SetOnBehalfOfLocationID sets OnBehalfOfLocationID, Tag 144 +func (h Header) SetOnBehalfOfLocationID(v string) { + h.Set(field.NewOnBehalfOfLocationID(v)) +} + +//SetDeliverToLocationID sets DeliverToLocationID, Tag 145 +func (h Header) SetDeliverToLocationID(v string) { + h.Set(field.NewDeliverToLocationID(v)) +} + +//SetXmlDataLen sets XmlDataLen, Tag 212 +func (h Header) SetXmlDataLen(v int) { + h.Set(field.NewXmlDataLen(v)) +} + +//SetXmlData sets XmlData, Tag 213 +func (h Header) SetXmlData(v string) { + h.Set(field.NewXmlData(v)) +} + +//SetMessageEncoding sets MessageEncoding, Tag 347 +func (h Header) SetMessageEncoding(v string) { + h.Set(field.NewMessageEncoding(v)) +} + +//SetLastMsgSeqNumProcessed sets LastMsgSeqNumProcessed, Tag 369 +func (h Header) SetLastMsgSeqNumProcessed(v int) { + h.Set(field.NewLastMsgSeqNumProcessed(v)) +} + +//SetOnBehalfOfSendingTime sets OnBehalfOfSendingTime, Tag 370 +func (h Header) SetOnBehalfOfSendingTime(v time.Time) { + h.Set(field.NewOnBehalfOfSendingTime(v)) +} + +//SetNoHops sets NoHops, Tag 627 +func (h Header) SetNoHops(f NoHopsRepeatingGroup) { + h.SetGroup(f) +} + +//GetBeginString gets BeginString, Tag 8 +func (h Header) GetBeginString() (f field.BeginStringField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetBodyLength gets BodyLength, Tag 9 +func (h Header) GetBodyLength() (f field.BodyLengthField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetMsgSeqNum gets MsgSeqNum, Tag 34 +func (h Header) GetMsgSeqNum() (f field.MsgSeqNumField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetMsgType gets MsgType, Tag 35 +func (h Header) GetMsgType() (f field.MsgTypeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetPossDupFlag gets PossDupFlag, Tag 43 +func (h Header) GetPossDupFlag() (f field.PossDupFlagField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSenderCompID gets SenderCompID, Tag 49 +func (h Header) GetSenderCompID() (f field.SenderCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSenderSubID gets SenderSubID, Tag 50 +func (h Header) GetSenderSubID() (f field.SenderSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSendingTime gets SendingTime, Tag 52 +func (h Header) GetSendingTime() (f field.SendingTimeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetTargetCompID gets TargetCompID, Tag 56 +func (h Header) GetTargetCompID() (f field.TargetCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetTargetSubID gets TargetSubID, Tag 57 +func (h Header) GetTargetSubID() (f field.TargetSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSecureDataLen gets SecureDataLen, Tag 90 +func (h Header) GetSecureDataLen() (f field.SecureDataLenField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSecureData gets SecureData, Tag 91 +func (h Header) GetSecureData() (f field.SecureDataField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetPossResend gets PossResend, Tag 97 +func (h Header) GetPossResend() (f field.PossResendField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOnBehalfOfCompID gets OnBehalfOfCompID, Tag 115 +func (h Header) GetOnBehalfOfCompID() (f field.OnBehalfOfCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOnBehalfOfSubID gets OnBehalfOfSubID, Tag 116 +func (h Header) GetOnBehalfOfSubID() (f field.OnBehalfOfSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOrigSendingTime gets OrigSendingTime, Tag 122 +func (h Header) GetOrigSendingTime() (f field.OrigSendingTimeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetDeliverToCompID gets DeliverToCompID, Tag 128 +func (h Header) GetDeliverToCompID() (f field.DeliverToCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetDeliverToSubID gets DeliverToSubID, Tag 129 +func (h Header) GetDeliverToSubID() (f field.DeliverToSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSenderLocationID gets SenderLocationID, Tag 142 +func (h Header) GetSenderLocationID() (f field.SenderLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetTargetLocationID gets TargetLocationID, Tag 143 +func (h Header) GetTargetLocationID() (f field.TargetLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOnBehalfOfLocationID gets OnBehalfOfLocationID, Tag 144 +func (h Header) GetOnBehalfOfLocationID() (f field.OnBehalfOfLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetDeliverToLocationID gets DeliverToLocationID, Tag 145 +func (h Header) GetDeliverToLocationID() (f field.DeliverToLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetXmlDataLen gets XmlDataLen, Tag 212 +func (h Header) GetXmlDataLen() (f field.XmlDataLenField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetXmlData gets XmlData, Tag 213 +func (h Header) GetXmlData() (f field.XmlDataField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetMessageEncoding gets MessageEncoding, Tag 347 +func (h Header) GetMessageEncoding() (f field.MessageEncodingField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetLastMsgSeqNumProcessed gets LastMsgSeqNumProcessed, Tag 369 +func (h Header) GetLastMsgSeqNumProcessed() (f field.LastMsgSeqNumProcessedField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOnBehalfOfSendingTime gets OnBehalfOfSendingTime, Tag 370 +func (h Header) GetOnBehalfOfSendingTime() (f field.OnBehalfOfSendingTimeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetNoHops gets NoHops, Tag 627 +func (h Header) GetNoHops() (NoHopsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoHopsRepeatingGroup() + err := h.GetGroup(f) + return f, err +} + +//HasBeginString returns true if BeginString is present, Tag 8 +func (h Header) HasBeginString() bool { + return h.Has(tag.BeginString) +} + +//HasBodyLength returns true if BodyLength is present, Tag 9 +func (h Header) HasBodyLength() bool { + return h.Has(tag.BodyLength) +} + +//HasMsgSeqNum returns true if MsgSeqNum is present, Tag 34 +func (h Header) HasMsgSeqNum() bool { + return h.Has(tag.MsgSeqNum) +} + +//HasMsgType returns true if MsgType is present, Tag 35 +func (h Header) HasMsgType() bool { + return h.Has(tag.MsgType) +} + +//HasPossDupFlag returns true if PossDupFlag is present, Tag 43 +func (h Header) HasPossDupFlag() bool { + return h.Has(tag.PossDupFlag) +} + +//HasSenderCompID returns true if SenderCompID is present, Tag 49 +func (h Header) HasSenderCompID() bool { + return h.Has(tag.SenderCompID) +} + +//HasSenderSubID returns true if SenderSubID is present, Tag 50 +func (h Header) HasSenderSubID() bool { + return h.Has(tag.SenderSubID) +} + +//HasSendingTime returns true if SendingTime is present, Tag 52 +func (h Header) HasSendingTime() bool { + return h.Has(tag.SendingTime) +} + +//HasTargetCompID returns true if TargetCompID is present, Tag 56 +func (h Header) HasTargetCompID() bool { + return h.Has(tag.TargetCompID) +} + +//HasTargetSubID returns true if TargetSubID is present, Tag 57 +func (h Header) HasTargetSubID() bool { + return h.Has(tag.TargetSubID) +} + +//HasSecureDataLen returns true if SecureDataLen is present, Tag 90 +func (h Header) HasSecureDataLen() bool { + return h.Has(tag.SecureDataLen) +} + +//HasSecureData returns true if SecureData is present, Tag 91 +func (h Header) HasSecureData() bool { + return h.Has(tag.SecureData) +} + +//HasPossResend returns true if PossResend is present, Tag 97 +func (h Header) HasPossResend() bool { + return h.Has(tag.PossResend) +} + +//HasOnBehalfOfCompID returns true if OnBehalfOfCompID is present, Tag 115 +func (h Header) HasOnBehalfOfCompID() bool { + return h.Has(tag.OnBehalfOfCompID) +} + +//HasOnBehalfOfSubID returns true if OnBehalfOfSubID is present, Tag 116 +func (h Header) HasOnBehalfOfSubID() bool { + return h.Has(tag.OnBehalfOfSubID) +} + +//HasOrigSendingTime returns true if OrigSendingTime is present, Tag 122 +func (h Header) HasOrigSendingTime() bool { + return h.Has(tag.OrigSendingTime) +} + +//HasDeliverToCompID returns true if DeliverToCompID is present, Tag 128 +func (h Header) HasDeliverToCompID() bool { + return h.Has(tag.DeliverToCompID) +} + +//HasDeliverToSubID returns true if DeliverToSubID is present, Tag 129 +func (h Header) HasDeliverToSubID() bool { + return h.Has(tag.DeliverToSubID) +} + +//HasSenderLocationID returns true if SenderLocationID is present, Tag 142 +func (h Header) HasSenderLocationID() bool { + return h.Has(tag.SenderLocationID) +} + +//HasTargetLocationID returns true if TargetLocationID is present, Tag 143 +func (h Header) HasTargetLocationID() bool { + return h.Has(tag.TargetLocationID) +} + +//HasOnBehalfOfLocationID returns true if OnBehalfOfLocationID is present, Tag 144 +func (h Header) HasOnBehalfOfLocationID() bool { + return h.Has(tag.OnBehalfOfLocationID) +} + +//HasDeliverToLocationID returns true if DeliverToLocationID is present, Tag 145 +func (h Header) HasDeliverToLocationID() bool { + return h.Has(tag.DeliverToLocationID) +} + +//HasXmlDataLen returns true if XmlDataLen is present, Tag 212 +func (h Header) HasXmlDataLen() bool { + return h.Has(tag.XmlDataLen) +} + +//HasXmlData returns true if XmlData is present, Tag 213 +func (h Header) HasXmlData() bool { + return h.Has(tag.XmlData) +} + +//HasMessageEncoding returns true if MessageEncoding is present, Tag 347 +func (h Header) HasMessageEncoding() bool { + return h.Has(tag.MessageEncoding) +} + +//HasLastMsgSeqNumProcessed returns true if LastMsgSeqNumProcessed is present, Tag 369 +func (h Header) HasLastMsgSeqNumProcessed() bool { + return h.Has(tag.LastMsgSeqNumProcessed) +} + +//HasOnBehalfOfSendingTime returns true if OnBehalfOfSendingTime is present, Tag 370 +func (h Header) HasOnBehalfOfSendingTime() bool { + return h.Has(tag.OnBehalfOfSendingTime) +} + +//HasNoHops returns true if NoHops is present, Tag 627 +func (h Header) HasNoHops() bool { + return h.Has(tag.NoHops) +} + +//NoHops is a repeating group element, Tag 627 +type NoHops struct { + quickfix.Group +} + +//SetHopCompID sets HopCompID, Tag 628 +func (h NoHops) SetHopCompID(v string) { + h.Set(field.NewHopCompID(v)) +} + +//SetHopSendingTime sets HopSendingTime, Tag 629 +func (h NoHops) SetHopSendingTime(v time.Time) { + h.Set(field.NewHopSendingTime(v)) +} + +//SetHopRefID sets HopRefID, Tag 630 +func (h NoHops) SetHopRefID(v int) { + h.Set(field.NewHopRefID(v)) +} + +//GetHopCompID gets HopCompID, Tag 628 +func (h NoHops) GetHopCompID() (f field.HopCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetHopSendingTime gets HopSendingTime, Tag 629 +func (h NoHops) GetHopSendingTime() (f field.HopSendingTimeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetHopRefID gets HopRefID, Tag 630 +func (h NoHops) GetHopRefID() (f field.HopRefIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//HasHopCompID returns true if HopCompID is present, Tag 628 +func (h NoHops) HasHopCompID() bool { + return h.Has(tag.HopCompID) +} + +//HasHopSendingTime returns true if HopSendingTime is present, Tag 629 +func (h NoHops) HasHopSendingTime() bool { + return h.Has(tag.HopSendingTime) +} + +//HasHopRefID returns true if HopRefID is present, Tag 630 +func (h NoHops) HasHopRefID() bool { + return h.Has(tag.HopRefID) +} + +//NoHopsRepeatingGroup is a repeating group, Tag 627 +type NoHopsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoHopsRepeatingGroup returns an initialized, NoHopsRepeatingGroup +func NewNoHopsRepeatingGroup() NoHopsRepeatingGroup { + return NoHopsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoHops, + quickfix.GroupTemplate{quickfix.GroupElement(tag.HopCompID), quickfix.GroupElement(tag.HopSendingTime), quickfix.GroupElement(tag.HopRefID)})} +} + +//Add create and append a new NoHops to this group +func (h NoHopsRepeatingGroup) Add() NoHops { + g := h.RepeatingGroup.Add() + return NoHops{g} +} + +//Get returns the ith NoHops in the NoHopsRepeatinGroup +func (h NoHopsRepeatingGroup) Get(i int) NoHops { + return NoHops{h.RepeatingGroup.Get(i)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix43/marketdatarequest/MarketDataRequest.generated.go b/vendor/github.com/quickfixgo/quickfix/fix43/marketdatarequest/MarketDataRequest.generated.go new file mode 100644 index 0000000..731a36f --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix43/marketdatarequest/MarketDataRequest.generated.go @@ -0,0 +1,964 @@ +package marketdatarequest + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fix43" + "github.com/quickfixgo/quickfix/tag" +) + +//MarketDataRequest is the fix43 MarketDataRequest type, MsgType = V +type MarketDataRequest struct { + fix43.Header + quickfix.Body + fix43.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a MarketDataRequest from a quickfix.Message instance +func FromMessage(m quickfix.Message) MarketDataRequest { + return MarketDataRequest{ + Header: fix43.Header{Header: m.Header}, + Body: m.Body, + Trailer: fix43.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m MarketDataRequest) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a MarketDataRequest initialized with the required fields for MarketDataRequest +func New(mdreqid field.MDReqIDField, subscriptionrequesttype field.SubscriptionRequestTypeField, marketdepth field.MarketDepthField) (m MarketDataRequest) { + m.Header = fix43.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("V")) + m.Set(mdreqid) + m.Set(subscriptionrequesttype) + m.Set(marketdepth) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg MarketDataRequest, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "FIX.4.3", "V", r +} + +//SetNoRelatedSym sets NoRelatedSym, Tag 146 +func (m MarketDataRequest) SetNoRelatedSym(f NoRelatedSymRepeatingGroup) { + m.SetGroup(f) +} + +//SetMDReqID sets MDReqID, Tag 262 +func (m MarketDataRequest) SetMDReqID(v string) { + m.Set(field.NewMDReqID(v)) +} + +//SetSubscriptionRequestType sets SubscriptionRequestType, Tag 263 +func (m MarketDataRequest) SetSubscriptionRequestType(v string) { + m.Set(field.NewSubscriptionRequestType(v)) +} + +//SetMarketDepth sets MarketDepth, Tag 264 +func (m MarketDataRequest) SetMarketDepth(v int) { + m.Set(field.NewMarketDepth(v)) +} + +//SetMDUpdateType sets MDUpdateType, Tag 265 +func (m MarketDataRequest) SetMDUpdateType(v int) { + m.Set(field.NewMDUpdateType(v)) +} + +//SetAggregatedBook sets AggregatedBook, Tag 266 +func (m MarketDataRequest) SetAggregatedBook(v bool) { + m.Set(field.NewAggregatedBook(v)) +} + +//SetNoMDEntryTypes sets NoMDEntryTypes, Tag 267 +func (m MarketDataRequest) SetNoMDEntryTypes(f NoMDEntryTypesRepeatingGroup) { + m.SetGroup(f) +} + +//SetOpenCloseSettleFlag sets OpenCloseSettleFlag, Tag 286 +func (m MarketDataRequest) SetOpenCloseSettleFlag(v string) { + m.Set(field.NewOpenCloseSettleFlag(v)) +} + +//SetNoTradingSessions sets NoTradingSessions, Tag 386 +func (m MarketDataRequest) SetNoTradingSessions(f NoTradingSessionsRepeatingGroup) { + m.SetGroup(f) +} + +//SetScope sets Scope, Tag 546 +func (m MarketDataRequest) SetScope(v string) { + m.Set(field.NewScope(v)) +} + +//SetMDImplicitDelete sets MDImplicitDelete, Tag 547 +func (m MarketDataRequest) SetMDImplicitDelete(v bool) { + m.Set(field.NewMDImplicitDelete(v)) +} + +//GetNoRelatedSym gets NoRelatedSym, Tag 146 +func (m MarketDataRequest) GetNoRelatedSym() (NoRelatedSymRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoRelatedSymRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetMDReqID gets MDReqID, Tag 262 +func (m MarketDataRequest) GetMDReqID() (f field.MDReqIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSubscriptionRequestType gets SubscriptionRequestType, Tag 263 +func (m MarketDataRequest) GetSubscriptionRequestType() (f field.SubscriptionRequestTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMarketDepth gets MarketDepth, Tag 264 +func (m MarketDataRequest) GetMarketDepth() (f field.MarketDepthField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMDUpdateType gets MDUpdateType, Tag 265 +func (m MarketDataRequest) GetMDUpdateType() (f field.MDUpdateTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAggregatedBook gets AggregatedBook, Tag 266 +func (m MarketDataRequest) GetAggregatedBook() (f field.AggregatedBookField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoMDEntryTypes gets NoMDEntryTypes, Tag 267 +func (m MarketDataRequest) GetNoMDEntryTypes() (NoMDEntryTypesRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoMDEntryTypesRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetOpenCloseSettleFlag gets OpenCloseSettleFlag, Tag 286 +func (m MarketDataRequest) GetOpenCloseSettleFlag() (f field.OpenCloseSettleFlagField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoTradingSessions gets NoTradingSessions, Tag 386 +func (m MarketDataRequest) GetNoTradingSessions() (NoTradingSessionsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoTradingSessionsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetScope gets Scope, Tag 546 +func (m MarketDataRequest) GetScope() (f field.ScopeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMDImplicitDelete gets MDImplicitDelete, Tag 547 +func (m MarketDataRequest) GetMDImplicitDelete() (f field.MDImplicitDeleteField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasNoRelatedSym returns true if NoRelatedSym is present, Tag 146 +func (m MarketDataRequest) HasNoRelatedSym() bool { + return m.Has(tag.NoRelatedSym) +} + +//HasMDReqID returns true if MDReqID is present, Tag 262 +func (m MarketDataRequest) HasMDReqID() bool { + return m.Has(tag.MDReqID) +} + +//HasSubscriptionRequestType returns true if SubscriptionRequestType is present, Tag 263 +func (m MarketDataRequest) HasSubscriptionRequestType() bool { + return m.Has(tag.SubscriptionRequestType) +} + +//HasMarketDepth returns true if MarketDepth is present, Tag 264 +func (m MarketDataRequest) HasMarketDepth() bool { + return m.Has(tag.MarketDepth) +} + +//HasMDUpdateType returns true if MDUpdateType is present, Tag 265 +func (m MarketDataRequest) HasMDUpdateType() bool { + return m.Has(tag.MDUpdateType) +} + +//HasAggregatedBook returns true if AggregatedBook is present, Tag 266 +func (m MarketDataRequest) HasAggregatedBook() bool { + return m.Has(tag.AggregatedBook) +} + +//HasNoMDEntryTypes returns true if NoMDEntryTypes is present, Tag 267 +func (m MarketDataRequest) HasNoMDEntryTypes() bool { + return m.Has(tag.NoMDEntryTypes) +} + +//HasOpenCloseSettleFlag returns true if OpenCloseSettleFlag is present, Tag 286 +func (m MarketDataRequest) HasOpenCloseSettleFlag() bool { + return m.Has(tag.OpenCloseSettleFlag) +} + +//HasNoTradingSessions returns true if NoTradingSessions is present, Tag 386 +func (m MarketDataRequest) HasNoTradingSessions() bool { + return m.Has(tag.NoTradingSessions) +} + +//HasScope returns true if Scope is present, Tag 546 +func (m MarketDataRequest) HasScope() bool { + return m.Has(tag.Scope) +} + +//HasMDImplicitDelete returns true if MDImplicitDelete is present, Tag 547 +func (m MarketDataRequest) HasMDImplicitDelete() bool { + return m.Has(tag.MDImplicitDelete) +} + +//NoRelatedSym is a repeating group element, Tag 146 +type NoRelatedSym struct { + quickfix.Group +} + +//SetSymbol sets Symbol, Tag 55 +func (m NoRelatedSym) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m NoRelatedSym) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m NoRelatedSym) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSecurityIDSource sets SecurityIDSource, Tag 22 +func (m NoRelatedSym) SetSecurityIDSource(v string) { + m.Set(field.NewSecurityIDSource(v)) +} + +//SetNoSecurityAltID sets NoSecurityAltID, Tag 454 +func (m NoRelatedSym) SetNoSecurityAltID(f NoSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetProduct sets Product, Tag 460 +func (m NoRelatedSym) SetProduct(v int) { + m.Set(field.NewProduct(v)) +} + +//SetCFICode sets CFICode, Tag 461 +func (m NoRelatedSym) SetCFICode(v string) { + m.Set(field.NewCFICode(v)) +} + +//SetSecurityType sets SecurityType, Tag 167 +func (m NoRelatedSym) SetSecurityType(v string) { + m.Set(field.NewSecurityType(v)) +} + +//SetMaturityMonthYear sets MaturityMonthYear, Tag 200 +func (m NoRelatedSym) SetMaturityMonthYear(v string) { + m.Set(field.NewMaturityMonthYear(v)) +} + +//SetMaturityDate sets MaturityDate, Tag 541 +func (m NoRelatedSym) SetMaturityDate(v string) { + m.Set(field.NewMaturityDate(v)) +} + +//SetCouponPaymentDate sets CouponPaymentDate, Tag 224 +func (m NoRelatedSym) SetCouponPaymentDate(v string) { + m.Set(field.NewCouponPaymentDate(v)) +} + +//SetIssueDate sets IssueDate, Tag 225 +func (m NoRelatedSym) SetIssueDate(v string) { + m.Set(field.NewIssueDate(v)) +} + +//SetRepoCollateralSecurityType sets RepoCollateralSecurityType, Tag 239 +func (m NoRelatedSym) SetRepoCollateralSecurityType(v int) { + m.Set(field.NewRepoCollateralSecurityType(v)) +} + +//SetRepurchaseTerm sets RepurchaseTerm, Tag 226 +func (m NoRelatedSym) SetRepurchaseTerm(v int) { + m.Set(field.NewRepurchaseTerm(v)) +} + +//SetRepurchaseRate sets RepurchaseRate, Tag 227 +func (m NoRelatedSym) SetRepurchaseRate(v float64) { + m.Set(field.NewRepurchaseRate(v)) +} + +//SetFactor sets Factor, Tag 228 +func (m NoRelatedSym) SetFactor(v float64) { + m.Set(field.NewFactor(v)) +} + +//SetCreditRating sets CreditRating, Tag 255 +func (m NoRelatedSym) SetCreditRating(v string) { + m.Set(field.NewCreditRating(v)) +} + +//SetInstrRegistry sets InstrRegistry, Tag 543 +func (m NoRelatedSym) SetInstrRegistry(v string) { + m.Set(field.NewInstrRegistry(v)) +} + +//SetCountryOfIssue sets CountryOfIssue, Tag 470 +func (m NoRelatedSym) SetCountryOfIssue(v string) { + m.Set(field.NewCountryOfIssue(v)) +} + +//SetStateOrProvinceOfIssue sets StateOrProvinceOfIssue, Tag 471 +func (m NoRelatedSym) SetStateOrProvinceOfIssue(v string) { + m.Set(field.NewStateOrProvinceOfIssue(v)) +} + +//SetLocaleOfIssue sets LocaleOfIssue, Tag 472 +func (m NoRelatedSym) SetLocaleOfIssue(v string) { + m.Set(field.NewLocaleOfIssue(v)) +} + +//SetRedemptionDate sets RedemptionDate, Tag 240 +func (m NoRelatedSym) SetRedemptionDate(v string) { + m.Set(field.NewRedemptionDate(v)) +} + +//SetStrikePrice sets StrikePrice, Tag 202 +func (m NoRelatedSym) SetStrikePrice(v float64) { + m.Set(field.NewStrikePrice(v)) +} + +//SetOptAttribute sets OptAttribute, Tag 206 +func (m NoRelatedSym) SetOptAttribute(v string) { + m.Set(field.NewOptAttribute(v)) +} + +//SetContractMultiplier sets ContractMultiplier, Tag 231 +func (m NoRelatedSym) SetContractMultiplier(v float64) { + m.Set(field.NewContractMultiplier(v)) +} + +//SetCouponRate sets CouponRate, Tag 223 +func (m NoRelatedSym) SetCouponRate(v float64) { + m.Set(field.NewCouponRate(v)) +} + +//SetSecurityExchange sets SecurityExchange, Tag 207 +func (m NoRelatedSym) SetSecurityExchange(v string) { + m.Set(field.NewSecurityExchange(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m NoRelatedSym) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetEncodedIssuerLen sets EncodedIssuerLen, Tag 348 +func (m NoRelatedSym) SetEncodedIssuerLen(v int) { + m.Set(field.NewEncodedIssuerLen(v)) +} + +//SetEncodedIssuer sets EncodedIssuer, Tag 349 +func (m NoRelatedSym) SetEncodedIssuer(v string) { + m.Set(field.NewEncodedIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m NoRelatedSym) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetEncodedSecurityDescLen sets EncodedSecurityDescLen, Tag 350 +func (m NoRelatedSym) SetEncodedSecurityDescLen(v int) { + m.Set(field.NewEncodedSecurityDescLen(v)) +} + +//SetEncodedSecurityDesc sets EncodedSecurityDesc, Tag 351 +func (m NoRelatedSym) SetEncodedSecurityDesc(v string) { + m.Set(field.NewEncodedSecurityDesc(v)) +} + +//GetSymbol gets Symbol, Tag 55 +func (m NoRelatedSym) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m NoRelatedSym) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m NoRelatedSym) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityIDSource gets SecurityIDSource, Tag 22 +func (m NoRelatedSym) GetSecurityIDSource() (f field.SecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoSecurityAltID gets NoSecurityAltID, Tag 454 +func (m NoRelatedSym) GetNoSecurityAltID() (NoSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetProduct gets Product, Tag 460 +func (m NoRelatedSym) GetProduct() (f field.ProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCFICode gets CFICode, Tag 461 +func (m NoRelatedSym) GetCFICode() (f field.CFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityType gets SecurityType, Tag 167 +func (m NoRelatedSym) GetSecurityType() (f field.SecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityMonthYear gets MaturityMonthYear, Tag 200 +func (m NoRelatedSym) GetMaturityMonthYear() (f field.MaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityDate gets MaturityDate, Tag 541 +func (m NoRelatedSym) GetMaturityDate() (f field.MaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponPaymentDate gets CouponPaymentDate, Tag 224 +func (m NoRelatedSym) GetCouponPaymentDate() (f field.CouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssueDate gets IssueDate, Tag 225 +func (m NoRelatedSym) GetIssueDate() (f field.IssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepoCollateralSecurityType gets RepoCollateralSecurityType, Tag 239 +func (m NoRelatedSym) GetRepoCollateralSecurityType() (f field.RepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseTerm gets RepurchaseTerm, Tag 226 +func (m NoRelatedSym) GetRepurchaseTerm() (f field.RepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseRate gets RepurchaseRate, Tag 227 +func (m NoRelatedSym) GetRepurchaseRate() (f field.RepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFactor gets Factor, Tag 228 +func (m NoRelatedSym) GetFactor() (f field.FactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCreditRating gets CreditRating, Tag 255 +func (m NoRelatedSym) GetCreditRating() (f field.CreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrRegistry gets InstrRegistry, Tag 543 +func (m NoRelatedSym) GetInstrRegistry() (f field.InstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCountryOfIssue gets CountryOfIssue, Tag 470 +func (m NoRelatedSym) GetCountryOfIssue() (f field.CountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStateOrProvinceOfIssue gets StateOrProvinceOfIssue, Tag 471 +func (m NoRelatedSym) GetStateOrProvinceOfIssue() (f field.StateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLocaleOfIssue gets LocaleOfIssue, Tag 472 +func (m NoRelatedSym) GetLocaleOfIssue() (f field.LocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRedemptionDate gets RedemptionDate, Tag 240 +func (m NoRelatedSym) GetRedemptionDate() (f field.RedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikePrice gets StrikePrice, Tag 202 +func (m NoRelatedSym) GetStrikePrice() (f field.StrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOptAttribute gets OptAttribute, Tag 206 +func (m NoRelatedSym) GetOptAttribute() (f field.OptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractMultiplier gets ContractMultiplier, Tag 231 +func (m NoRelatedSym) GetContractMultiplier() (f field.ContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponRate gets CouponRate, Tag 223 +func (m NoRelatedSym) GetCouponRate() (f field.CouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityExchange gets SecurityExchange, Tag 207 +func (m NoRelatedSym) GetSecurityExchange() (f field.SecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m NoRelatedSym) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuerLen gets EncodedIssuerLen, Tag 348 +func (m NoRelatedSym) GetEncodedIssuerLen() (f field.EncodedIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuer gets EncodedIssuer, Tag 349 +func (m NoRelatedSym) GetEncodedIssuer() (f field.EncodedIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m NoRelatedSym) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDescLen gets EncodedSecurityDescLen, Tag 350 +func (m NoRelatedSym) GetEncodedSecurityDescLen() (f field.EncodedSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDesc gets EncodedSecurityDesc, Tag 351 +func (m NoRelatedSym) GetEncodedSecurityDesc() (f field.EncodedSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m NoRelatedSym) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m NoRelatedSym) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m NoRelatedSym) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSecurityIDSource returns true if SecurityIDSource is present, Tag 22 +func (m NoRelatedSym) HasSecurityIDSource() bool { + return m.Has(tag.SecurityIDSource) +} + +//HasNoSecurityAltID returns true if NoSecurityAltID is present, Tag 454 +func (m NoRelatedSym) HasNoSecurityAltID() bool { + return m.Has(tag.NoSecurityAltID) +} + +//HasProduct returns true if Product is present, Tag 460 +func (m NoRelatedSym) HasProduct() bool { + return m.Has(tag.Product) +} + +//HasCFICode returns true if CFICode is present, Tag 461 +func (m NoRelatedSym) HasCFICode() bool { + return m.Has(tag.CFICode) +} + +//HasSecurityType returns true if SecurityType is present, Tag 167 +func (m NoRelatedSym) HasSecurityType() bool { + return m.Has(tag.SecurityType) +} + +//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200 +func (m NoRelatedSym) HasMaturityMonthYear() bool { + return m.Has(tag.MaturityMonthYear) +} + +//HasMaturityDate returns true if MaturityDate is present, Tag 541 +func (m NoRelatedSym) HasMaturityDate() bool { + return m.Has(tag.MaturityDate) +} + +//HasCouponPaymentDate returns true if CouponPaymentDate is present, Tag 224 +func (m NoRelatedSym) HasCouponPaymentDate() bool { + return m.Has(tag.CouponPaymentDate) +} + +//HasIssueDate returns true if IssueDate is present, Tag 225 +func (m NoRelatedSym) HasIssueDate() bool { + return m.Has(tag.IssueDate) +} + +//HasRepoCollateralSecurityType returns true if RepoCollateralSecurityType is present, Tag 239 +func (m NoRelatedSym) HasRepoCollateralSecurityType() bool { + return m.Has(tag.RepoCollateralSecurityType) +} + +//HasRepurchaseTerm returns true if RepurchaseTerm is present, Tag 226 +func (m NoRelatedSym) HasRepurchaseTerm() bool { + return m.Has(tag.RepurchaseTerm) +} + +//HasRepurchaseRate returns true if RepurchaseRate is present, Tag 227 +func (m NoRelatedSym) HasRepurchaseRate() bool { + return m.Has(tag.RepurchaseRate) +} + +//HasFactor returns true if Factor is present, Tag 228 +func (m NoRelatedSym) HasFactor() bool { + return m.Has(tag.Factor) +} + +//HasCreditRating returns true if CreditRating is present, Tag 255 +func (m NoRelatedSym) HasCreditRating() bool { + return m.Has(tag.CreditRating) +} + +//HasInstrRegistry returns true if InstrRegistry is present, Tag 543 +func (m NoRelatedSym) HasInstrRegistry() bool { + return m.Has(tag.InstrRegistry) +} + +//HasCountryOfIssue returns true if CountryOfIssue is present, Tag 470 +func (m NoRelatedSym) HasCountryOfIssue() bool { + return m.Has(tag.CountryOfIssue) +} + +//HasStateOrProvinceOfIssue returns true if StateOrProvinceOfIssue is present, Tag 471 +func (m NoRelatedSym) HasStateOrProvinceOfIssue() bool { + return m.Has(tag.StateOrProvinceOfIssue) +} + +//HasLocaleOfIssue returns true if LocaleOfIssue is present, Tag 472 +func (m NoRelatedSym) HasLocaleOfIssue() bool { + return m.Has(tag.LocaleOfIssue) +} + +//HasRedemptionDate returns true if RedemptionDate is present, Tag 240 +func (m NoRelatedSym) HasRedemptionDate() bool { + return m.Has(tag.RedemptionDate) +} + +//HasStrikePrice returns true if StrikePrice is present, Tag 202 +func (m NoRelatedSym) HasStrikePrice() bool { + return m.Has(tag.StrikePrice) +} + +//HasOptAttribute returns true if OptAttribute is present, Tag 206 +func (m NoRelatedSym) HasOptAttribute() bool { + return m.Has(tag.OptAttribute) +} + +//HasContractMultiplier returns true if ContractMultiplier is present, Tag 231 +func (m NoRelatedSym) HasContractMultiplier() bool { + return m.Has(tag.ContractMultiplier) +} + +//HasCouponRate returns true if CouponRate is present, Tag 223 +func (m NoRelatedSym) HasCouponRate() bool { + return m.Has(tag.CouponRate) +} + +//HasSecurityExchange returns true if SecurityExchange is present, Tag 207 +func (m NoRelatedSym) HasSecurityExchange() bool { + return m.Has(tag.SecurityExchange) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m NoRelatedSym) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasEncodedIssuerLen returns true if EncodedIssuerLen is present, Tag 348 +func (m NoRelatedSym) HasEncodedIssuerLen() bool { + return m.Has(tag.EncodedIssuerLen) +} + +//HasEncodedIssuer returns true if EncodedIssuer is present, Tag 349 +func (m NoRelatedSym) HasEncodedIssuer() bool { + return m.Has(tag.EncodedIssuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m NoRelatedSym) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasEncodedSecurityDescLen returns true if EncodedSecurityDescLen is present, Tag 350 +func (m NoRelatedSym) HasEncodedSecurityDescLen() bool { + return m.Has(tag.EncodedSecurityDescLen) +} + +//HasEncodedSecurityDesc returns true if EncodedSecurityDesc is present, Tag 351 +func (m NoRelatedSym) HasEncodedSecurityDesc() bool { + return m.Has(tag.EncodedSecurityDesc) +} + +//NoSecurityAltID is a repeating group element, Tag 454 +type NoSecurityAltID struct { + quickfix.Group +} + +//SetSecurityAltID sets SecurityAltID, Tag 455 +func (m NoSecurityAltID) SetSecurityAltID(v string) { + m.Set(field.NewSecurityAltID(v)) +} + +//SetSecurityAltIDSource sets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) SetSecurityAltIDSource(v string) { + m.Set(field.NewSecurityAltIDSource(v)) +} + +//GetSecurityAltID gets SecurityAltID, Tag 455 +func (m NoSecurityAltID) GetSecurityAltID() (f field.SecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityAltIDSource gets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) GetSecurityAltIDSource() (f field.SecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasSecurityAltID returns true if SecurityAltID is present, Tag 455 +func (m NoSecurityAltID) HasSecurityAltID() bool { + return m.Has(tag.SecurityAltID) +} + +//HasSecurityAltIDSource returns true if SecurityAltIDSource is present, Tag 456 +func (m NoSecurityAltID) HasSecurityAltIDSource() bool { + return m.Has(tag.SecurityAltIDSource) +} + +//NoSecurityAltIDRepeatingGroup is a repeating group, Tag 454 +type NoSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoSecurityAltIDRepeatingGroup returns an initialized, NoSecurityAltIDRepeatingGroup +func NewNoSecurityAltIDRepeatingGroup() NoSecurityAltIDRepeatingGroup { + return NoSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.SecurityAltID), quickfix.GroupElement(tag.SecurityAltIDSource)})} +} + +//Add create and append a new NoSecurityAltID to this group +func (m NoSecurityAltIDRepeatingGroup) Add() NoSecurityAltID { + g := m.RepeatingGroup.Add() + return NoSecurityAltID{g} +} + +//Get returns the ith NoSecurityAltID in the NoSecurityAltIDRepeatinGroup +func (m NoSecurityAltIDRepeatingGroup) Get(i int) NoSecurityAltID { + return NoSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoRelatedSymRepeatingGroup is a repeating group, Tag 146 +type NoRelatedSymRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoRelatedSymRepeatingGroup returns an initialized, NoRelatedSymRepeatingGroup +func NewNoRelatedSymRepeatingGroup() NoRelatedSymRepeatingGroup { + return NoRelatedSymRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoRelatedSym, + quickfix.GroupTemplate{quickfix.GroupElement(tag.Symbol), quickfix.GroupElement(tag.SymbolSfx), quickfix.GroupElement(tag.SecurityID), quickfix.GroupElement(tag.SecurityIDSource), NewNoSecurityAltIDRepeatingGroup(), quickfix.GroupElement(tag.Product), quickfix.GroupElement(tag.CFICode), quickfix.GroupElement(tag.SecurityType), quickfix.GroupElement(tag.MaturityMonthYear), quickfix.GroupElement(tag.MaturityDate), quickfix.GroupElement(tag.CouponPaymentDate), quickfix.GroupElement(tag.IssueDate), quickfix.GroupElement(tag.RepoCollateralSecurityType), quickfix.GroupElement(tag.RepurchaseTerm), quickfix.GroupElement(tag.RepurchaseRate), quickfix.GroupElement(tag.Factor), quickfix.GroupElement(tag.CreditRating), quickfix.GroupElement(tag.InstrRegistry), quickfix.GroupElement(tag.CountryOfIssue), quickfix.GroupElement(tag.StateOrProvinceOfIssue), quickfix.GroupElement(tag.LocaleOfIssue), quickfix.GroupElement(tag.RedemptionDate), quickfix.GroupElement(tag.StrikePrice), quickfix.GroupElement(tag.OptAttribute), quickfix.GroupElement(tag.ContractMultiplier), quickfix.GroupElement(tag.CouponRate), quickfix.GroupElement(tag.SecurityExchange), quickfix.GroupElement(tag.Issuer), quickfix.GroupElement(tag.EncodedIssuerLen), quickfix.GroupElement(tag.EncodedIssuer), quickfix.GroupElement(tag.SecurityDesc), quickfix.GroupElement(tag.EncodedSecurityDescLen), quickfix.GroupElement(tag.EncodedSecurityDesc)})} +} + +//Add create and append a new NoRelatedSym to this group +func (m NoRelatedSymRepeatingGroup) Add() NoRelatedSym { + g := m.RepeatingGroup.Add() + return NoRelatedSym{g} +} + +//Get returns the ith NoRelatedSym in the NoRelatedSymRepeatinGroup +func (m NoRelatedSymRepeatingGroup) Get(i int) NoRelatedSym { + return NoRelatedSym{m.RepeatingGroup.Get(i)} +} + +//NoMDEntryTypes is a repeating group element, Tag 267 +type NoMDEntryTypes struct { + quickfix.Group +} + +//SetMDEntryType sets MDEntryType, Tag 269 +func (m NoMDEntryTypes) SetMDEntryType(v string) { + m.Set(field.NewMDEntryType(v)) +} + +//GetMDEntryType gets MDEntryType, Tag 269 +func (m NoMDEntryTypes) GetMDEntryType() (f field.MDEntryTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasMDEntryType returns true if MDEntryType is present, Tag 269 +func (m NoMDEntryTypes) HasMDEntryType() bool { + return m.Has(tag.MDEntryType) +} + +//NoMDEntryTypesRepeatingGroup is a repeating group, Tag 267 +type NoMDEntryTypesRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoMDEntryTypesRepeatingGroup returns an initialized, NoMDEntryTypesRepeatingGroup +func NewNoMDEntryTypesRepeatingGroup() NoMDEntryTypesRepeatingGroup { + return NoMDEntryTypesRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoMDEntryTypes, + quickfix.GroupTemplate{quickfix.GroupElement(tag.MDEntryType)})} +} + +//Add create and append a new NoMDEntryTypes to this group +func (m NoMDEntryTypesRepeatingGroup) Add() NoMDEntryTypes { + g := m.RepeatingGroup.Add() + return NoMDEntryTypes{g} +} + +//Get returns the ith NoMDEntryTypes in the NoMDEntryTypesRepeatinGroup +func (m NoMDEntryTypesRepeatingGroup) Get(i int) NoMDEntryTypes { + return NoMDEntryTypes{m.RepeatingGroup.Get(i)} +} + +//NoTradingSessions is a repeating group element, Tag 386 +type NoTradingSessions struct { + quickfix.Group +} + +//SetTradingSessionID sets TradingSessionID, Tag 336 +func (m NoTradingSessions) SetTradingSessionID(v string) { + m.Set(field.NewTradingSessionID(v)) +} + +//SetTradingSessionSubID sets TradingSessionSubID, Tag 625 +func (m NoTradingSessions) SetTradingSessionSubID(v string) { + m.Set(field.NewTradingSessionSubID(v)) +} + +//GetTradingSessionID gets TradingSessionID, Tag 336 +func (m NoTradingSessions) GetTradingSessionID() (f field.TradingSessionIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradingSessionSubID gets TradingSessionSubID, Tag 625 +func (m NoTradingSessions) GetTradingSessionSubID() (f field.TradingSessionSubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasTradingSessionID returns true if TradingSessionID is present, Tag 336 +func (m NoTradingSessions) HasTradingSessionID() bool { + return m.Has(tag.TradingSessionID) +} + +//HasTradingSessionSubID returns true if TradingSessionSubID is present, Tag 625 +func (m NoTradingSessions) HasTradingSessionSubID() bool { + return m.Has(tag.TradingSessionSubID) +} + +//NoTradingSessionsRepeatingGroup is a repeating group, Tag 386 +type NoTradingSessionsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoTradingSessionsRepeatingGroup returns an initialized, NoTradingSessionsRepeatingGroup +func NewNoTradingSessionsRepeatingGroup() NoTradingSessionsRepeatingGroup { + return NoTradingSessionsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoTradingSessions, + quickfix.GroupTemplate{quickfix.GroupElement(tag.TradingSessionID), quickfix.GroupElement(tag.TradingSessionSubID)})} +} + +//Add create and append a new NoTradingSessions to this group +func (m NoTradingSessionsRepeatingGroup) Add() NoTradingSessions { + g := m.RepeatingGroup.Add() + return NoTradingSessions{g} +} + +//Get returns the ith NoTradingSessions in the NoTradingSessionsRepeatinGroup +func (m NoTradingSessionsRepeatingGroup) Get(i int) NoTradingSessions { + return NoTradingSessions{m.RepeatingGroup.Get(i)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix43/newordersingle/NewOrderSingle.generated.go b/vendor/github.com/quickfixgo/quickfix/fix43/newordersingle/NewOrderSingle.generated.go new file mode 100644 index 0000000..24dda7c --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix43/newordersingle/NewOrderSingle.generated.go @@ -0,0 +1,2368 @@ +package newordersingle + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fix43" + "github.com/quickfixgo/quickfix/tag" +) + +//NewOrderSingle is the fix43 NewOrderSingle type, MsgType = D +type NewOrderSingle struct { + fix43.Header + quickfix.Body + fix43.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a NewOrderSingle from a quickfix.Message instance +func FromMessage(m quickfix.Message) NewOrderSingle { + return NewOrderSingle{ + Header: fix43.Header{Header: m.Header}, + Body: m.Body, + Trailer: fix43.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m NewOrderSingle) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a NewOrderSingle initialized with the required fields for NewOrderSingle +func New(clordid field.ClOrdIDField, handlinst field.HandlInstField, side field.SideField, transacttime field.TransactTimeField, ordtype field.OrdTypeField) (m NewOrderSingle) { + m.Header = fix43.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("D")) + m.Set(clordid) + m.Set(handlinst) + m.Set(side) + m.Set(transacttime) + m.Set(ordtype) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg NewOrderSingle, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "FIX.4.3", "D", r +} + +//SetAccount sets Account, Tag 1 +func (m NewOrderSingle) SetAccount(v string) { + m.Set(field.NewAccount(v)) +} + +//SetClOrdID sets ClOrdID, Tag 11 +func (m NewOrderSingle) SetClOrdID(v string) { + m.Set(field.NewClOrdID(v)) +} + +//SetCommission sets Commission, Tag 12 +func (m NewOrderSingle) SetCommission(v float64) { + m.Set(field.NewCommission(v)) +} + +//SetCommType sets CommType, Tag 13 +func (m NewOrderSingle) SetCommType(v string) { + m.Set(field.NewCommType(v)) +} + +//SetCurrency sets Currency, Tag 15 +func (m NewOrderSingle) SetCurrency(v string) { + m.Set(field.NewCurrency(v)) +} + +//SetExecInst sets ExecInst, Tag 18 +func (m NewOrderSingle) SetExecInst(v string) { + m.Set(field.NewExecInst(v)) +} + +//SetHandlInst sets HandlInst, Tag 21 +func (m NewOrderSingle) SetHandlInst(v string) { + m.Set(field.NewHandlInst(v)) +} + +//SetSecurityIDSource sets SecurityIDSource, Tag 22 +func (m NewOrderSingle) SetSecurityIDSource(v string) { + m.Set(field.NewSecurityIDSource(v)) +} + +//SetIOIid sets IOIid, Tag 23 +func (m NewOrderSingle) SetIOIid(v string) { + m.Set(field.NewIOIid(v)) +} + +//SetOrderQty sets OrderQty, Tag 38 +func (m NewOrderSingle) SetOrderQty(v float64) { + m.Set(field.NewOrderQty(v)) +} + +//SetOrdType sets OrdType, Tag 40 +func (m NewOrderSingle) SetOrdType(v string) { + m.Set(field.NewOrdType(v)) +} + +//SetPrice sets Price, Tag 44 +func (m NewOrderSingle) SetPrice(v float64) { + m.Set(field.NewPrice(v)) +} + +//SetRule80A sets Rule80A, Tag 47 +func (m NewOrderSingle) SetRule80A(v string) { + m.Set(field.NewRule80A(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m NewOrderSingle) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSide sets Side, Tag 54 +func (m NewOrderSingle) SetSide(v string) { + m.Set(field.NewSide(v)) +} + +//SetSymbol sets Symbol, Tag 55 +func (m NewOrderSingle) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetText sets Text, Tag 58 +func (m NewOrderSingle) SetText(v string) { + m.Set(field.NewText(v)) +} + +//SetTimeInForce sets TimeInForce, Tag 59 +func (m NewOrderSingle) SetTimeInForce(v string) { + m.Set(field.NewTimeInForce(v)) +} + +//SetTransactTime sets TransactTime, Tag 60 +func (m NewOrderSingle) SetTransactTime(v time.Time) { + m.Set(field.NewTransactTime(v)) +} + +//SetSettlmntTyp sets SettlmntTyp, Tag 63 +func (m NewOrderSingle) SetSettlmntTyp(v string) { + m.Set(field.NewSettlmntTyp(v)) +} + +//SetFutSettDate sets FutSettDate, Tag 64 +func (m NewOrderSingle) SetFutSettDate(v string) { + m.Set(field.NewFutSettDate(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m NewOrderSingle) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetPositionEffect sets PositionEffect, Tag 77 +func (m NewOrderSingle) SetPositionEffect(v string) { + m.Set(field.NewPositionEffect(v)) +} + +//SetNoAllocs sets NoAllocs, Tag 78 +func (m NewOrderSingle) SetNoAllocs(f NoAllocsRepeatingGroup) { + m.SetGroup(f) +} + +//SetProcessCode sets ProcessCode, Tag 81 +func (m NewOrderSingle) SetProcessCode(v string) { + m.Set(field.NewProcessCode(v)) +} + +//SetStopPx sets StopPx, Tag 99 +func (m NewOrderSingle) SetStopPx(v float64) { + m.Set(field.NewStopPx(v)) +} + +//SetExDestination sets ExDestination, Tag 100 +func (m NewOrderSingle) SetExDestination(v string) { + m.Set(field.NewExDestination(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m NewOrderSingle) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m NewOrderSingle) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetMinQty sets MinQty, Tag 110 +func (m NewOrderSingle) SetMinQty(v float64) { + m.Set(field.NewMinQty(v)) +} + +//SetMaxFloor sets MaxFloor, Tag 111 +func (m NewOrderSingle) SetMaxFloor(v float64) { + m.Set(field.NewMaxFloor(v)) +} + +//SetLocateReqd sets LocateReqd, Tag 114 +func (m NewOrderSingle) SetLocateReqd(v bool) { + m.Set(field.NewLocateReqd(v)) +} + +//SetQuoteID sets QuoteID, Tag 117 +func (m NewOrderSingle) SetQuoteID(v string) { + m.Set(field.NewQuoteID(v)) +} + +//SetNetMoney sets NetMoney, Tag 118 +func (m NewOrderSingle) SetNetMoney(v float64) { + m.Set(field.NewNetMoney(v)) +} + +//SetSettlCurrency sets SettlCurrency, Tag 120 +func (m NewOrderSingle) SetSettlCurrency(v string) { + m.Set(field.NewSettlCurrency(v)) +} + +//SetForexReq sets ForexReq, Tag 121 +func (m NewOrderSingle) SetForexReq(v bool) { + m.Set(field.NewForexReq(v)) +} + +//SetExpireTime sets ExpireTime, Tag 126 +func (m NewOrderSingle) SetExpireTime(v time.Time) { + m.Set(field.NewExpireTime(v)) +} + +//SetPrevClosePx sets PrevClosePx, Tag 140 +func (m NewOrderSingle) SetPrevClosePx(v float64) { + m.Set(field.NewPrevClosePx(v)) +} + +//SetCashOrderQty sets CashOrderQty, Tag 152 +func (m NewOrderSingle) SetCashOrderQty(v float64) { + m.Set(field.NewCashOrderQty(v)) +} + +//SetAccruedInterestRate sets AccruedInterestRate, Tag 158 +func (m NewOrderSingle) SetAccruedInterestRate(v float64) { + m.Set(field.NewAccruedInterestRate(v)) +} + +//SetAccruedInterestAmt sets AccruedInterestAmt, Tag 159 +func (m NewOrderSingle) SetAccruedInterestAmt(v float64) { + m.Set(field.NewAccruedInterestAmt(v)) +} + +//SetSecurityType sets SecurityType, Tag 167 +func (m NewOrderSingle) SetSecurityType(v string) { + m.Set(field.NewSecurityType(v)) +} + +//SetEffectiveTime sets EffectiveTime, Tag 168 +func (m NewOrderSingle) SetEffectiveTime(v time.Time) { + m.Set(field.NewEffectiveTime(v)) +} + +//SetOrderQty2 sets OrderQty2, Tag 192 +func (m NewOrderSingle) SetOrderQty2(v float64) { + m.Set(field.NewOrderQty2(v)) +} + +//SetFutSettDate2 sets FutSettDate2, Tag 193 +func (m NewOrderSingle) SetFutSettDate2(v string) { + m.Set(field.NewFutSettDate2(v)) +} + +//SetMaturityMonthYear sets MaturityMonthYear, Tag 200 +func (m NewOrderSingle) SetMaturityMonthYear(v string) { + m.Set(field.NewMaturityMonthYear(v)) +} + +//SetStrikePrice sets StrikePrice, Tag 202 +func (m NewOrderSingle) SetStrikePrice(v float64) { + m.Set(field.NewStrikePrice(v)) +} + +//SetCoveredOrUncovered sets CoveredOrUncovered, Tag 203 +func (m NewOrderSingle) SetCoveredOrUncovered(v int) { + m.Set(field.NewCoveredOrUncovered(v)) +} + +//SetOptAttribute sets OptAttribute, Tag 206 +func (m NewOrderSingle) SetOptAttribute(v string) { + m.Set(field.NewOptAttribute(v)) +} + +//SetSecurityExchange sets SecurityExchange, Tag 207 +func (m NewOrderSingle) SetSecurityExchange(v string) { + m.Set(field.NewSecurityExchange(v)) +} + +//SetMaxShow sets MaxShow, Tag 210 +func (m NewOrderSingle) SetMaxShow(v float64) { + m.Set(field.NewMaxShow(v)) +} + +//SetPegDifference sets PegDifference, Tag 211 +func (m NewOrderSingle) SetPegDifference(v float64) { + m.Set(field.NewPegDifference(v)) +} + +//SetSpread sets Spread, Tag 218 +func (m NewOrderSingle) SetSpread(v float64) { + m.Set(field.NewSpread(v)) +} + +//SetBenchmarkCurveCurrency sets BenchmarkCurveCurrency, Tag 220 +func (m NewOrderSingle) SetBenchmarkCurveCurrency(v string) { + m.Set(field.NewBenchmarkCurveCurrency(v)) +} + +//SetBenchmarkCurveName sets BenchmarkCurveName, Tag 221 +func (m NewOrderSingle) SetBenchmarkCurveName(v string) { + m.Set(field.NewBenchmarkCurveName(v)) +} + +//SetBenchmarkCurvePoint sets BenchmarkCurvePoint, Tag 222 +func (m NewOrderSingle) SetBenchmarkCurvePoint(v string) { + m.Set(field.NewBenchmarkCurvePoint(v)) +} + +//SetCouponRate sets CouponRate, Tag 223 +func (m NewOrderSingle) SetCouponRate(v float64) { + m.Set(field.NewCouponRate(v)) +} + +//SetCouponPaymentDate sets CouponPaymentDate, Tag 224 +func (m NewOrderSingle) SetCouponPaymentDate(v string) { + m.Set(field.NewCouponPaymentDate(v)) +} + +//SetIssueDate sets IssueDate, Tag 225 +func (m NewOrderSingle) SetIssueDate(v string) { + m.Set(field.NewIssueDate(v)) +} + +//SetRepurchaseTerm sets RepurchaseTerm, Tag 226 +func (m NewOrderSingle) SetRepurchaseTerm(v int) { + m.Set(field.NewRepurchaseTerm(v)) +} + +//SetRepurchaseRate sets RepurchaseRate, Tag 227 +func (m NewOrderSingle) SetRepurchaseRate(v float64) { + m.Set(field.NewRepurchaseRate(v)) +} + +//SetFactor sets Factor, Tag 228 +func (m NewOrderSingle) SetFactor(v float64) { + m.Set(field.NewFactor(v)) +} + +//SetTradeOriginationDate sets TradeOriginationDate, Tag 229 +func (m NewOrderSingle) SetTradeOriginationDate(v string) { + m.Set(field.NewTradeOriginationDate(v)) +} + +//SetContractMultiplier sets ContractMultiplier, Tag 231 +func (m NewOrderSingle) SetContractMultiplier(v float64) { + m.Set(field.NewContractMultiplier(v)) +} + +//SetNoStipulations sets NoStipulations, Tag 232 +func (m NewOrderSingle) SetNoStipulations(f NoStipulationsRepeatingGroup) { + m.SetGroup(f) +} + +//SetYieldType sets YieldType, Tag 235 +func (m NewOrderSingle) SetYieldType(v string) { + m.Set(field.NewYieldType(v)) +} + +//SetYield sets Yield, Tag 236 +func (m NewOrderSingle) SetYield(v float64) { + m.Set(field.NewYield(v)) +} + +//SetRepoCollateralSecurityType sets RepoCollateralSecurityType, Tag 239 +func (m NewOrderSingle) SetRepoCollateralSecurityType(v int) { + m.Set(field.NewRepoCollateralSecurityType(v)) +} + +//SetRedemptionDate sets RedemptionDate, Tag 240 +func (m NewOrderSingle) SetRedemptionDate(v string) { + m.Set(field.NewRedemptionDate(v)) +} + +//SetCreditRating sets CreditRating, Tag 255 +func (m NewOrderSingle) SetCreditRating(v string) { + m.Set(field.NewCreditRating(v)) +} + +//SetEncodedIssuerLen sets EncodedIssuerLen, Tag 348 +func (m NewOrderSingle) SetEncodedIssuerLen(v int) { + m.Set(field.NewEncodedIssuerLen(v)) +} + +//SetEncodedIssuer sets EncodedIssuer, Tag 349 +func (m NewOrderSingle) SetEncodedIssuer(v string) { + m.Set(field.NewEncodedIssuer(v)) +} + +//SetEncodedSecurityDescLen sets EncodedSecurityDescLen, Tag 350 +func (m NewOrderSingle) SetEncodedSecurityDescLen(v int) { + m.Set(field.NewEncodedSecurityDescLen(v)) +} + +//SetEncodedSecurityDesc sets EncodedSecurityDesc, Tag 351 +func (m NewOrderSingle) SetEncodedSecurityDesc(v string) { + m.Set(field.NewEncodedSecurityDesc(v)) +} + +//SetEncodedTextLen sets EncodedTextLen, Tag 354 +func (m NewOrderSingle) SetEncodedTextLen(v int) { + m.Set(field.NewEncodedTextLen(v)) +} + +//SetEncodedText sets EncodedText, Tag 355 +func (m NewOrderSingle) SetEncodedText(v string) { + m.Set(field.NewEncodedText(v)) +} + +//SetComplianceID sets ComplianceID, Tag 376 +func (m NewOrderSingle) SetComplianceID(v string) { + m.Set(field.NewComplianceID(v)) +} + +//SetSolicitedFlag sets SolicitedFlag, Tag 377 +func (m NewOrderSingle) SetSolicitedFlag(v bool) { + m.Set(field.NewSolicitedFlag(v)) +} + +//SetNoTradingSessions sets NoTradingSessions, Tag 386 +func (m NewOrderSingle) SetNoTradingSessions(f NoTradingSessionsRepeatingGroup) { + m.SetGroup(f) +} + +//SetDiscretionInst sets DiscretionInst, Tag 388 +func (m NewOrderSingle) SetDiscretionInst(v string) { + m.Set(field.NewDiscretionInst(v)) +} + +//SetDiscretionOffset sets DiscretionOffset, Tag 389 +func (m NewOrderSingle) SetDiscretionOffset(v float64) { + m.Set(field.NewDiscretionOffset(v)) +} + +//SetPriceType sets PriceType, Tag 423 +func (m NewOrderSingle) SetPriceType(v int) { + m.Set(field.NewPriceType(v)) +} + +//SetGTBookingInst sets GTBookingInst, Tag 427 +func (m NewOrderSingle) SetGTBookingInst(v int) { + m.Set(field.NewGTBookingInst(v)) +} + +//SetExpireDate sets ExpireDate, Tag 432 +func (m NewOrderSingle) SetExpireDate(v string) { + m.Set(field.NewExpireDate(v)) +} + +//SetNoPartyIDs sets NoPartyIDs, Tag 453 +func (m NewOrderSingle) SetNoPartyIDs(f NoPartyIDsRepeatingGroup) { + m.SetGroup(f) +} + +//SetNoSecurityAltID sets NoSecurityAltID, Tag 454 +func (m NewOrderSingle) SetNoSecurityAltID(f NoSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetProduct sets Product, Tag 460 +func (m NewOrderSingle) SetProduct(v int) { + m.Set(field.NewProduct(v)) +} + +//SetCFICode sets CFICode, Tag 461 +func (m NewOrderSingle) SetCFICode(v string) { + m.Set(field.NewCFICode(v)) +} + +//SetQuantityType sets QuantityType, Tag 465 +func (m NewOrderSingle) SetQuantityType(v int) { + m.Set(field.NewQuantityType(v)) +} + +//SetRoundingDirection sets RoundingDirection, Tag 468 +func (m NewOrderSingle) SetRoundingDirection(v string) { + m.Set(field.NewRoundingDirection(v)) +} + +//SetRoundingModulus sets RoundingModulus, Tag 469 +func (m NewOrderSingle) SetRoundingModulus(v float64) { + m.Set(field.NewRoundingModulus(v)) +} + +//SetCountryOfIssue sets CountryOfIssue, Tag 470 +func (m NewOrderSingle) SetCountryOfIssue(v string) { + m.Set(field.NewCountryOfIssue(v)) +} + +//SetStateOrProvinceOfIssue sets StateOrProvinceOfIssue, Tag 471 +func (m NewOrderSingle) SetStateOrProvinceOfIssue(v string) { + m.Set(field.NewStateOrProvinceOfIssue(v)) +} + +//SetLocaleOfIssue sets LocaleOfIssue, Tag 472 +func (m NewOrderSingle) SetLocaleOfIssue(v string) { + m.Set(field.NewLocaleOfIssue(v)) +} + +//SetCommCurrency sets CommCurrency, Tag 479 +func (m NewOrderSingle) SetCommCurrency(v string) { + m.Set(field.NewCommCurrency(v)) +} + +//SetCancellationRights sets CancellationRights, Tag 480 +func (m NewOrderSingle) SetCancellationRights(v string) { + m.Set(field.NewCancellationRights(v)) +} + +//SetMoneyLaunderingStatus sets MoneyLaunderingStatus, Tag 481 +func (m NewOrderSingle) SetMoneyLaunderingStatus(v string) { + m.Set(field.NewMoneyLaunderingStatus(v)) +} + +//SetDesignation sets Designation, Tag 494 +func (m NewOrderSingle) SetDesignation(v string) { + m.Set(field.NewDesignation(v)) +} + +//SetFundRenewWaiv sets FundRenewWaiv, Tag 497 +func (m NewOrderSingle) SetFundRenewWaiv(v string) { + m.Set(field.NewFundRenewWaiv(v)) +} + +//SetRegistID sets RegistID, Tag 513 +func (m NewOrderSingle) SetRegistID(v string) { + m.Set(field.NewRegistID(v)) +} + +//SetOrderPercent sets OrderPercent, Tag 516 +func (m NewOrderSingle) SetOrderPercent(v float64) { + m.Set(field.NewOrderPercent(v)) +} + +//SetSecondaryClOrdID sets SecondaryClOrdID, Tag 526 +func (m NewOrderSingle) SetSecondaryClOrdID(v string) { + m.Set(field.NewSecondaryClOrdID(v)) +} + +//SetOrderCapacity sets OrderCapacity, Tag 528 +func (m NewOrderSingle) SetOrderCapacity(v string) { + m.Set(field.NewOrderCapacity(v)) +} + +//SetOrderRestrictions sets OrderRestrictions, Tag 529 +func (m NewOrderSingle) SetOrderRestrictions(v string) { + m.Set(field.NewOrderRestrictions(v)) +} + +//SetMaturityDate sets MaturityDate, Tag 541 +func (m NewOrderSingle) SetMaturityDate(v string) { + m.Set(field.NewMaturityDate(v)) +} + +//SetInstrRegistry sets InstrRegistry, Tag 543 +func (m NewOrderSingle) SetInstrRegistry(v string) { + m.Set(field.NewInstrRegistry(v)) +} + +//SetCashMargin sets CashMargin, Tag 544 +func (m NewOrderSingle) SetCashMargin(v string) { + m.Set(field.NewCashMargin(v)) +} + +//SetAccountType sets AccountType, Tag 581 +func (m NewOrderSingle) SetAccountType(v int) { + m.Set(field.NewAccountType(v)) +} + +//SetCustOrderCapacity sets CustOrderCapacity, Tag 582 +func (m NewOrderSingle) SetCustOrderCapacity(v int) { + m.Set(field.NewCustOrderCapacity(v)) +} + +//SetClOrdLinkID sets ClOrdLinkID, Tag 583 +func (m NewOrderSingle) SetClOrdLinkID(v string) { + m.Set(field.NewClOrdLinkID(v)) +} + +//SetDayBookingInst sets DayBookingInst, Tag 589 +func (m NewOrderSingle) SetDayBookingInst(v string) { + m.Set(field.NewDayBookingInst(v)) +} + +//SetBookingUnit sets BookingUnit, Tag 590 +func (m NewOrderSingle) SetBookingUnit(v string) { + m.Set(field.NewBookingUnit(v)) +} + +//SetPreallocMethod sets PreallocMethod, Tag 591 +func (m NewOrderSingle) SetPreallocMethod(v string) { + m.Set(field.NewPreallocMethod(v)) +} + +//SetClearingFeeIndicator sets ClearingFeeIndicator, Tag 635 +func (m NewOrderSingle) SetClearingFeeIndicator(v string) { + m.Set(field.NewClearingFeeIndicator(v)) +} + +//SetPrice2 sets Price2, Tag 640 +func (m NewOrderSingle) SetPrice2(v float64) { + m.Set(field.NewPrice2(v)) +} + +//GetAccount gets Account, Tag 1 +func (m NewOrderSingle) GetAccount() (f field.AccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdID gets ClOrdID, Tag 11 +func (m NewOrderSingle) GetClOrdID() (f field.ClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommission gets Commission, Tag 12 +func (m NewOrderSingle) GetCommission() (f field.CommissionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommType gets CommType, Tag 13 +func (m NewOrderSingle) GetCommType() (f field.CommTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCurrency gets Currency, Tag 15 +func (m NewOrderSingle) GetCurrency() (f field.CurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecInst gets ExecInst, Tag 18 +func (m NewOrderSingle) GetExecInst() (f field.ExecInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetHandlInst gets HandlInst, Tag 21 +func (m NewOrderSingle) GetHandlInst() (f field.HandlInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityIDSource gets SecurityIDSource, Tag 22 +func (m NewOrderSingle) GetSecurityIDSource() (f field.SecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIOIid gets IOIid, Tag 23 +func (m NewOrderSingle) GetIOIid() (f field.IOIidField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty gets OrderQty, Tag 38 +func (m NewOrderSingle) GetOrderQty() (f field.OrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdType gets OrdType, Tag 40 +func (m NewOrderSingle) GetOrdType() (f field.OrdTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrice gets Price, Tag 44 +func (m NewOrderSingle) GetPrice() (f field.PriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRule80A gets Rule80A, Tag 47 +func (m NewOrderSingle) GetRule80A() (f field.Rule80AField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m NewOrderSingle) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSide gets Side, Tag 54 +func (m NewOrderSingle) GetSide() (f field.SideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbol gets Symbol, Tag 55 +func (m NewOrderSingle) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetText gets Text, Tag 58 +func (m NewOrderSingle) GetText() (f field.TextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTimeInForce gets TimeInForce, Tag 59 +func (m NewOrderSingle) GetTimeInForce() (f field.TimeInForceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTransactTime gets TransactTime, Tag 60 +func (m NewOrderSingle) GetTransactTime() (f field.TransactTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlmntTyp gets SettlmntTyp, Tag 63 +func (m NewOrderSingle) GetSettlmntTyp() (f field.SettlmntTypField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFutSettDate gets FutSettDate, Tag 64 +func (m NewOrderSingle) GetFutSettDate() (f field.FutSettDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m NewOrderSingle) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPositionEffect gets PositionEffect, Tag 77 +func (m NewOrderSingle) GetPositionEffect() (f field.PositionEffectField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoAllocs gets NoAllocs, Tag 78 +func (m NewOrderSingle) GetNoAllocs() (NoAllocsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoAllocsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetProcessCode gets ProcessCode, Tag 81 +func (m NewOrderSingle) GetProcessCode() (f field.ProcessCodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStopPx gets StopPx, Tag 99 +func (m NewOrderSingle) GetStopPx() (f field.StopPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExDestination gets ExDestination, Tag 100 +func (m NewOrderSingle) GetExDestination() (f field.ExDestinationField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m NewOrderSingle) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m NewOrderSingle) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMinQty gets MinQty, Tag 110 +func (m NewOrderSingle) GetMinQty() (f field.MinQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxFloor gets MaxFloor, Tag 111 +func (m NewOrderSingle) GetMaxFloor() (f field.MaxFloorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLocateReqd gets LocateReqd, Tag 114 +func (m NewOrderSingle) GetLocateReqd() (f field.LocateReqdField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetQuoteID gets QuoteID, Tag 117 +func (m NewOrderSingle) GetQuoteID() (f field.QuoteIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNetMoney gets NetMoney, Tag 118 +func (m NewOrderSingle) GetNetMoney() (f field.NetMoneyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrency gets SettlCurrency, Tag 120 +func (m NewOrderSingle) GetSettlCurrency() (f field.SettlCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetForexReq gets ForexReq, Tag 121 +func (m NewOrderSingle) GetForexReq() (f field.ForexReqField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireTime gets ExpireTime, Tag 126 +func (m NewOrderSingle) GetExpireTime() (f field.ExpireTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrevClosePx gets PrevClosePx, Tag 140 +func (m NewOrderSingle) GetPrevClosePx() (f field.PrevClosePxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashOrderQty gets CashOrderQty, Tag 152 +func (m NewOrderSingle) GetCashOrderQty() (f field.CashOrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAccruedInterestRate gets AccruedInterestRate, Tag 158 +func (m NewOrderSingle) GetAccruedInterestRate() (f field.AccruedInterestRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAccruedInterestAmt gets AccruedInterestAmt, Tag 159 +func (m NewOrderSingle) GetAccruedInterestAmt() (f field.AccruedInterestAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityType gets SecurityType, Tag 167 +func (m NewOrderSingle) GetSecurityType() (f field.SecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEffectiveTime gets EffectiveTime, Tag 168 +func (m NewOrderSingle) GetEffectiveTime() (f field.EffectiveTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty2 gets OrderQty2, Tag 192 +func (m NewOrderSingle) GetOrderQty2() (f field.OrderQty2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFutSettDate2 gets FutSettDate2, Tag 193 +func (m NewOrderSingle) GetFutSettDate2() (f field.FutSettDate2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityMonthYear gets MaturityMonthYear, Tag 200 +func (m NewOrderSingle) GetMaturityMonthYear() (f field.MaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikePrice gets StrikePrice, Tag 202 +func (m NewOrderSingle) GetStrikePrice() (f field.StrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCoveredOrUncovered gets CoveredOrUncovered, Tag 203 +func (m NewOrderSingle) GetCoveredOrUncovered() (f field.CoveredOrUncoveredField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOptAttribute gets OptAttribute, Tag 206 +func (m NewOrderSingle) GetOptAttribute() (f field.OptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityExchange gets SecurityExchange, Tag 207 +func (m NewOrderSingle) GetSecurityExchange() (f field.SecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxShow gets MaxShow, Tag 210 +func (m NewOrderSingle) GetMaxShow() (f field.MaxShowField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegDifference gets PegDifference, Tag 211 +func (m NewOrderSingle) GetPegDifference() (f field.PegDifferenceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSpread gets Spread, Tag 218 +func (m NewOrderSingle) GetSpread() (f field.SpreadField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkCurveCurrency gets BenchmarkCurveCurrency, Tag 220 +func (m NewOrderSingle) GetBenchmarkCurveCurrency() (f field.BenchmarkCurveCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkCurveName gets BenchmarkCurveName, Tag 221 +func (m NewOrderSingle) GetBenchmarkCurveName() (f field.BenchmarkCurveNameField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkCurvePoint gets BenchmarkCurvePoint, Tag 222 +func (m NewOrderSingle) GetBenchmarkCurvePoint() (f field.BenchmarkCurvePointField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponRate gets CouponRate, Tag 223 +func (m NewOrderSingle) GetCouponRate() (f field.CouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponPaymentDate gets CouponPaymentDate, Tag 224 +func (m NewOrderSingle) GetCouponPaymentDate() (f field.CouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssueDate gets IssueDate, Tag 225 +func (m NewOrderSingle) GetIssueDate() (f field.IssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseTerm gets RepurchaseTerm, Tag 226 +func (m NewOrderSingle) GetRepurchaseTerm() (f field.RepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseRate gets RepurchaseRate, Tag 227 +func (m NewOrderSingle) GetRepurchaseRate() (f field.RepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFactor gets Factor, Tag 228 +func (m NewOrderSingle) GetFactor() (f field.FactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradeOriginationDate gets TradeOriginationDate, Tag 229 +func (m NewOrderSingle) GetTradeOriginationDate() (f field.TradeOriginationDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractMultiplier gets ContractMultiplier, Tag 231 +func (m NewOrderSingle) GetContractMultiplier() (f field.ContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoStipulations gets NoStipulations, Tag 232 +func (m NewOrderSingle) GetNoStipulations() (NoStipulationsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoStipulationsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetYieldType gets YieldType, Tag 235 +func (m NewOrderSingle) GetYieldType() (f field.YieldTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYield gets Yield, Tag 236 +func (m NewOrderSingle) GetYield() (f field.YieldField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepoCollateralSecurityType gets RepoCollateralSecurityType, Tag 239 +func (m NewOrderSingle) GetRepoCollateralSecurityType() (f field.RepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRedemptionDate gets RedemptionDate, Tag 240 +func (m NewOrderSingle) GetRedemptionDate() (f field.RedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCreditRating gets CreditRating, Tag 255 +func (m NewOrderSingle) GetCreditRating() (f field.CreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuerLen gets EncodedIssuerLen, Tag 348 +func (m NewOrderSingle) GetEncodedIssuerLen() (f field.EncodedIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuer gets EncodedIssuer, Tag 349 +func (m NewOrderSingle) GetEncodedIssuer() (f field.EncodedIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDescLen gets EncodedSecurityDescLen, Tag 350 +func (m NewOrderSingle) GetEncodedSecurityDescLen() (f field.EncodedSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDesc gets EncodedSecurityDesc, Tag 351 +func (m NewOrderSingle) GetEncodedSecurityDesc() (f field.EncodedSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedTextLen gets EncodedTextLen, Tag 354 +func (m NewOrderSingle) GetEncodedTextLen() (f field.EncodedTextLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedText gets EncodedText, Tag 355 +func (m NewOrderSingle) GetEncodedText() (f field.EncodedTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetComplianceID gets ComplianceID, Tag 376 +func (m NewOrderSingle) GetComplianceID() (f field.ComplianceIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSolicitedFlag gets SolicitedFlag, Tag 377 +func (m NewOrderSingle) GetSolicitedFlag() (f field.SolicitedFlagField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoTradingSessions gets NoTradingSessions, Tag 386 +func (m NewOrderSingle) GetNoTradingSessions() (NoTradingSessionsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoTradingSessionsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetDiscretionInst gets DiscretionInst, Tag 388 +func (m NewOrderSingle) GetDiscretionInst() (f field.DiscretionInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionOffset gets DiscretionOffset, Tag 389 +func (m NewOrderSingle) GetDiscretionOffset() (f field.DiscretionOffsetField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPriceType gets PriceType, Tag 423 +func (m NewOrderSingle) GetPriceType() (f field.PriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetGTBookingInst gets GTBookingInst, Tag 427 +func (m NewOrderSingle) GetGTBookingInst() (f field.GTBookingInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireDate gets ExpireDate, Tag 432 +func (m NewOrderSingle) GetExpireDate() (f field.ExpireDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoPartyIDs gets NoPartyIDs, Tag 453 +func (m NewOrderSingle) GetNoPartyIDs() (NoPartyIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoPartyIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetNoSecurityAltID gets NoSecurityAltID, Tag 454 +func (m NewOrderSingle) GetNoSecurityAltID() (NoSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetProduct gets Product, Tag 460 +func (m NewOrderSingle) GetProduct() (f field.ProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCFICode gets CFICode, Tag 461 +func (m NewOrderSingle) GetCFICode() (f field.CFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetQuantityType gets QuantityType, Tag 465 +func (m NewOrderSingle) GetQuantityType() (f field.QuantityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRoundingDirection gets RoundingDirection, Tag 468 +func (m NewOrderSingle) GetRoundingDirection() (f field.RoundingDirectionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRoundingModulus gets RoundingModulus, Tag 469 +func (m NewOrderSingle) GetRoundingModulus() (f field.RoundingModulusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCountryOfIssue gets CountryOfIssue, Tag 470 +func (m NewOrderSingle) GetCountryOfIssue() (f field.CountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStateOrProvinceOfIssue gets StateOrProvinceOfIssue, Tag 471 +func (m NewOrderSingle) GetStateOrProvinceOfIssue() (f field.StateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLocaleOfIssue gets LocaleOfIssue, Tag 472 +func (m NewOrderSingle) GetLocaleOfIssue() (f field.LocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommCurrency gets CommCurrency, Tag 479 +func (m NewOrderSingle) GetCommCurrency() (f field.CommCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCancellationRights gets CancellationRights, Tag 480 +func (m NewOrderSingle) GetCancellationRights() (f field.CancellationRightsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMoneyLaunderingStatus gets MoneyLaunderingStatus, Tag 481 +func (m NewOrderSingle) GetMoneyLaunderingStatus() (f field.MoneyLaunderingStatusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDesignation gets Designation, Tag 494 +func (m NewOrderSingle) GetDesignation() (f field.DesignationField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFundRenewWaiv gets FundRenewWaiv, Tag 497 +func (m NewOrderSingle) GetFundRenewWaiv() (f field.FundRenewWaivField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRegistID gets RegistID, Tag 513 +func (m NewOrderSingle) GetRegistID() (f field.RegistIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderPercent gets OrderPercent, Tag 516 +func (m NewOrderSingle) GetOrderPercent() (f field.OrderPercentField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecondaryClOrdID gets SecondaryClOrdID, Tag 526 +func (m NewOrderSingle) GetSecondaryClOrdID() (f field.SecondaryClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderCapacity gets OrderCapacity, Tag 528 +func (m NewOrderSingle) GetOrderCapacity() (f field.OrderCapacityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderRestrictions gets OrderRestrictions, Tag 529 +func (m NewOrderSingle) GetOrderRestrictions() (f field.OrderRestrictionsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityDate gets MaturityDate, Tag 541 +func (m NewOrderSingle) GetMaturityDate() (f field.MaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrRegistry gets InstrRegistry, Tag 543 +func (m NewOrderSingle) GetInstrRegistry() (f field.InstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashMargin gets CashMargin, Tag 544 +func (m NewOrderSingle) GetCashMargin() (f field.CashMarginField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAccountType gets AccountType, Tag 581 +func (m NewOrderSingle) GetAccountType() (f field.AccountTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCustOrderCapacity gets CustOrderCapacity, Tag 582 +func (m NewOrderSingle) GetCustOrderCapacity() (f field.CustOrderCapacityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdLinkID gets ClOrdLinkID, Tag 583 +func (m NewOrderSingle) GetClOrdLinkID() (f field.ClOrdLinkIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDayBookingInst gets DayBookingInst, Tag 589 +func (m NewOrderSingle) GetDayBookingInst() (f field.DayBookingInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBookingUnit gets BookingUnit, Tag 590 +func (m NewOrderSingle) GetBookingUnit() (f field.BookingUnitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPreallocMethod gets PreallocMethod, Tag 591 +func (m NewOrderSingle) GetPreallocMethod() (f field.PreallocMethodField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClearingFeeIndicator gets ClearingFeeIndicator, Tag 635 +func (m NewOrderSingle) GetClearingFeeIndicator() (f field.ClearingFeeIndicatorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrice2 gets Price2, Tag 640 +func (m NewOrderSingle) GetPrice2() (f field.Price2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasAccount returns true if Account is present, Tag 1 +func (m NewOrderSingle) HasAccount() bool { + return m.Has(tag.Account) +} + +//HasClOrdID returns true if ClOrdID is present, Tag 11 +func (m NewOrderSingle) HasClOrdID() bool { + return m.Has(tag.ClOrdID) +} + +//HasCommission returns true if Commission is present, Tag 12 +func (m NewOrderSingle) HasCommission() bool { + return m.Has(tag.Commission) +} + +//HasCommType returns true if CommType is present, Tag 13 +func (m NewOrderSingle) HasCommType() bool { + return m.Has(tag.CommType) +} + +//HasCurrency returns true if Currency is present, Tag 15 +func (m NewOrderSingle) HasCurrency() bool { + return m.Has(tag.Currency) +} + +//HasExecInst returns true if ExecInst is present, Tag 18 +func (m NewOrderSingle) HasExecInst() bool { + return m.Has(tag.ExecInst) +} + +//HasHandlInst returns true if HandlInst is present, Tag 21 +func (m NewOrderSingle) HasHandlInst() bool { + return m.Has(tag.HandlInst) +} + +//HasSecurityIDSource returns true if SecurityIDSource is present, Tag 22 +func (m NewOrderSingle) HasSecurityIDSource() bool { + return m.Has(tag.SecurityIDSource) +} + +//HasIOIid returns true if IOIid is present, Tag 23 +func (m NewOrderSingle) HasIOIid() bool { + return m.Has(tag.IOIid) +} + +//HasOrderQty returns true if OrderQty is present, Tag 38 +func (m NewOrderSingle) HasOrderQty() bool { + return m.Has(tag.OrderQty) +} + +//HasOrdType returns true if OrdType is present, Tag 40 +func (m NewOrderSingle) HasOrdType() bool { + return m.Has(tag.OrdType) +} + +//HasPrice returns true if Price is present, Tag 44 +func (m NewOrderSingle) HasPrice() bool { + return m.Has(tag.Price) +} + +//HasRule80A returns true if Rule80A is present, Tag 47 +func (m NewOrderSingle) HasRule80A() bool { + return m.Has(tag.Rule80A) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m NewOrderSingle) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSide returns true if Side is present, Tag 54 +func (m NewOrderSingle) HasSide() bool { + return m.Has(tag.Side) +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m NewOrderSingle) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasText returns true if Text is present, Tag 58 +func (m NewOrderSingle) HasText() bool { + return m.Has(tag.Text) +} + +//HasTimeInForce returns true if TimeInForce is present, Tag 59 +func (m NewOrderSingle) HasTimeInForce() bool { + return m.Has(tag.TimeInForce) +} + +//HasTransactTime returns true if TransactTime is present, Tag 60 +func (m NewOrderSingle) HasTransactTime() bool { + return m.Has(tag.TransactTime) +} + +//HasSettlmntTyp returns true if SettlmntTyp is present, Tag 63 +func (m NewOrderSingle) HasSettlmntTyp() bool { + return m.Has(tag.SettlmntTyp) +} + +//HasFutSettDate returns true if FutSettDate is present, Tag 64 +func (m NewOrderSingle) HasFutSettDate() bool { + return m.Has(tag.FutSettDate) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m NewOrderSingle) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasPositionEffect returns true if PositionEffect is present, Tag 77 +func (m NewOrderSingle) HasPositionEffect() bool { + return m.Has(tag.PositionEffect) +} + +//HasNoAllocs returns true if NoAllocs is present, Tag 78 +func (m NewOrderSingle) HasNoAllocs() bool { + return m.Has(tag.NoAllocs) +} + +//HasProcessCode returns true if ProcessCode is present, Tag 81 +func (m NewOrderSingle) HasProcessCode() bool { + return m.Has(tag.ProcessCode) +} + +//HasStopPx returns true if StopPx is present, Tag 99 +func (m NewOrderSingle) HasStopPx() bool { + return m.Has(tag.StopPx) +} + +//HasExDestination returns true if ExDestination is present, Tag 100 +func (m NewOrderSingle) HasExDestination() bool { + return m.Has(tag.ExDestination) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m NewOrderSingle) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m NewOrderSingle) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasMinQty returns true if MinQty is present, Tag 110 +func (m NewOrderSingle) HasMinQty() bool { + return m.Has(tag.MinQty) +} + +//HasMaxFloor returns true if MaxFloor is present, Tag 111 +func (m NewOrderSingle) HasMaxFloor() bool { + return m.Has(tag.MaxFloor) +} + +//HasLocateReqd returns true if LocateReqd is present, Tag 114 +func (m NewOrderSingle) HasLocateReqd() bool { + return m.Has(tag.LocateReqd) +} + +//HasQuoteID returns true if QuoteID is present, Tag 117 +func (m NewOrderSingle) HasQuoteID() bool { + return m.Has(tag.QuoteID) +} + +//HasNetMoney returns true if NetMoney is present, Tag 118 +func (m NewOrderSingle) HasNetMoney() bool { + return m.Has(tag.NetMoney) +} + +//HasSettlCurrency returns true if SettlCurrency is present, Tag 120 +func (m NewOrderSingle) HasSettlCurrency() bool { + return m.Has(tag.SettlCurrency) +} + +//HasForexReq returns true if ForexReq is present, Tag 121 +func (m NewOrderSingle) HasForexReq() bool { + return m.Has(tag.ForexReq) +} + +//HasExpireTime returns true if ExpireTime is present, Tag 126 +func (m NewOrderSingle) HasExpireTime() bool { + return m.Has(tag.ExpireTime) +} + +//HasPrevClosePx returns true if PrevClosePx is present, Tag 140 +func (m NewOrderSingle) HasPrevClosePx() bool { + return m.Has(tag.PrevClosePx) +} + +//HasCashOrderQty returns true if CashOrderQty is present, Tag 152 +func (m NewOrderSingle) HasCashOrderQty() bool { + return m.Has(tag.CashOrderQty) +} + +//HasAccruedInterestRate returns true if AccruedInterestRate is present, Tag 158 +func (m NewOrderSingle) HasAccruedInterestRate() bool { + return m.Has(tag.AccruedInterestRate) +} + +//HasAccruedInterestAmt returns true if AccruedInterestAmt is present, Tag 159 +func (m NewOrderSingle) HasAccruedInterestAmt() bool { + return m.Has(tag.AccruedInterestAmt) +} + +//HasSecurityType returns true if SecurityType is present, Tag 167 +func (m NewOrderSingle) HasSecurityType() bool { + return m.Has(tag.SecurityType) +} + +//HasEffectiveTime returns true if EffectiveTime is present, Tag 168 +func (m NewOrderSingle) HasEffectiveTime() bool { + return m.Has(tag.EffectiveTime) +} + +//HasOrderQty2 returns true if OrderQty2 is present, Tag 192 +func (m NewOrderSingle) HasOrderQty2() bool { + return m.Has(tag.OrderQty2) +} + +//HasFutSettDate2 returns true if FutSettDate2 is present, Tag 193 +func (m NewOrderSingle) HasFutSettDate2() bool { + return m.Has(tag.FutSettDate2) +} + +//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200 +func (m NewOrderSingle) HasMaturityMonthYear() bool { + return m.Has(tag.MaturityMonthYear) +} + +//HasStrikePrice returns true if StrikePrice is present, Tag 202 +func (m NewOrderSingle) HasStrikePrice() bool { + return m.Has(tag.StrikePrice) +} + +//HasCoveredOrUncovered returns true if CoveredOrUncovered is present, Tag 203 +func (m NewOrderSingle) HasCoveredOrUncovered() bool { + return m.Has(tag.CoveredOrUncovered) +} + +//HasOptAttribute returns true if OptAttribute is present, Tag 206 +func (m NewOrderSingle) HasOptAttribute() bool { + return m.Has(tag.OptAttribute) +} + +//HasSecurityExchange returns true if SecurityExchange is present, Tag 207 +func (m NewOrderSingle) HasSecurityExchange() bool { + return m.Has(tag.SecurityExchange) +} + +//HasMaxShow returns true if MaxShow is present, Tag 210 +func (m NewOrderSingle) HasMaxShow() bool { + return m.Has(tag.MaxShow) +} + +//HasPegDifference returns true if PegDifference is present, Tag 211 +func (m NewOrderSingle) HasPegDifference() bool { + return m.Has(tag.PegDifference) +} + +//HasSpread returns true if Spread is present, Tag 218 +func (m NewOrderSingle) HasSpread() bool { + return m.Has(tag.Spread) +} + +//HasBenchmarkCurveCurrency returns true if BenchmarkCurveCurrency is present, Tag 220 +func (m NewOrderSingle) HasBenchmarkCurveCurrency() bool { + return m.Has(tag.BenchmarkCurveCurrency) +} + +//HasBenchmarkCurveName returns true if BenchmarkCurveName is present, Tag 221 +func (m NewOrderSingle) HasBenchmarkCurveName() bool { + return m.Has(tag.BenchmarkCurveName) +} + +//HasBenchmarkCurvePoint returns true if BenchmarkCurvePoint is present, Tag 222 +func (m NewOrderSingle) HasBenchmarkCurvePoint() bool { + return m.Has(tag.BenchmarkCurvePoint) +} + +//HasCouponRate returns true if CouponRate is present, Tag 223 +func (m NewOrderSingle) HasCouponRate() bool { + return m.Has(tag.CouponRate) +} + +//HasCouponPaymentDate returns true if CouponPaymentDate is present, Tag 224 +func (m NewOrderSingle) HasCouponPaymentDate() bool { + return m.Has(tag.CouponPaymentDate) +} + +//HasIssueDate returns true if IssueDate is present, Tag 225 +func (m NewOrderSingle) HasIssueDate() bool { + return m.Has(tag.IssueDate) +} + +//HasRepurchaseTerm returns true if RepurchaseTerm is present, Tag 226 +func (m NewOrderSingle) HasRepurchaseTerm() bool { + return m.Has(tag.RepurchaseTerm) +} + +//HasRepurchaseRate returns true if RepurchaseRate is present, Tag 227 +func (m NewOrderSingle) HasRepurchaseRate() bool { + return m.Has(tag.RepurchaseRate) +} + +//HasFactor returns true if Factor is present, Tag 228 +func (m NewOrderSingle) HasFactor() bool { + return m.Has(tag.Factor) +} + +//HasTradeOriginationDate returns true if TradeOriginationDate is present, Tag 229 +func (m NewOrderSingle) HasTradeOriginationDate() bool { + return m.Has(tag.TradeOriginationDate) +} + +//HasContractMultiplier returns true if ContractMultiplier is present, Tag 231 +func (m NewOrderSingle) HasContractMultiplier() bool { + return m.Has(tag.ContractMultiplier) +} + +//HasNoStipulations returns true if NoStipulations is present, Tag 232 +func (m NewOrderSingle) HasNoStipulations() bool { + return m.Has(tag.NoStipulations) +} + +//HasYieldType returns true if YieldType is present, Tag 235 +func (m NewOrderSingle) HasYieldType() bool { + return m.Has(tag.YieldType) +} + +//HasYield returns true if Yield is present, Tag 236 +func (m NewOrderSingle) HasYield() bool { + return m.Has(tag.Yield) +} + +//HasRepoCollateralSecurityType returns true if RepoCollateralSecurityType is present, Tag 239 +func (m NewOrderSingle) HasRepoCollateralSecurityType() bool { + return m.Has(tag.RepoCollateralSecurityType) +} + +//HasRedemptionDate returns true if RedemptionDate is present, Tag 240 +func (m NewOrderSingle) HasRedemptionDate() bool { + return m.Has(tag.RedemptionDate) +} + +//HasCreditRating returns true if CreditRating is present, Tag 255 +func (m NewOrderSingle) HasCreditRating() bool { + return m.Has(tag.CreditRating) +} + +//HasEncodedIssuerLen returns true if EncodedIssuerLen is present, Tag 348 +func (m NewOrderSingle) HasEncodedIssuerLen() bool { + return m.Has(tag.EncodedIssuerLen) +} + +//HasEncodedIssuer returns true if EncodedIssuer is present, Tag 349 +func (m NewOrderSingle) HasEncodedIssuer() bool { + return m.Has(tag.EncodedIssuer) +} + +//HasEncodedSecurityDescLen returns true if EncodedSecurityDescLen is present, Tag 350 +func (m NewOrderSingle) HasEncodedSecurityDescLen() bool { + return m.Has(tag.EncodedSecurityDescLen) +} + +//HasEncodedSecurityDesc returns true if EncodedSecurityDesc is present, Tag 351 +func (m NewOrderSingle) HasEncodedSecurityDesc() bool { + return m.Has(tag.EncodedSecurityDesc) +} + +//HasEncodedTextLen returns true if EncodedTextLen is present, Tag 354 +func (m NewOrderSingle) HasEncodedTextLen() bool { + return m.Has(tag.EncodedTextLen) +} + +//HasEncodedText returns true if EncodedText is present, Tag 355 +func (m NewOrderSingle) HasEncodedText() bool { + return m.Has(tag.EncodedText) +} + +//HasComplianceID returns true if ComplianceID is present, Tag 376 +func (m NewOrderSingle) HasComplianceID() bool { + return m.Has(tag.ComplianceID) +} + +//HasSolicitedFlag returns true if SolicitedFlag is present, Tag 377 +func (m NewOrderSingle) HasSolicitedFlag() bool { + return m.Has(tag.SolicitedFlag) +} + +//HasNoTradingSessions returns true if NoTradingSessions is present, Tag 386 +func (m NewOrderSingle) HasNoTradingSessions() bool { + return m.Has(tag.NoTradingSessions) +} + +//HasDiscretionInst returns true if DiscretionInst is present, Tag 388 +func (m NewOrderSingle) HasDiscretionInst() bool { + return m.Has(tag.DiscretionInst) +} + +//HasDiscretionOffset returns true if DiscretionOffset is present, Tag 389 +func (m NewOrderSingle) HasDiscretionOffset() bool { + return m.Has(tag.DiscretionOffset) +} + +//HasPriceType returns true if PriceType is present, Tag 423 +func (m NewOrderSingle) HasPriceType() bool { + return m.Has(tag.PriceType) +} + +//HasGTBookingInst returns true if GTBookingInst is present, Tag 427 +func (m NewOrderSingle) HasGTBookingInst() bool { + return m.Has(tag.GTBookingInst) +} + +//HasExpireDate returns true if ExpireDate is present, Tag 432 +func (m NewOrderSingle) HasExpireDate() bool { + return m.Has(tag.ExpireDate) +} + +//HasNoPartyIDs returns true if NoPartyIDs is present, Tag 453 +func (m NewOrderSingle) HasNoPartyIDs() bool { + return m.Has(tag.NoPartyIDs) +} + +//HasNoSecurityAltID returns true if NoSecurityAltID is present, Tag 454 +func (m NewOrderSingle) HasNoSecurityAltID() bool { + return m.Has(tag.NoSecurityAltID) +} + +//HasProduct returns true if Product is present, Tag 460 +func (m NewOrderSingle) HasProduct() bool { + return m.Has(tag.Product) +} + +//HasCFICode returns true if CFICode is present, Tag 461 +func (m NewOrderSingle) HasCFICode() bool { + return m.Has(tag.CFICode) +} + +//HasQuantityType returns true if QuantityType is present, Tag 465 +func (m NewOrderSingle) HasQuantityType() bool { + return m.Has(tag.QuantityType) +} + +//HasRoundingDirection returns true if RoundingDirection is present, Tag 468 +func (m NewOrderSingle) HasRoundingDirection() bool { + return m.Has(tag.RoundingDirection) +} + +//HasRoundingModulus returns true if RoundingModulus is present, Tag 469 +func (m NewOrderSingle) HasRoundingModulus() bool { + return m.Has(tag.RoundingModulus) +} + +//HasCountryOfIssue returns true if CountryOfIssue is present, Tag 470 +func (m NewOrderSingle) HasCountryOfIssue() bool { + return m.Has(tag.CountryOfIssue) +} + +//HasStateOrProvinceOfIssue returns true if StateOrProvinceOfIssue is present, Tag 471 +func (m NewOrderSingle) HasStateOrProvinceOfIssue() bool { + return m.Has(tag.StateOrProvinceOfIssue) +} + +//HasLocaleOfIssue returns true if LocaleOfIssue is present, Tag 472 +func (m NewOrderSingle) HasLocaleOfIssue() bool { + return m.Has(tag.LocaleOfIssue) +} + +//HasCommCurrency returns true if CommCurrency is present, Tag 479 +func (m NewOrderSingle) HasCommCurrency() bool { + return m.Has(tag.CommCurrency) +} + +//HasCancellationRights returns true if CancellationRights is present, Tag 480 +func (m NewOrderSingle) HasCancellationRights() bool { + return m.Has(tag.CancellationRights) +} + +//HasMoneyLaunderingStatus returns true if MoneyLaunderingStatus is present, Tag 481 +func (m NewOrderSingle) HasMoneyLaunderingStatus() bool { + return m.Has(tag.MoneyLaunderingStatus) +} + +//HasDesignation returns true if Designation is present, Tag 494 +func (m NewOrderSingle) HasDesignation() bool { + return m.Has(tag.Designation) +} + +//HasFundRenewWaiv returns true if FundRenewWaiv is present, Tag 497 +func (m NewOrderSingle) HasFundRenewWaiv() bool { + return m.Has(tag.FundRenewWaiv) +} + +//HasRegistID returns true if RegistID is present, Tag 513 +func (m NewOrderSingle) HasRegistID() bool { + return m.Has(tag.RegistID) +} + +//HasOrderPercent returns true if OrderPercent is present, Tag 516 +func (m NewOrderSingle) HasOrderPercent() bool { + return m.Has(tag.OrderPercent) +} + +//HasSecondaryClOrdID returns true if SecondaryClOrdID is present, Tag 526 +func (m NewOrderSingle) HasSecondaryClOrdID() bool { + return m.Has(tag.SecondaryClOrdID) +} + +//HasOrderCapacity returns true if OrderCapacity is present, Tag 528 +func (m NewOrderSingle) HasOrderCapacity() bool { + return m.Has(tag.OrderCapacity) +} + +//HasOrderRestrictions returns true if OrderRestrictions is present, Tag 529 +func (m NewOrderSingle) HasOrderRestrictions() bool { + return m.Has(tag.OrderRestrictions) +} + +//HasMaturityDate returns true if MaturityDate is present, Tag 541 +func (m NewOrderSingle) HasMaturityDate() bool { + return m.Has(tag.MaturityDate) +} + +//HasInstrRegistry returns true if InstrRegistry is present, Tag 543 +func (m NewOrderSingle) HasInstrRegistry() bool { + return m.Has(tag.InstrRegistry) +} + +//HasCashMargin returns true if CashMargin is present, Tag 544 +func (m NewOrderSingle) HasCashMargin() bool { + return m.Has(tag.CashMargin) +} + +//HasAccountType returns true if AccountType is present, Tag 581 +func (m NewOrderSingle) HasAccountType() bool { + return m.Has(tag.AccountType) +} + +//HasCustOrderCapacity returns true if CustOrderCapacity is present, Tag 582 +func (m NewOrderSingle) HasCustOrderCapacity() bool { + return m.Has(tag.CustOrderCapacity) +} + +//HasClOrdLinkID returns true if ClOrdLinkID is present, Tag 583 +func (m NewOrderSingle) HasClOrdLinkID() bool { + return m.Has(tag.ClOrdLinkID) +} + +//HasDayBookingInst returns true if DayBookingInst is present, Tag 589 +func (m NewOrderSingle) HasDayBookingInst() bool { + return m.Has(tag.DayBookingInst) +} + +//HasBookingUnit returns true if BookingUnit is present, Tag 590 +func (m NewOrderSingle) HasBookingUnit() bool { + return m.Has(tag.BookingUnit) +} + +//HasPreallocMethod returns true if PreallocMethod is present, Tag 591 +func (m NewOrderSingle) HasPreallocMethod() bool { + return m.Has(tag.PreallocMethod) +} + +//HasClearingFeeIndicator returns true if ClearingFeeIndicator is present, Tag 635 +func (m NewOrderSingle) HasClearingFeeIndicator() bool { + return m.Has(tag.ClearingFeeIndicator) +} + +//HasPrice2 returns true if Price2 is present, Tag 640 +func (m NewOrderSingle) HasPrice2() bool { + return m.Has(tag.Price2) +} + +//NoAllocs is a repeating group element, Tag 78 +type NoAllocs struct { + quickfix.Group +} + +//SetAllocAccount sets AllocAccount, Tag 79 +func (m NoAllocs) SetAllocAccount(v string) { + m.Set(field.NewAllocAccount(v)) +} + +//SetIndividualAllocID sets IndividualAllocID, Tag 467 +func (m NoAllocs) SetIndividualAllocID(v string) { + m.Set(field.NewIndividualAllocID(v)) +} + +//SetNoNestedPartyIDs sets NoNestedPartyIDs, Tag 539 +func (m NoAllocs) SetNoNestedPartyIDs(f NoNestedPartyIDsRepeatingGroup) { + m.SetGroup(f) +} + +//SetAllocQty sets AllocQty, Tag 80 +func (m NoAllocs) SetAllocQty(v float64) { + m.Set(field.NewAllocQty(v)) +} + +//GetAllocAccount gets AllocAccount, Tag 79 +func (m NoAllocs) GetAllocAccount() (f field.AllocAccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIndividualAllocID gets IndividualAllocID, Tag 467 +func (m NoAllocs) GetIndividualAllocID() (f field.IndividualAllocIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoNestedPartyIDs gets NoNestedPartyIDs, Tag 539 +func (m NoAllocs) GetNoNestedPartyIDs() (NoNestedPartyIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoNestedPartyIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetAllocQty gets AllocQty, Tag 80 +func (m NoAllocs) GetAllocQty() (f field.AllocQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasAllocAccount returns true if AllocAccount is present, Tag 79 +func (m NoAllocs) HasAllocAccount() bool { + return m.Has(tag.AllocAccount) +} + +//HasIndividualAllocID returns true if IndividualAllocID is present, Tag 467 +func (m NoAllocs) HasIndividualAllocID() bool { + return m.Has(tag.IndividualAllocID) +} + +//HasNoNestedPartyIDs returns true if NoNestedPartyIDs is present, Tag 539 +func (m NoAllocs) HasNoNestedPartyIDs() bool { + return m.Has(tag.NoNestedPartyIDs) +} + +//HasAllocQty returns true if AllocQty is present, Tag 80 +func (m NoAllocs) HasAllocQty() bool { + return m.Has(tag.AllocQty) +} + +//NoNestedPartyIDs is a repeating group element, Tag 539 +type NoNestedPartyIDs struct { + quickfix.Group +} + +//SetNestedPartyID sets NestedPartyID, Tag 524 +func (m NoNestedPartyIDs) SetNestedPartyID(v string) { + m.Set(field.NewNestedPartyID(v)) +} + +//SetNestedPartyIDSource sets NestedPartyIDSource, Tag 525 +func (m NoNestedPartyIDs) SetNestedPartyIDSource(v string) { + m.Set(field.NewNestedPartyIDSource(v)) +} + +//SetNestedPartyRole sets NestedPartyRole, Tag 538 +func (m NoNestedPartyIDs) SetNestedPartyRole(v int) { + m.Set(field.NewNestedPartyRole(v)) +} + +//SetNestedPartySubID sets NestedPartySubID, Tag 545 +func (m NoNestedPartyIDs) SetNestedPartySubID(v string) { + m.Set(field.NewNestedPartySubID(v)) +} + +//GetNestedPartyID gets NestedPartyID, Tag 524 +func (m NoNestedPartyIDs) GetNestedPartyID() (f field.NestedPartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNestedPartyIDSource gets NestedPartyIDSource, Tag 525 +func (m NoNestedPartyIDs) GetNestedPartyIDSource() (f field.NestedPartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNestedPartyRole gets NestedPartyRole, Tag 538 +func (m NoNestedPartyIDs) GetNestedPartyRole() (f field.NestedPartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNestedPartySubID gets NestedPartySubID, Tag 545 +func (m NoNestedPartyIDs) GetNestedPartySubID() (f field.NestedPartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasNestedPartyID returns true if NestedPartyID is present, Tag 524 +func (m NoNestedPartyIDs) HasNestedPartyID() bool { + return m.Has(tag.NestedPartyID) +} + +//HasNestedPartyIDSource returns true if NestedPartyIDSource is present, Tag 525 +func (m NoNestedPartyIDs) HasNestedPartyIDSource() bool { + return m.Has(tag.NestedPartyIDSource) +} + +//HasNestedPartyRole returns true if NestedPartyRole is present, Tag 538 +func (m NoNestedPartyIDs) HasNestedPartyRole() bool { + return m.Has(tag.NestedPartyRole) +} + +//HasNestedPartySubID returns true if NestedPartySubID is present, Tag 545 +func (m NoNestedPartyIDs) HasNestedPartySubID() bool { + return m.Has(tag.NestedPartySubID) +} + +//NoNestedPartyIDsRepeatingGroup is a repeating group, Tag 539 +type NoNestedPartyIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoNestedPartyIDsRepeatingGroup returns an initialized, NoNestedPartyIDsRepeatingGroup +func NewNoNestedPartyIDsRepeatingGroup() NoNestedPartyIDsRepeatingGroup { + return NoNestedPartyIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoNestedPartyIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.NestedPartyID), quickfix.GroupElement(tag.NestedPartyIDSource), quickfix.GroupElement(tag.NestedPartyRole), quickfix.GroupElement(tag.NestedPartySubID)})} +} + +//Add create and append a new NoNestedPartyIDs to this group +func (m NoNestedPartyIDsRepeatingGroup) Add() NoNestedPartyIDs { + g := m.RepeatingGroup.Add() + return NoNestedPartyIDs{g} +} + +//Get returns the ith NoNestedPartyIDs in the NoNestedPartyIDsRepeatinGroup +func (m NoNestedPartyIDsRepeatingGroup) Get(i int) NoNestedPartyIDs { + return NoNestedPartyIDs{m.RepeatingGroup.Get(i)} +} + +//NoAllocsRepeatingGroup is a repeating group, Tag 78 +type NoAllocsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoAllocsRepeatingGroup returns an initialized, NoAllocsRepeatingGroup +func NewNoAllocsRepeatingGroup() NoAllocsRepeatingGroup { + return NoAllocsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoAllocs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.AllocAccount), quickfix.GroupElement(tag.IndividualAllocID), NewNoNestedPartyIDsRepeatingGroup(), quickfix.GroupElement(tag.AllocQty)})} +} + +//Add create and append a new NoAllocs to this group +func (m NoAllocsRepeatingGroup) Add() NoAllocs { + g := m.RepeatingGroup.Add() + return NoAllocs{g} +} + +//Get returns the ith NoAllocs in the NoAllocsRepeatinGroup +func (m NoAllocsRepeatingGroup) Get(i int) NoAllocs { + return NoAllocs{m.RepeatingGroup.Get(i)} +} + +//NoStipulations is a repeating group element, Tag 232 +type NoStipulations struct { + quickfix.Group +} + +//SetStipulationType sets StipulationType, Tag 233 +func (m NoStipulations) SetStipulationType(v string) { + m.Set(field.NewStipulationType(v)) +} + +//SetStipulationValue sets StipulationValue, Tag 234 +func (m NoStipulations) SetStipulationValue(v string) { + m.Set(field.NewStipulationValue(v)) +} + +//GetStipulationType gets StipulationType, Tag 233 +func (m NoStipulations) GetStipulationType() (f field.StipulationTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStipulationValue gets StipulationValue, Tag 234 +func (m NoStipulations) GetStipulationValue() (f field.StipulationValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasStipulationType returns true if StipulationType is present, Tag 233 +func (m NoStipulations) HasStipulationType() bool { + return m.Has(tag.StipulationType) +} + +//HasStipulationValue returns true if StipulationValue is present, Tag 234 +func (m NoStipulations) HasStipulationValue() bool { + return m.Has(tag.StipulationValue) +} + +//NoStipulationsRepeatingGroup is a repeating group, Tag 232 +type NoStipulationsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoStipulationsRepeatingGroup returns an initialized, NoStipulationsRepeatingGroup +func NewNoStipulationsRepeatingGroup() NoStipulationsRepeatingGroup { + return NoStipulationsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoStipulations, + quickfix.GroupTemplate{quickfix.GroupElement(tag.StipulationType), quickfix.GroupElement(tag.StipulationValue)})} +} + +//Add create and append a new NoStipulations to this group +func (m NoStipulationsRepeatingGroup) Add() NoStipulations { + g := m.RepeatingGroup.Add() + return NoStipulations{g} +} + +//Get returns the ith NoStipulations in the NoStipulationsRepeatinGroup +func (m NoStipulationsRepeatingGroup) Get(i int) NoStipulations { + return NoStipulations{m.RepeatingGroup.Get(i)} +} + +//NoTradingSessions is a repeating group element, Tag 386 +type NoTradingSessions struct { + quickfix.Group +} + +//SetTradingSessionID sets TradingSessionID, Tag 336 +func (m NoTradingSessions) SetTradingSessionID(v string) { + m.Set(field.NewTradingSessionID(v)) +} + +//SetTradingSessionSubID sets TradingSessionSubID, Tag 625 +func (m NoTradingSessions) SetTradingSessionSubID(v string) { + m.Set(field.NewTradingSessionSubID(v)) +} + +//GetTradingSessionID gets TradingSessionID, Tag 336 +func (m NoTradingSessions) GetTradingSessionID() (f field.TradingSessionIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradingSessionSubID gets TradingSessionSubID, Tag 625 +func (m NoTradingSessions) GetTradingSessionSubID() (f field.TradingSessionSubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasTradingSessionID returns true if TradingSessionID is present, Tag 336 +func (m NoTradingSessions) HasTradingSessionID() bool { + return m.Has(tag.TradingSessionID) +} + +//HasTradingSessionSubID returns true if TradingSessionSubID is present, Tag 625 +func (m NoTradingSessions) HasTradingSessionSubID() bool { + return m.Has(tag.TradingSessionSubID) +} + +//NoTradingSessionsRepeatingGroup is a repeating group, Tag 386 +type NoTradingSessionsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoTradingSessionsRepeatingGroup returns an initialized, NoTradingSessionsRepeatingGroup +func NewNoTradingSessionsRepeatingGroup() NoTradingSessionsRepeatingGroup { + return NoTradingSessionsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoTradingSessions, + quickfix.GroupTemplate{quickfix.GroupElement(tag.TradingSessionID), quickfix.GroupElement(tag.TradingSessionSubID)})} +} + +//Add create and append a new NoTradingSessions to this group +func (m NoTradingSessionsRepeatingGroup) Add() NoTradingSessions { + g := m.RepeatingGroup.Add() + return NoTradingSessions{g} +} + +//Get returns the ith NoTradingSessions in the NoTradingSessionsRepeatinGroup +func (m NoTradingSessionsRepeatingGroup) Get(i int) NoTradingSessions { + return NoTradingSessions{m.RepeatingGroup.Get(i)} +} + +//NoPartyIDs is a repeating group element, Tag 453 +type NoPartyIDs struct { + quickfix.Group +} + +//SetPartyID sets PartyID, Tag 448 +func (m NoPartyIDs) SetPartyID(v string) { + m.Set(field.NewPartyID(v)) +} + +//SetPartyIDSource sets PartyIDSource, Tag 447 +func (m NoPartyIDs) SetPartyIDSource(v string) { + m.Set(field.NewPartyIDSource(v)) +} + +//SetPartyRole sets PartyRole, Tag 452 +func (m NoPartyIDs) SetPartyRole(v int) { + m.Set(field.NewPartyRole(v)) +} + +//SetPartySubID sets PartySubID, Tag 523 +func (m NoPartyIDs) SetPartySubID(v string) { + m.Set(field.NewPartySubID(v)) +} + +//GetPartyID gets PartyID, Tag 448 +func (m NoPartyIDs) GetPartyID() (f field.PartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartyIDSource gets PartyIDSource, Tag 447 +func (m NoPartyIDs) GetPartyIDSource() (f field.PartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartyRole gets PartyRole, Tag 452 +func (m NoPartyIDs) GetPartyRole() (f field.PartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartySubID gets PartySubID, Tag 523 +func (m NoPartyIDs) GetPartySubID() (f field.PartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasPartyID returns true if PartyID is present, Tag 448 +func (m NoPartyIDs) HasPartyID() bool { + return m.Has(tag.PartyID) +} + +//HasPartyIDSource returns true if PartyIDSource is present, Tag 447 +func (m NoPartyIDs) HasPartyIDSource() bool { + return m.Has(tag.PartyIDSource) +} + +//HasPartyRole returns true if PartyRole is present, Tag 452 +func (m NoPartyIDs) HasPartyRole() bool { + return m.Has(tag.PartyRole) +} + +//HasPartySubID returns true if PartySubID is present, Tag 523 +func (m NoPartyIDs) HasPartySubID() bool { + return m.Has(tag.PartySubID) +} + +//NoPartyIDsRepeatingGroup is a repeating group, Tag 453 +type NoPartyIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoPartyIDsRepeatingGroup returns an initialized, NoPartyIDsRepeatingGroup +func NewNoPartyIDsRepeatingGroup() NoPartyIDsRepeatingGroup { + return NoPartyIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoPartyIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.PartyID), quickfix.GroupElement(tag.PartyIDSource), quickfix.GroupElement(tag.PartyRole), quickfix.GroupElement(tag.PartySubID)})} +} + +//Add create and append a new NoPartyIDs to this group +func (m NoPartyIDsRepeatingGroup) Add() NoPartyIDs { + g := m.RepeatingGroup.Add() + return NoPartyIDs{g} +} + +//Get returns the ith NoPartyIDs in the NoPartyIDsRepeatinGroup +func (m NoPartyIDsRepeatingGroup) Get(i int) NoPartyIDs { + return NoPartyIDs{m.RepeatingGroup.Get(i)} +} + +//NoSecurityAltID is a repeating group element, Tag 454 +type NoSecurityAltID struct { + quickfix.Group +} + +//SetSecurityAltID sets SecurityAltID, Tag 455 +func (m NoSecurityAltID) SetSecurityAltID(v string) { + m.Set(field.NewSecurityAltID(v)) +} + +//SetSecurityAltIDSource sets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) SetSecurityAltIDSource(v string) { + m.Set(field.NewSecurityAltIDSource(v)) +} + +//GetSecurityAltID gets SecurityAltID, Tag 455 +func (m NoSecurityAltID) GetSecurityAltID() (f field.SecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityAltIDSource gets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) GetSecurityAltIDSource() (f field.SecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasSecurityAltID returns true if SecurityAltID is present, Tag 455 +func (m NoSecurityAltID) HasSecurityAltID() bool { + return m.Has(tag.SecurityAltID) +} + +//HasSecurityAltIDSource returns true if SecurityAltIDSource is present, Tag 456 +func (m NoSecurityAltID) HasSecurityAltIDSource() bool { + return m.Has(tag.SecurityAltIDSource) +} + +//NoSecurityAltIDRepeatingGroup is a repeating group, Tag 454 +type NoSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoSecurityAltIDRepeatingGroup returns an initialized, NoSecurityAltIDRepeatingGroup +func NewNoSecurityAltIDRepeatingGroup() NoSecurityAltIDRepeatingGroup { + return NoSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.SecurityAltID), quickfix.GroupElement(tag.SecurityAltIDSource)})} +} + +//Add create and append a new NoSecurityAltID to this group +func (m NoSecurityAltIDRepeatingGroup) Add() NoSecurityAltID { + g := m.RepeatingGroup.Add() + return NoSecurityAltID{g} +} + +//Get returns the ith NoSecurityAltID in the NoSecurityAltIDRepeatinGroup +func (m NoSecurityAltIDRepeatingGroup) Get(i int) NoSecurityAltID { + return NoSecurityAltID{m.RepeatingGroup.Get(i)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix43/ordercancelrequest/OrderCancelRequest.generated.go b/vendor/github.com/quickfixgo/quickfix/fix43/ordercancelrequest/OrderCancelRequest.generated.go new file mode 100644 index 0000000..0d0c1f0 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix43/ordercancelrequest/OrderCancelRequest.generated.go @@ -0,0 +1,1083 @@ +package ordercancelrequest + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fix43" + "github.com/quickfixgo/quickfix/tag" +) + +//OrderCancelRequest is the fix43 OrderCancelRequest type, MsgType = F +type OrderCancelRequest struct { + fix43.Header + quickfix.Body + fix43.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a OrderCancelRequest from a quickfix.Message instance +func FromMessage(m quickfix.Message) OrderCancelRequest { + return OrderCancelRequest{ + Header: fix43.Header{Header: m.Header}, + Body: m.Body, + Trailer: fix43.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m OrderCancelRequest) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a OrderCancelRequest initialized with the required fields for OrderCancelRequest +func New(origclordid field.OrigClOrdIDField, clordid field.ClOrdIDField, side field.SideField, transacttime field.TransactTimeField) (m OrderCancelRequest) { + m.Header = fix43.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("F")) + m.Set(origclordid) + m.Set(clordid) + m.Set(side) + m.Set(transacttime) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg OrderCancelRequest, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "FIX.4.3", "F", r +} + +//SetAccount sets Account, Tag 1 +func (m OrderCancelRequest) SetAccount(v string) { + m.Set(field.NewAccount(v)) +} + +//SetClOrdID sets ClOrdID, Tag 11 +func (m OrderCancelRequest) SetClOrdID(v string) { + m.Set(field.NewClOrdID(v)) +} + +//SetSecurityIDSource sets SecurityIDSource, Tag 22 +func (m OrderCancelRequest) SetSecurityIDSource(v string) { + m.Set(field.NewSecurityIDSource(v)) +} + +//SetOrderID sets OrderID, Tag 37 +func (m OrderCancelRequest) SetOrderID(v string) { + m.Set(field.NewOrderID(v)) +} + +//SetOrderQty sets OrderQty, Tag 38 +func (m OrderCancelRequest) SetOrderQty(v float64) { + m.Set(field.NewOrderQty(v)) +} + +//SetOrigClOrdID sets OrigClOrdID, Tag 41 +func (m OrderCancelRequest) SetOrigClOrdID(v string) { + m.Set(field.NewOrigClOrdID(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m OrderCancelRequest) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSide sets Side, Tag 54 +func (m OrderCancelRequest) SetSide(v string) { + m.Set(field.NewSide(v)) +} + +//SetSymbol sets Symbol, Tag 55 +func (m OrderCancelRequest) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetText sets Text, Tag 58 +func (m OrderCancelRequest) SetText(v string) { + m.Set(field.NewText(v)) +} + +//SetTransactTime sets TransactTime, Tag 60 +func (m OrderCancelRequest) SetTransactTime(v time.Time) { + m.Set(field.NewTransactTime(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m OrderCancelRequest) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetListID sets ListID, Tag 66 +func (m OrderCancelRequest) SetListID(v string) { + m.Set(field.NewListID(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m OrderCancelRequest) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m OrderCancelRequest) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetCashOrderQty sets CashOrderQty, Tag 152 +func (m OrderCancelRequest) SetCashOrderQty(v float64) { + m.Set(field.NewCashOrderQty(v)) +} + +//SetSecurityType sets SecurityType, Tag 167 +func (m OrderCancelRequest) SetSecurityType(v string) { + m.Set(field.NewSecurityType(v)) +} + +//SetMaturityMonthYear sets MaturityMonthYear, Tag 200 +func (m OrderCancelRequest) SetMaturityMonthYear(v string) { + m.Set(field.NewMaturityMonthYear(v)) +} + +//SetStrikePrice sets StrikePrice, Tag 202 +func (m OrderCancelRequest) SetStrikePrice(v float64) { + m.Set(field.NewStrikePrice(v)) +} + +//SetOptAttribute sets OptAttribute, Tag 206 +func (m OrderCancelRequest) SetOptAttribute(v string) { + m.Set(field.NewOptAttribute(v)) +} + +//SetSecurityExchange sets SecurityExchange, Tag 207 +func (m OrderCancelRequest) SetSecurityExchange(v string) { + m.Set(field.NewSecurityExchange(v)) +} + +//SetCouponRate sets CouponRate, Tag 223 +func (m OrderCancelRequest) SetCouponRate(v float64) { + m.Set(field.NewCouponRate(v)) +} + +//SetCouponPaymentDate sets CouponPaymentDate, Tag 224 +func (m OrderCancelRequest) SetCouponPaymentDate(v string) { + m.Set(field.NewCouponPaymentDate(v)) +} + +//SetIssueDate sets IssueDate, Tag 225 +func (m OrderCancelRequest) SetIssueDate(v string) { + m.Set(field.NewIssueDate(v)) +} + +//SetRepurchaseTerm sets RepurchaseTerm, Tag 226 +func (m OrderCancelRequest) SetRepurchaseTerm(v int) { + m.Set(field.NewRepurchaseTerm(v)) +} + +//SetRepurchaseRate sets RepurchaseRate, Tag 227 +func (m OrderCancelRequest) SetRepurchaseRate(v float64) { + m.Set(field.NewRepurchaseRate(v)) +} + +//SetFactor sets Factor, Tag 228 +func (m OrderCancelRequest) SetFactor(v float64) { + m.Set(field.NewFactor(v)) +} + +//SetContractMultiplier sets ContractMultiplier, Tag 231 +func (m OrderCancelRequest) SetContractMultiplier(v float64) { + m.Set(field.NewContractMultiplier(v)) +} + +//SetRepoCollateralSecurityType sets RepoCollateralSecurityType, Tag 239 +func (m OrderCancelRequest) SetRepoCollateralSecurityType(v int) { + m.Set(field.NewRepoCollateralSecurityType(v)) +} + +//SetRedemptionDate sets RedemptionDate, Tag 240 +func (m OrderCancelRequest) SetRedemptionDate(v string) { + m.Set(field.NewRedemptionDate(v)) +} + +//SetCreditRating sets CreditRating, Tag 255 +func (m OrderCancelRequest) SetCreditRating(v string) { + m.Set(field.NewCreditRating(v)) +} + +//SetEncodedIssuerLen sets EncodedIssuerLen, Tag 348 +func (m OrderCancelRequest) SetEncodedIssuerLen(v int) { + m.Set(field.NewEncodedIssuerLen(v)) +} + +//SetEncodedIssuer sets EncodedIssuer, Tag 349 +func (m OrderCancelRequest) SetEncodedIssuer(v string) { + m.Set(field.NewEncodedIssuer(v)) +} + +//SetEncodedSecurityDescLen sets EncodedSecurityDescLen, Tag 350 +func (m OrderCancelRequest) SetEncodedSecurityDescLen(v int) { + m.Set(field.NewEncodedSecurityDescLen(v)) +} + +//SetEncodedSecurityDesc sets EncodedSecurityDesc, Tag 351 +func (m OrderCancelRequest) SetEncodedSecurityDesc(v string) { + m.Set(field.NewEncodedSecurityDesc(v)) +} + +//SetEncodedTextLen sets EncodedTextLen, Tag 354 +func (m OrderCancelRequest) SetEncodedTextLen(v int) { + m.Set(field.NewEncodedTextLen(v)) +} + +//SetEncodedText sets EncodedText, Tag 355 +func (m OrderCancelRequest) SetEncodedText(v string) { + m.Set(field.NewEncodedText(v)) +} + +//SetComplianceID sets ComplianceID, Tag 376 +func (m OrderCancelRequest) SetComplianceID(v string) { + m.Set(field.NewComplianceID(v)) +} + +//SetNoPartyIDs sets NoPartyIDs, Tag 453 +func (m OrderCancelRequest) SetNoPartyIDs(f NoPartyIDsRepeatingGroup) { + m.SetGroup(f) +} + +//SetNoSecurityAltID sets NoSecurityAltID, Tag 454 +func (m OrderCancelRequest) SetNoSecurityAltID(f NoSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetProduct sets Product, Tag 460 +func (m OrderCancelRequest) SetProduct(v int) { + m.Set(field.NewProduct(v)) +} + +//SetCFICode sets CFICode, Tag 461 +func (m OrderCancelRequest) SetCFICode(v string) { + m.Set(field.NewCFICode(v)) +} + +//SetRoundingDirection sets RoundingDirection, Tag 468 +func (m OrderCancelRequest) SetRoundingDirection(v string) { + m.Set(field.NewRoundingDirection(v)) +} + +//SetRoundingModulus sets RoundingModulus, Tag 469 +func (m OrderCancelRequest) SetRoundingModulus(v float64) { + m.Set(field.NewRoundingModulus(v)) +} + +//SetCountryOfIssue sets CountryOfIssue, Tag 470 +func (m OrderCancelRequest) SetCountryOfIssue(v string) { + m.Set(field.NewCountryOfIssue(v)) +} + +//SetStateOrProvinceOfIssue sets StateOrProvinceOfIssue, Tag 471 +func (m OrderCancelRequest) SetStateOrProvinceOfIssue(v string) { + m.Set(field.NewStateOrProvinceOfIssue(v)) +} + +//SetLocaleOfIssue sets LocaleOfIssue, Tag 472 +func (m OrderCancelRequest) SetLocaleOfIssue(v string) { + m.Set(field.NewLocaleOfIssue(v)) +} + +//SetOrderPercent sets OrderPercent, Tag 516 +func (m OrderCancelRequest) SetOrderPercent(v float64) { + m.Set(field.NewOrderPercent(v)) +} + +//SetSecondaryClOrdID sets SecondaryClOrdID, Tag 526 +func (m OrderCancelRequest) SetSecondaryClOrdID(v string) { + m.Set(field.NewSecondaryClOrdID(v)) +} + +//SetMaturityDate sets MaturityDate, Tag 541 +func (m OrderCancelRequest) SetMaturityDate(v string) { + m.Set(field.NewMaturityDate(v)) +} + +//SetInstrRegistry sets InstrRegistry, Tag 543 +func (m OrderCancelRequest) SetInstrRegistry(v string) { + m.Set(field.NewInstrRegistry(v)) +} + +//SetAccountType sets AccountType, Tag 581 +func (m OrderCancelRequest) SetAccountType(v int) { + m.Set(field.NewAccountType(v)) +} + +//SetClOrdLinkID sets ClOrdLinkID, Tag 583 +func (m OrderCancelRequest) SetClOrdLinkID(v string) { + m.Set(field.NewClOrdLinkID(v)) +} + +//SetOrigOrdModTime sets OrigOrdModTime, Tag 586 +func (m OrderCancelRequest) SetOrigOrdModTime(v time.Time) { + m.Set(field.NewOrigOrdModTime(v)) +} + +//GetAccount gets Account, Tag 1 +func (m OrderCancelRequest) GetAccount() (f field.AccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdID gets ClOrdID, Tag 11 +func (m OrderCancelRequest) GetClOrdID() (f field.ClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityIDSource gets SecurityIDSource, Tag 22 +func (m OrderCancelRequest) GetSecurityIDSource() (f field.SecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderID gets OrderID, Tag 37 +func (m OrderCancelRequest) GetOrderID() (f field.OrderIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty gets OrderQty, Tag 38 +func (m OrderCancelRequest) GetOrderQty() (f field.OrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrigClOrdID gets OrigClOrdID, Tag 41 +func (m OrderCancelRequest) GetOrigClOrdID() (f field.OrigClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m OrderCancelRequest) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSide gets Side, Tag 54 +func (m OrderCancelRequest) GetSide() (f field.SideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbol gets Symbol, Tag 55 +func (m OrderCancelRequest) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetText gets Text, Tag 58 +func (m OrderCancelRequest) GetText() (f field.TextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTransactTime gets TransactTime, Tag 60 +func (m OrderCancelRequest) GetTransactTime() (f field.TransactTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m OrderCancelRequest) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetListID gets ListID, Tag 66 +func (m OrderCancelRequest) GetListID() (f field.ListIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m OrderCancelRequest) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m OrderCancelRequest) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashOrderQty gets CashOrderQty, Tag 152 +func (m OrderCancelRequest) GetCashOrderQty() (f field.CashOrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityType gets SecurityType, Tag 167 +func (m OrderCancelRequest) GetSecurityType() (f field.SecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityMonthYear gets MaturityMonthYear, Tag 200 +func (m OrderCancelRequest) GetMaturityMonthYear() (f field.MaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikePrice gets StrikePrice, Tag 202 +func (m OrderCancelRequest) GetStrikePrice() (f field.StrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOptAttribute gets OptAttribute, Tag 206 +func (m OrderCancelRequest) GetOptAttribute() (f field.OptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityExchange gets SecurityExchange, Tag 207 +func (m OrderCancelRequest) GetSecurityExchange() (f field.SecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponRate gets CouponRate, Tag 223 +func (m OrderCancelRequest) GetCouponRate() (f field.CouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponPaymentDate gets CouponPaymentDate, Tag 224 +func (m OrderCancelRequest) GetCouponPaymentDate() (f field.CouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssueDate gets IssueDate, Tag 225 +func (m OrderCancelRequest) GetIssueDate() (f field.IssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseTerm gets RepurchaseTerm, Tag 226 +func (m OrderCancelRequest) GetRepurchaseTerm() (f field.RepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseRate gets RepurchaseRate, Tag 227 +func (m OrderCancelRequest) GetRepurchaseRate() (f field.RepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFactor gets Factor, Tag 228 +func (m OrderCancelRequest) GetFactor() (f field.FactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractMultiplier gets ContractMultiplier, Tag 231 +func (m OrderCancelRequest) GetContractMultiplier() (f field.ContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepoCollateralSecurityType gets RepoCollateralSecurityType, Tag 239 +func (m OrderCancelRequest) GetRepoCollateralSecurityType() (f field.RepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRedemptionDate gets RedemptionDate, Tag 240 +func (m OrderCancelRequest) GetRedemptionDate() (f field.RedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCreditRating gets CreditRating, Tag 255 +func (m OrderCancelRequest) GetCreditRating() (f field.CreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuerLen gets EncodedIssuerLen, Tag 348 +func (m OrderCancelRequest) GetEncodedIssuerLen() (f field.EncodedIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuer gets EncodedIssuer, Tag 349 +func (m OrderCancelRequest) GetEncodedIssuer() (f field.EncodedIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDescLen gets EncodedSecurityDescLen, Tag 350 +func (m OrderCancelRequest) GetEncodedSecurityDescLen() (f field.EncodedSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDesc gets EncodedSecurityDesc, Tag 351 +func (m OrderCancelRequest) GetEncodedSecurityDesc() (f field.EncodedSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedTextLen gets EncodedTextLen, Tag 354 +func (m OrderCancelRequest) GetEncodedTextLen() (f field.EncodedTextLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedText gets EncodedText, Tag 355 +func (m OrderCancelRequest) GetEncodedText() (f field.EncodedTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetComplianceID gets ComplianceID, Tag 376 +func (m OrderCancelRequest) GetComplianceID() (f field.ComplianceIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoPartyIDs gets NoPartyIDs, Tag 453 +func (m OrderCancelRequest) GetNoPartyIDs() (NoPartyIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoPartyIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetNoSecurityAltID gets NoSecurityAltID, Tag 454 +func (m OrderCancelRequest) GetNoSecurityAltID() (NoSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetProduct gets Product, Tag 460 +func (m OrderCancelRequest) GetProduct() (f field.ProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCFICode gets CFICode, Tag 461 +func (m OrderCancelRequest) GetCFICode() (f field.CFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRoundingDirection gets RoundingDirection, Tag 468 +func (m OrderCancelRequest) GetRoundingDirection() (f field.RoundingDirectionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRoundingModulus gets RoundingModulus, Tag 469 +func (m OrderCancelRequest) GetRoundingModulus() (f field.RoundingModulusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCountryOfIssue gets CountryOfIssue, Tag 470 +func (m OrderCancelRequest) GetCountryOfIssue() (f field.CountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStateOrProvinceOfIssue gets StateOrProvinceOfIssue, Tag 471 +func (m OrderCancelRequest) GetStateOrProvinceOfIssue() (f field.StateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLocaleOfIssue gets LocaleOfIssue, Tag 472 +func (m OrderCancelRequest) GetLocaleOfIssue() (f field.LocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderPercent gets OrderPercent, Tag 516 +func (m OrderCancelRequest) GetOrderPercent() (f field.OrderPercentField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecondaryClOrdID gets SecondaryClOrdID, Tag 526 +func (m OrderCancelRequest) GetSecondaryClOrdID() (f field.SecondaryClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityDate gets MaturityDate, Tag 541 +func (m OrderCancelRequest) GetMaturityDate() (f field.MaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrRegistry gets InstrRegistry, Tag 543 +func (m OrderCancelRequest) GetInstrRegistry() (f field.InstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAccountType gets AccountType, Tag 581 +func (m OrderCancelRequest) GetAccountType() (f field.AccountTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdLinkID gets ClOrdLinkID, Tag 583 +func (m OrderCancelRequest) GetClOrdLinkID() (f field.ClOrdLinkIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrigOrdModTime gets OrigOrdModTime, Tag 586 +func (m OrderCancelRequest) GetOrigOrdModTime() (f field.OrigOrdModTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasAccount returns true if Account is present, Tag 1 +func (m OrderCancelRequest) HasAccount() bool { + return m.Has(tag.Account) +} + +//HasClOrdID returns true if ClOrdID is present, Tag 11 +func (m OrderCancelRequest) HasClOrdID() bool { + return m.Has(tag.ClOrdID) +} + +//HasSecurityIDSource returns true if SecurityIDSource is present, Tag 22 +func (m OrderCancelRequest) HasSecurityIDSource() bool { + return m.Has(tag.SecurityIDSource) +} + +//HasOrderID returns true if OrderID is present, Tag 37 +func (m OrderCancelRequest) HasOrderID() bool { + return m.Has(tag.OrderID) +} + +//HasOrderQty returns true if OrderQty is present, Tag 38 +func (m OrderCancelRequest) HasOrderQty() bool { + return m.Has(tag.OrderQty) +} + +//HasOrigClOrdID returns true if OrigClOrdID is present, Tag 41 +func (m OrderCancelRequest) HasOrigClOrdID() bool { + return m.Has(tag.OrigClOrdID) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m OrderCancelRequest) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSide returns true if Side is present, Tag 54 +func (m OrderCancelRequest) HasSide() bool { + return m.Has(tag.Side) +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m OrderCancelRequest) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasText returns true if Text is present, Tag 58 +func (m OrderCancelRequest) HasText() bool { + return m.Has(tag.Text) +} + +//HasTransactTime returns true if TransactTime is present, Tag 60 +func (m OrderCancelRequest) HasTransactTime() bool { + return m.Has(tag.TransactTime) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m OrderCancelRequest) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasListID returns true if ListID is present, Tag 66 +func (m OrderCancelRequest) HasListID() bool { + return m.Has(tag.ListID) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m OrderCancelRequest) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m OrderCancelRequest) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasCashOrderQty returns true if CashOrderQty is present, Tag 152 +func (m OrderCancelRequest) HasCashOrderQty() bool { + return m.Has(tag.CashOrderQty) +} + +//HasSecurityType returns true if SecurityType is present, Tag 167 +func (m OrderCancelRequest) HasSecurityType() bool { + return m.Has(tag.SecurityType) +} + +//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200 +func (m OrderCancelRequest) HasMaturityMonthYear() bool { + return m.Has(tag.MaturityMonthYear) +} + +//HasStrikePrice returns true if StrikePrice is present, Tag 202 +func (m OrderCancelRequest) HasStrikePrice() bool { + return m.Has(tag.StrikePrice) +} + +//HasOptAttribute returns true if OptAttribute is present, Tag 206 +func (m OrderCancelRequest) HasOptAttribute() bool { + return m.Has(tag.OptAttribute) +} + +//HasSecurityExchange returns true if SecurityExchange is present, Tag 207 +func (m OrderCancelRequest) HasSecurityExchange() bool { + return m.Has(tag.SecurityExchange) +} + +//HasCouponRate returns true if CouponRate is present, Tag 223 +func (m OrderCancelRequest) HasCouponRate() bool { + return m.Has(tag.CouponRate) +} + +//HasCouponPaymentDate returns true if CouponPaymentDate is present, Tag 224 +func (m OrderCancelRequest) HasCouponPaymentDate() bool { + return m.Has(tag.CouponPaymentDate) +} + +//HasIssueDate returns true if IssueDate is present, Tag 225 +func (m OrderCancelRequest) HasIssueDate() bool { + return m.Has(tag.IssueDate) +} + +//HasRepurchaseTerm returns true if RepurchaseTerm is present, Tag 226 +func (m OrderCancelRequest) HasRepurchaseTerm() bool { + return m.Has(tag.RepurchaseTerm) +} + +//HasRepurchaseRate returns true if RepurchaseRate is present, Tag 227 +func (m OrderCancelRequest) HasRepurchaseRate() bool { + return m.Has(tag.RepurchaseRate) +} + +//HasFactor returns true if Factor is present, Tag 228 +func (m OrderCancelRequest) HasFactor() bool { + return m.Has(tag.Factor) +} + +//HasContractMultiplier returns true if ContractMultiplier is present, Tag 231 +func (m OrderCancelRequest) HasContractMultiplier() bool { + return m.Has(tag.ContractMultiplier) +} + +//HasRepoCollateralSecurityType returns true if RepoCollateralSecurityType is present, Tag 239 +func (m OrderCancelRequest) HasRepoCollateralSecurityType() bool { + return m.Has(tag.RepoCollateralSecurityType) +} + +//HasRedemptionDate returns true if RedemptionDate is present, Tag 240 +func (m OrderCancelRequest) HasRedemptionDate() bool { + return m.Has(tag.RedemptionDate) +} + +//HasCreditRating returns true if CreditRating is present, Tag 255 +func (m OrderCancelRequest) HasCreditRating() bool { + return m.Has(tag.CreditRating) +} + +//HasEncodedIssuerLen returns true if EncodedIssuerLen is present, Tag 348 +func (m OrderCancelRequest) HasEncodedIssuerLen() bool { + return m.Has(tag.EncodedIssuerLen) +} + +//HasEncodedIssuer returns true if EncodedIssuer is present, Tag 349 +func (m OrderCancelRequest) HasEncodedIssuer() bool { + return m.Has(tag.EncodedIssuer) +} + +//HasEncodedSecurityDescLen returns true if EncodedSecurityDescLen is present, Tag 350 +func (m OrderCancelRequest) HasEncodedSecurityDescLen() bool { + return m.Has(tag.EncodedSecurityDescLen) +} + +//HasEncodedSecurityDesc returns true if EncodedSecurityDesc is present, Tag 351 +func (m OrderCancelRequest) HasEncodedSecurityDesc() bool { + return m.Has(tag.EncodedSecurityDesc) +} + +//HasEncodedTextLen returns true if EncodedTextLen is present, Tag 354 +func (m OrderCancelRequest) HasEncodedTextLen() bool { + return m.Has(tag.EncodedTextLen) +} + +//HasEncodedText returns true if EncodedText is present, Tag 355 +func (m OrderCancelRequest) HasEncodedText() bool { + return m.Has(tag.EncodedText) +} + +//HasComplianceID returns true if ComplianceID is present, Tag 376 +func (m OrderCancelRequest) HasComplianceID() bool { + return m.Has(tag.ComplianceID) +} + +//HasNoPartyIDs returns true if NoPartyIDs is present, Tag 453 +func (m OrderCancelRequest) HasNoPartyIDs() bool { + return m.Has(tag.NoPartyIDs) +} + +//HasNoSecurityAltID returns true if NoSecurityAltID is present, Tag 454 +func (m OrderCancelRequest) HasNoSecurityAltID() bool { + return m.Has(tag.NoSecurityAltID) +} + +//HasProduct returns true if Product is present, Tag 460 +func (m OrderCancelRequest) HasProduct() bool { + return m.Has(tag.Product) +} + +//HasCFICode returns true if CFICode is present, Tag 461 +func (m OrderCancelRequest) HasCFICode() bool { + return m.Has(tag.CFICode) +} + +//HasRoundingDirection returns true if RoundingDirection is present, Tag 468 +func (m OrderCancelRequest) HasRoundingDirection() bool { + return m.Has(tag.RoundingDirection) +} + +//HasRoundingModulus returns true if RoundingModulus is present, Tag 469 +func (m OrderCancelRequest) HasRoundingModulus() bool { + return m.Has(tag.RoundingModulus) +} + +//HasCountryOfIssue returns true if CountryOfIssue is present, Tag 470 +func (m OrderCancelRequest) HasCountryOfIssue() bool { + return m.Has(tag.CountryOfIssue) +} + +//HasStateOrProvinceOfIssue returns true if StateOrProvinceOfIssue is present, Tag 471 +func (m OrderCancelRequest) HasStateOrProvinceOfIssue() bool { + return m.Has(tag.StateOrProvinceOfIssue) +} + +//HasLocaleOfIssue returns true if LocaleOfIssue is present, Tag 472 +func (m OrderCancelRequest) HasLocaleOfIssue() bool { + return m.Has(tag.LocaleOfIssue) +} + +//HasOrderPercent returns true if OrderPercent is present, Tag 516 +func (m OrderCancelRequest) HasOrderPercent() bool { + return m.Has(tag.OrderPercent) +} + +//HasSecondaryClOrdID returns true if SecondaryClOrdID is present, Tag 526 +func (m OrderCancelRequest) HasSecondaryClOrdID() bool { + return m.Has(tag.SecondaryClOrdID) +} + +//HasMaturityDate returns true if MaturityDate is present, Tag 541 +func (m OrderCancelRequest) HasMaturityDate() bool { + return m.Has(tag.MaturityDate) +} + +//HasInstrRegistry returns true if InstrRegistry is present, Tag 543 +func (m OrderCancelRequest) HasInstrRegistry() bool { + return m.Has(tag.InstrRegistry) +} + +//HasAccountType returns true if AccountType is present, Tag 581 +func (m OrderCancelRequest) HasAccountType() bool { + return m.Has(tag.AccountType) +} + +//HasClOrdLinkID returns true if ClOrdLinkID is present, Tag 583 +func (m OrderCancelRequest) HasClOrdLinkID() bool { + return m.Has(tag.ClOrdLinkID) +} + +//HasOrigOrdModTime returns true if OrigOrdModTime is present, Tag 586 +func (m OrderCancelRequest) HasOrigOrdModTime() bool { + return m.Has(tag.OrigOrdModTime) +} + +//NoPartyIDs is a repeating group element, Tag 453 +type NoPartyIDs struct { + quickfix.Group +} + +//SetPartyID sets PartyID, Tag 448 +func (m NoPartyIDs) SetPartyID(v string) { + m.Set(field.NewPartyID(v)) +} + +//SetPartyIDSource sets PartyIDSource, Tag 447 +func (m NoPartyIDs) SetPartyIDSource(v string) { + m.Set(field.NewPartyIDSource(v)) +} + +//SetPartyRole sets PartyRole, Tag 452 +func (m NoPartyIDs) SetPartyRole(v int) { + m.Set(field.NewPartyRole(v)) +} + +//SetPartySubID sets PartySubID, Tag 523 +func (m NoPartyIDs) SetPartySubID(v string) { + m.Set(field.NewPartySubID(v)) +} + +//GetPartyID gets PartyID, Tag 448 +func (m NoPartyIDs) GetPartyID() (f field.PartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartyIDSource gets PartyIDSource, Tag 447 +func (m NoPartyIDs) GetPartyIDSource() (f field.PartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartyRole gets PartyRole, Tag 452 +func (m NoPartyIDs) GetPartyRole() (f field.PartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartySubID gets PartySubID, Tag 523 +func (m NoPartyIDs) GetPartySubID() (f field.PartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasPartyID returns true if PartyID is present, Tag 448 +func (m NoPartyIDs) HasPartyID() bool { + return m.Has(tag.PartyID) +} + +//HasPartyIDSource returns true if PartyIDSource is present, Tag 447 +func (m NoPartyIDs) HasPartyIDSource() bool { + return m.Has(tag.PartyIDSource) +} + +//HasPartyRole returns true if PartyRole is present, Tag 452 +func (m NoPartyIDs) HasPartyRole() bool { + return m.Has(tag.PartyRole) +} + +//HasPartySubID returns true if PartySubID is present, Tag 523 +func (m NoPartyIDs) HasPartySubID() bool { + return m.Has(tag.PartySubID) +} + +//NoPartyIDsRepeatingGroup is a repeating group, Tag 453 +type NoPartyIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoPartyIDsRepeatingGroup returns an initialized, NoPartyIDsRepeatingGroup +func NewNoPartyIDsRepeatingGroup() NoPartyIDsRepeatingGroup { + return NoPartyIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoPartyIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.PartyID), quickfix.GroupElement(tag.PartyIDSource), quickfix.GroupElement(tag.PartyRole), quickfix.GroupElement(tag.PartySubID)})} +} + +//Add create and append a new NoPartyIDs to this group +func (m NoPartyIDsRepeatingGroup) Add() NoPartyIDs { + g := m.RepeatingGroup.Add() + return NoPartyIDs{g} +} + +//Get returns the ith NoPartyIDs in the NoPartyIDsRepeatinGroup +func (m NoPartyIDsRepeatingGroup) Get(i int) NoPartyIDs { + return NoPartyIDs{m.RepeatingGroup.Get(i)} +} + +//NoSecurityAltID is a repeating group element, Tag 454 +type NoSecurityAltID struct { + quickfix.Group +} + +//SetSecurityAltID sets SecurityAltID, Tag 455 +func (m NoSecurityAltID) SetSecurityAltID(v string) { + m.Set(field.NewSecurityAltID(v)) +} + +//SetSecurityAltIDSource sets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) SetSecurityAltIDSource(v string) { + m.Set(field.NewSecurityAltIDSource(v)) +} + +//GetSecurityAltID gets SecurityAltID, Tag 455 +func (m NoSecurityAltID) GetSecurityAltID() (f field.SecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityAltIDSource gets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) GetSecurityAltIDSource() (f field.SecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasSecurityAltID returns true if SecurityAltID is present, Tag 455 +func (m NoSecurityAltID) HasSecurityAltID() bool { + return m.Has(tag.SecurityAltID) +} + +//HasSecurityAltIDSource returns true if SecurityAltIDSource is present, Tag 456 +func (m NoSecurityAltID) HasSecurityAltIDSource() bool { + return m.Has(tag.SecurityAltIDSource) +} + +//NoSecurityAltIDRepeatingGroup is a repeating group, Tag 454 +type NoSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoSecurityAltIDRepeatingGroup returns an initialized, NoSecurityAltIDRepeatingGroup +func NewNoSecurityAltIDRepeatingGroup() NoSecurityAltIDRepeatingGroup { + return NoSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.SecurityAltID), quickfix.GroupElement(tag.SecurityAltIDSource)})} +} + +//Add create and append a new NoSecurityAltID to this group +func (m NoSecurityAltIDRepeatingGroup) Add() NoSecurityAltID { + g := m.RepeatingGroup.Add() + return NoSecurityAltID{g} +} + +//Get returns the ith NoSecurityAltID in the NoSecurityAltIDRepeatinGroup +func (m NoSecurityAltIDRepeatingGroup) Get(i int) NoSecurityAltID { + return NoSecurityAltID{m.RepeatingGroup.Get(i)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix43/trailer.generated.go b/vendor/github.com/quickfixgo/quickfix/fix43/trailer.generated.go new file mode 100644 index 0000000..33ae8da --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix43/trailer.generated.go @@ -0,0 +1,60 @@ +package fix43 + +import ( + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/tag" +) + +//Trailer is the fix43 Trailer type +type Trailer struct { + quickfix.Trailer +} + +//SetCheckSum sets CheckSum, Tag 10 +func (t Trailer) SetCheckSum(v string) { + t.Set(field.NewCheckSum(v)) +} + +//SetSignature sets Signature, Tag 89 +func (t Trailer) SetSignature(v string) { + t.Set(field.NewSignature(v)) +} + +//SetSignatureLength sets SignatureLength, Tag 93 +func (t Trailer) SetSignatureLength(v int) { + t.Set(field.NewSignatureLength(v)) +} + +//GetCheckSum gets CheckSum, Tag 10 +func (t Trailer) GetCheckSum() (f field.CheckSumField, err quickfix.MessageRejectError) { + err = t.Get(&f) + return +} + +//GetSignature gets Signature, Tag 89 +func (t Trailer) GetSignature() (f field.SignatureField, err quickfix.MessageRejectError) { + err = t.Get(&f) + return +} + +//GetSignatureLength gets SignatureLength, Tag 93 +func (t Trailer) GetSignatureLength() (f field.SignatureLengthField, err quickfix.MessageRejectError) { + err = t.Get(&f) + return +} + +//HasCheckSum returns true if CheckSum is present, Tag 10 +func (t Trailer) HasCheckSum() bool { + return t.Has(tag.CheckSum) +} + +//HasSignature returns true if Signature is present, Tag 89 +func (t Trailer) HasSignature() bool { + return t.Has(tag.Signature) +} + +//HasSignatureLength returns true if SignatureLength is present, Tag 93 +func (t Trailer) HasSignatureLength() bool { + return t.Has(tag.SignatureLength) +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix44/executionreport/ExecutionReport.generated.go b/vendor/github.com/quickfixgo/quickfix/fix44/executionreport/ExecutionReport.generated.go new file mode 100644 index 0000000..83eb7b3 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix44/executionreport/ExecutionReport.generated.go @@ -0,0 +1,6229 @@ +package executionreport + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fix44" + "github.com/quickfixgo/quickfix/tag" +) + +//ExecutionReport is the fix44 ExecutionReport type, MsgType = 8 +type ExecutionReport struct { + fix44.Header + quickfix.Body + fix44.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a ExecutionReport from a quickfix.Message instance +func FromMessage(m quickfix.Message) ExecutionReport { + return ExecutionReport{ + Header: fix44.Header{Header: m.Header}, + Body: m.Body, + Trailer: fix44.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m ExecutionReport) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a ExecutionReport initialized with the required fields for ExecutionReport +func New(orderid field.OrderIDField, execid field.ExecIDField, exectype field.ExecTypeField, ordstatus field.OrdStatusField, side field.SideField, leavesqty field.LeavesQtyField, cumqty field.CumQtyField, avgpx field.AvgPxField) (m ExecutionReport) { + m.Header = fix44.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("8")) + m.Set(orderid) + m.Set(execid) + m.Set(exectype) + m.Set(ordstatus) + m.Set(side) + m.Set(leavesqty) + m.Set(cumqty) + m.Set(avgpx) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg ExecutionReport, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "FIX.4.4", "8", r +} + +//SetAccount sets Account, Tag 1 +func (m ExecutionReport) SetAccount(v string) { + m.Set(field.NewAccount(v)) +} + +//SetAvgPx sets AvgPx, Tag 6 +func (m ExecutionReport) SetAvgPx(v float64) { + m.Set(field.NewAvgPx(v)) +} + +//SetClOrdID sets ClOrdID, Tag 11 +func (m ExecutionReport) SetClOrdID(v string) { + m.Set(field.NewClOrdID(v)) +} + +//SetCommission sets Commission, Tag 12 +func (m ExecutionReport) SetCommission(v float64) { + m.Set(field.NewCommission(v)) +} + +//SetCommType sets CommType, Tag 13 +func (m ExecutionReport) SetCommType(v string) { + m.Set(field.NewCommType(v)) +} + +//SetCumQty sets CumQty, Tag 14 +func (m ExecutionReport) SetCumQty(v float64) { + m.Set(field.NewCumQty(v)) +} + +//SetCurrency sets Currency, Tag 15 +func (m ExecutionReport) SetCurrency(v string) { + m.Set(field.NewCurrency(v)) +} + +//SetExecID sets ExecID, Tag 17 +func (m ExecutionReport) SetExecID(v string) { + m.Set(field.NewExecID(v)) +} + +//SetExecInst sets ExecInst, Tag 18 +func (m ExecutionReport) SetExecInst(v string) { + m.Set(field.NewExecInst(v)) +} + +//SetExecRefID sets ExecRefID, Tag 19 +func (m ExecutionReport) SetExecRefID(v string) { + m.Set(field.NewExecRefID(v)) +} + +//SetHandlInst sets HandlInst, Tag 21 +func (m ExecutionReport) SetHandlInst(v string) { + m.Set(field.NewHandlInst(v)) +} + +//SetSecurityIDSource sets SecurityIDSource, Tag 22 +func (m ExecutionReport) SetSecurityIDSource(v string) { + m.Set(field.NewSecurityIDSource(v)) +} + +//SetLastCapacity sets LastCapacity, Tag 29 +func (m ExecutionReport) SetLastCapacity(v string) { + m.Set(field.NewLastCapacity(v)) +} + +//SetLastMkt sets LastMkt, Tag 30 +func (m ExecutionReport) SetLastMkt(v string) { + m.Set(field.NewLastMkt(v)) +} + +//SetLastPx sets LastPx, Tag 31 +func (m ExecutionReport) SetLastPx(v float64) { + m.Set(field.NewLastPx(v)) +} + +//SetLastQty sets LastQty, Tag 32 +func (m ExecutionReport) SetLastQty(v float64) { + m.Set(field.NewLastQty(v)) +} + +//SetOrderID sets OrderID, Tag 37 +func (m ExecutionReport) SetOrderID(v string) { + m.Set(field.NewOrderID(v)) +} + +//SetOrderQty sets OrderQty, Tag 38 +func (m ExecutionReport) SetOrderQty(v float64) { + m.Set(field.NewOrderQty(v)) +} + +//SetOrdStatus sets OrdStatus, Tag 39 +func (m ExecutionReport) SetOrdStatus(v string) { + m.Set(field.NewOrdStatus(v)) +} + +//SetOrdType sets OrdType, Tag 40 +func (m ExecutionReport) SetOrdType(v string) { + m.Set(field.NewOrdType(v)) +} + +//SetOrigClOrdID sets OrigClOrdID, Tag 41 +func (m ExecutionReport) SetOrigClOrdID(v string) { + m.Set(field.NewOrigClOrdID(v)) +} + +//SetPrice sets Price, Tag 44 +func (m ExecutionReport) SetPrice(v float64) { + m.Set(field.NewPrice(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m ExecutionReport) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSide sets Side, Tag 54 +func (m ExecutionReport) SetSide(v string) { + m.Set(field.NewSide(v)) +} + +//SetSymbol sets Symbol, Tag 55 +func (m ExecutionReport) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetText sets Text, Tag 58 +func (m ExecutionReport) SetText(v string) { + m.Set(field.NewText(v)) +} + +//SetTimeInForce sets TimeInForce, Tag 59 +func (m ExecutionReport) SetTimeInForce(v string) { + m.Set(field.NewTimeInForce(v)) +} + +//SetTransactTime sets TransactTime, Tag 60 +func (m ExecutionReport) SetTransactTime(v time.Time) { + m.Set(field.NewTransactTime(v)) +} + +//SetSettlType sets SettlType, Tag 63 +func (m ExecutionReport) SetSettlType(v string) { + m.Set(field.NewSettlType(v)) +} + +//SetSettlDate sets SettlDate, Tag 64 +func (m ExecutionReport) SetSettlDate(v string) { + m.Set(field.NewSettlDate(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m ExecutionReport) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetListID sets ListID, Tag 66 +func (m ExecutionReport) SetListID(v string) { + m.Set(field.NewListID(v)) +} + +//SetTradeDate sets TradeDate, Tag 75 +func (m ExecutionReport) SetTradeDate(v string) { + m.Set(field.NewTradeDate(v)) +} + +//SetPositionEffect sets PositionEffect, Tag 77 +func (m ExecutionReport) SetPositionEffect(v string) { + m.Set(field.NewPositionEffect(v)) +} + +//SetStopPx sets StopPx, Tag 99 +func (m ExecutionReport) SetStopPx(v float64) { + m.Set(field.NewStopPx(v)) +} + +//SetOrdRejReason sets OrdRejReason, Tag 103 +func (m ExecutionReport) SetOrdRejReason(v int) { + m.Set(field.NewOrdRejReason(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m ExecutionReport) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m ExecutionReport) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetMinQty sets MinQty, Tag 110 +func (m ExecutionReport) SetMinQty(v float64) { + m.Set(field.NewMinQty(v)) +} + +//SetMaxFloor sets MaxFloor, Tag 111 +func (m ExecutionReport) SetMaxFloor(v float64) { + m.Set(field.NewMaxFloor(v)) +} + +//SetReportToExch sets ReportToExch, Tag 113 +func (m ExecutionReport) SetReportToExch(v bool) { + m.Set(field.NewReportToExch(v)) +} + +//SetNetMoney sets NetMoney, Tag 118 +func (m ExecutionReport) SetNetMoney(v float64) { + m.Set(field.NewNetMoney(v)) +} + +//SetSettlCurrAmt sets SettlCurrAmt, Tag 119 +func (m ExecutionReport) SetSettlCurrAmt(v float64) { + m.Set(field.NewSettlCurrAmt(v)) +} + +//SetSettlCurrency sets SettlCurrency, Tag 120 +func (m ExecutionReport) SetSettlCurrency(v string) { + m.Set(field.NewSettlCurrency(v)) +} + +//SetExpireTime sets ExpireTime, Tag 126 +func (m ExecutionReport) SetExpireTime(v time.Time) { + m.Set(field.NewExpireTime(v)) +} + +//SetNoMiscFees sets NoMiscFees, Tag 136 +func (m ExecutionReport) SetNoMiscFees(f NoMiscFeesRepeatingGroup) { + m.SetGroup(f) +} + +//SetExecType sets ExecType, Tag 150 +func (m ExecutionReport) SetExecType(v string) { + m.Set(field.NewExecType(v)) +} + +//SetLeavesQty sets LeavesQty, Tag 151 +func (m ExecutionReport) SetLeavesQty(v float64) { + m.Set(field.NewLeavesQty(v)) +} + +//SetCashOrderQty sets CashOrderQty, Tag 152 +func (m ExecutionReport) SetCashOrderQty(v float64) { + m.Set(field.NewCashOrderQty(v)) +} + +//SetSettlCurrFxRate sets SettlCurrFxRate, Tag 155 +func (m ExecutionReport) SetSettlCurrFxRate(v float64) { + m.Set(field.NewSettlCurrFxRate(v)) +} + +//SetSettlCurrFxRateCalc sets SettlCurrFxRateCalc, Tag 156 +func (m ExecutionReport) SetSettlCurrFxRateCalc(v string) { + m.Set(field.NewSettlCurrFxRateCalc(v)) +} + +//SetNumDaysInterest sets NumDaysInterest, Tag 157 +func (m ExecutionReport) SetNumDaysInterest(v int) { + m.Set(field.NewNumDaysInterest(v)) +} + +//SetAccruedInterestRate sets AccruedInterestRate, Tag 158 +func (m ExecutionReport) SetAccruedInterestRate(v float64) { + m.Set(field.NewAccruedInterestRate(v)) +} + +//SetAccruedInterestAmt sets AccruedInterestAmt, Tag 159 +func (m ExecutionReport) SetAccruedInterestAmt(v float64) { + m.Set(field.NewAccruedInterestAmt(v)) +} + +//SetSecurityType sets SecurityType, Tag 167 +func (m ExecutionReport) SetSecurityType(v string) { + m.Set(field.NewSecurityType(v)) +} + +//SetEffectiveTime sets EffectiveTime, Tag 168 +func (m ExecutionReport) SetEffectiveTime(v time.Time) { + m.Set(field.NewEffectiveTime(v)) +} + +//SetOrderQty2 sets OrderQty2, Tag 192 +func (m ExecutionReport) SetOrderQty2(v float64) { + m.Set(field.NewOrderQty2(v)) +} + +//SetSettlDate2 sets SettlDate2, Tag 193 +func (m ExecutionReport) SetSettlDate2(v string) { + m.Set(field.NewSettlDate2(v)) +} + +//SetLastSpotRate sets LastSpotRate, Tag 194 +func (m ExecutionReport) SetLastSpotRate(v float64) { + m.Set(field.NewLastSpotRate(v)) +} + +//SetLastForwardPoints sets LastForwardPoints, Tag 195 +func (m ExecutionReport) SetLastForwardPoints(v float64) { + m.Set(field.NewLastForwardPoints(v)) +} + +//SetSecondaryOrderID sets SecondaryOrderID, Tag 198 +func (m ExecutionReport) SetSecondaryOrderID(v string) { + m.Set(field.NewSecondaryOrderID(v)) +} + +//SetMaturityMonthYear sets MaturityMonthYear, Tag 200 +func (m ExecutionReport) SetMaturityMonthYear(v string) { + m.Set(field.NewMaturityMonthYear(v)) +} + +//SetStrikePrice sets StrikePrice, Tag 202 +func (m ExecutionReport) SetStrikePrice(v float64) { + m.Set(field.NewStrikePrice(v)) +} + +//SetOptAttribute sets OptAttribute, Tag 206 +func (m ExecutionReport) SetOptAttribute(v string) { + m.Set(field.NewOptAttribute(v)) +} + +//SetSecurityExchange sets SecurityExchange, Tag 207 +func (m ExecutionReport) SetSecurityExchange(v string) { + m.Set(field.NewSecurityExchange(v)) +} + +//SetMaxShow sets MaxShow, Tag 210 +func (m ExecutionReport) SetMaxShow(v float64) { + m.Set(field.NewMaxShow(v)) +} + +//SetPegOffsetValue sets PegOffsetValue, Tag 211 +func (m ExecutionReport) SetPegOffsetValue(v float64) { + m.Set(field.NewPegOffsetValue(v)) +} + +//SetSpread sets Spread, Tag 218 +func (m ExecutionReport) SetSpread(v float64) { + m.Set(field.NewSpread(v)) +} + +//SetBenchmarkCurveCurrency sets BenchmarkCurveCurrency, Tag 220 +func (m ExecutionReport) SetBenchmarkCurveCurrency(v string) { + m.Set(field.NewBenchmarkCurveCurrency(v)) +} + +//SetBenchmarkCurveName sets BenchmarkCurveName, Tag 221 +func (m ExecutionReport) SetBenchmarkCurveName(v string) { + m.Set(field.NewBenchmarkCurveName(v)) +} + +//SetBenchmarkCurvePoint sets BenchmarkCurvePoint, Tag 222 +func (m ExecutionReport) SetBenchmarkCurvePoint(v string) { + m.Set(field.NewBenchmarkCurvePoint(v)) +} + +//SetCouponRate sets CouponRate, Tag 223 +func (m ExecutionReport) SetCouponRate(v float64) { + m.Set(field.NewCouponRate(v)) +} + +//SetCouponPaymentDate sets CouponPaymentDate, Tag 224 +func (m ExecutionReport) SetCouponPaymentDate(v string) { + m.Set(field.NewCouponPaymentDate(v)) +} + +//SetIssueDate sets IssueDate, Tag 225 +func (m ExecutionReport) SetIssueDate(v string) { + m.Set(field.NewIssueDate(v)) +} + +//SetRepurchaseTerm sets RepurchaseTerm, Tag 226 +func (m ExecutionReport) SetRepurchaseTerm(v int) { + m.Set(field.NewRepurchaseTerm(v)) +} + +//SetRepurchaseRate sets RepurchaseRate, Tag 227 +func (m ExecutionReport) SetRepurchaseRate(v float64) { + m.Set(field.NewRepurchaseRate(v)) +} + +//SetFactor sets Factor, Tag 228 +func (m ExecutionReport) SetFactor(v float64) { + m.Set(field.NewFactor(v)) +} + +//SetTradeOriginationDate sets TradeOriginationDate, Tag 229 +func (m ExecutionReport) SetTradeOriginationDate(v string) { + m.Set(field.NewTradeOriginationDate(v)) +} + +//SetExDate sets ExDate, Tag 230 +func (m ExecutionReport) SetExDate(v string) { + m.Set(field.NewExDate(v)) +} + +//SetContractMultiplier sets ContractMultiplier, Tag 231 +func (m ExecutionReport) SetContractMultiplier(v float64) { + m.Set(field.NewContractMultiplier(v)) +} + +//SetNoStipulations sets NoStipulations, Tag 232 +func (m ExecutionReport) SetNoStipulations(f NoStipulationsRepeatingGroup) { + m.SetGroup(f) +} + +//SetYieldType sets YieldType, Tag 235 +func (m ExecutionReport) SetYieldType(v string) { + m.Set(field.NewYieldType(v)) +} + +//SetYield sets Yield, Tag 236 +func (m ExecutionReport) SetYield(v float64) { + m.Set(field.NewYield(v)) +} + +//SetTotalTakedown sets TotalTakedown, Tag 237 +func (m ExecutionReport) SetTotalTakedown(v float64) { + m.Set(field.NewTotalTakedown(v)) +} + +//SetConcession sets Concession, Tag 238 +func (m ExecutionReport) SetConcession(v float64) { + m.Set(field.NewConcession(v)) +} + +//SetRepoCollateralSecurityType sets RepoCollateralSecurityType, Tag 239 +func (m ExecutionReport) SetRepoCollateralSecurityType(v int) { + m.Set(field.NewRepoCollateralSecurityType(v)) +} + +//SetRedemptionDate sets RedemptionDate, Tag 240 +func (m ExecutionReport) SetRedemptionDate(v string) { + m.Set(field.NewRedemptionDate(v)) +} + +//SetCreditRating sets CreditRating, Tag 255 +func (m ExecutionReport) SetCreditRating(v string) { + m.Set(field.NewCreditRating(v)) +} + +//SetTradedFlatSwitch sets TradedFlatSwitch, Tag 258 +func (m ExecutionReport) SetTradedFlatSwitch(v bool) { + m.Set(field.NewTradedFlatSwitch(v)) +} + +//SetBasisFeatureDate sets BasisFeatureDate, Tag 259 +func (m ExecutionReport) SetBasisFeatureDate(v string) { + m.Set(field.NewBasisFeatureDate(v)) +} + +//SetBasisFeaturePrice sets BasisFeaturePrice, Tag 260 +func (m ExecutionReport) SetBasisFeaturePrice(v float64) { + m.Set(field.NewBasisFeaturePrice(v)) +} + +//SetTradingSessionID sets TradingSessionID, Tag 336 +func (m ExecutionReport) SetTradingSessionID(v string) { + m.Set(field.NewTradingSessionID(v)) +} + +//SetEncodedIssuerLen sets EncodedIssuerLen, Tag 348 +func (m ExecutionReport) SetEncodedIssuerLen(v int) { + m.Set(field.NewEncodedIssuerLen(v)) +} + +//SetEncodedIssuer sets EncodedIssuer, Tag 349 +func (m ExecutionReport) SetEncodedIssuer(v string) { + m.Set(field.NewEncodedIssuer(v)) +} + +//SetEncodedSecurityDescLen sets EncodedSecurityDescLen, Tag 350 +func (m ExecutionReport) SetEncodedSecurityDescLen(v int) { + m.Set(field.NewEncodedSecurityDescLen(v)) +} + +//SetEncodedSecurityDesc sets EncodedSecurityDesc, Tag 351 +func (m ExecutionReport) SetEncodedSecurityDesc(v string) { + m.Set(field.NewEncodedSecurityDesc(v)) +} + +//SetEncodedTextLen sets EncodedTextLen, Tag 354 +func (m ExecutionReport) SetEncodedTextLen(v int) { + m.Set(field.NewEncodedTextLen(v)) +} + +//SetEncodedText sets EncodedText, Tag 355 +func (m ExecutionReport) SetEncodedText(v string) { + m.Set(field.NewEncodedText(v)) +} + +//SetComplianceID sets ComplianceID, Tag 376 +func (m ExecutionReport) SetComplianceID(v string) { + m.Set(field.NewComplianceID(v)) +} + +//SetSolicitedFlag sets SolicitedFlag, Tag 377 +func (m ExecutionReport) SetSolicitedFlag(v bool) { + m.Set(field.NewSolicitedFlag(v)) +} + +//SetExecRestatementReason sets ExecRestatementReason, Tag 378 +func (m ExecutionReport) SetExecRestatementReason(v int) { + m.Set(field.NewExecRestatementReason(v)) +} + +//SetGrossTradeAmt sets GrossTradeAmt, Tag 381 +func (m ExecutionReport) SetGrossTradeAmt(v float64) { + m.Set(field.NewGrossTradeAmt(v)) +} + +//SetNoContraBrokers sets NoContraBrokers, Tag 382 +func (m ExecutionReport) SetNoContraBrokers(f NoContraBrokersRepeatingGroup) { + m.SetGroup(f) +} + +//SetDiscretionInst sets DiscretionInst, Tag 388 +func (m ExecutionReport) SetDiscretionInst(v string) { + m.Set(field.NewDiscretionInst(v)) +} + +//SetDiscretionOffsetValue sets DiscretionOffsetValue, Tag 389 +func (m ExecutionReport) SetDiscretionOffsetValue(v float64) { + m.Set(field.NewDiscretionOffsetValue(v)) +} + +//SetPriceType sets PriceType, Tag 423 +func (m ExecutionReport) SetPriceType(v int) { + m.Set(field.NewPriceType(v)) +} + +//SetDayOrderQty sets DayOrderQty, Tag 424 +func (m ExecutionReport) SetDayOrderQty(v float64) { + m.Set(field.NewDayOrderQty(v)) +} + +//SetDayCumQty sets DayCumQty, Tag 425 +func (m ExecutionReport) SetDayCumQty(v float64) { + m.Set(field.NewDayCumQty(v)) +} + +//SetDayAvgPx sets DayAvgPx, Tag 426 +func (m ExecutionReport) SetDayAvgPx(v float64) { + m.Set(field.NewDayAvgPx(v)) +} + +//SetGTBookingInst sets GTBookingInst, Tag 427 +func (m ExecutionReport) SetGTBookingInst(v int) { + m.Set(field.NewGTBookingInst(v)) +} + +//SetExpireDate sets ExpireDate, Tag 432 +func (m ExecutionReport) SetExpireDate(v string) { + m.Set(field.NewExpireDate(v)) +} + +//SetMultiLegReportingType sets MultiLegReportingType, Tag 442 +func (m ExecutionReport) SetMultiLegReportingType(v string) { + m.Set(field.NewMultiLegReportingType(v)) +} + +//SetNoPartyIDs sets NoPartyIDs, Tag 453 +func (m ExecutionReport) SetNoPartyIDs(f NoPartyIDsRepeatingGroup) { + m.SetGroup(f) +} + +//SetNoSecurityAltID sets NoSecurityAltID, Tag 454 +func (m ExecutionReport) SetNoSecurityAltID(f NoSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetProduct sets Product, Tag 460 +func (m ExecutionReport) SetProduct(v int) { + m.Set(field.NewProduct(v)) +} + +//SetCFICode sets CFICode, Tag 461 +func (m ExecutionReport) SetCFICode(v string) { + m.Set(field.NewCFICode(v)) +} + +//SetRoundingDirection sets RoundingDirection, Tag 468 +func (m ExecutionReport) SetRoundingDirection(v string) { + m.Set(field.NewRoundingDirection(v)) +} + +//SetRoundingModulus sets RoundingModulus, Tag 469 +func (m ExecutionReport) SetRoundingModulus(v float64) { + m.Set(field.NewRoundingModulus(v)) +} + +//SetCountryOfIssue sets CountryOfIssue, Tag 470 +func (m ExecutionReport) SetCountryOfIssue(v string) { + m.Set(field.NewCountryOfIssue(v)) +} + +//SetStateOrProvinceOfIssue sets StateOrProvinceOfIssue, Tag 471 +func (m ExecutionReport) SetStateOrProvinceOfIssue(v string) { + m.Set(field.NewStateOrProvinceOfIssue(v)) +} + +//SetLocaleOfIssue sets LocaleOfIssue, Tag 472 +func (m ExecutionReport) SetLocaleOfIssue(v string) { + m.Set(field.NewLocaleOfIssue(v)) +} + +//SetCommCurrency sets CommCurrency, Tag 479 +func (m ExecutionReport) SetCommCurrency(v string) { + m.Set(field.NewCommCurrency(v)) +} + +//SetCancellationRights sets CancellationRights, Tag 480 +func (m ExecutionReport) SetCancellationRights(v string) { + m.Set(field.NewCancellationRights(v)) +} + +//SetMoneyLaunderingStatus sets MoneyLaunderingStatus, Tag 481 +func (m ExecutionReport) SetMoneyLaunderingStatus(v string) { + m.Set(field.NewMoneyLaunderingStatus(v)) +} + +//SetTransBkdTime sets TransBkdTime, Tag 483 +func (m ExecutionReport) SetTransBkdTime(v time.Time) { + m.Set(field.NewTransBkdTime(v)) +} + +//SetExecPriceType sets ExecPriceType, Tag 484 +func (m ExecutionReport) SetExecPriceType(v string) { + m.Set(field.NewExecPriceType(v)) +} + +//SetExecPriceAdjustment sets ExecPriceAdjustment, Tag 485 +func (m ExecutionReport) SetExecPriceAdjustment(v float64) { + m.Set(field.NewExecPriceAdjustment(v)) +} + +//SetDesignation sets Designation, Tag 494 +func (m ExecutionReport) SetDesignation(v string) { + m.Set(field.NewDesignation(v)) +} + +//SetFundRenewWaiv sets FundRenewWaiv, Tag 497 +func (m ExecutionReport) SetFundRenewWaiv(v string) { + m.Set(field.NewFundRenewWaiv(v)) +} + +//SetRegistID sets RegistID, Tag 513 +func (m ExecutionReport) SetRegistID(v string) { + m.Set(field.NewRegistID(v)) +} + +//SetExecValuationPoint sets ExecValuationPoint, Tag 515 +func (m ExecutionReport) SetExecValuationPoint(v time.Time) { + m.Set(field.NewExecValuationPoint(v)) +} + +//SetOrderPercent sets OrderPercent, Tag 516 +func (m ExecutionReport) SetOrderPercent(v float64) { + m.Set(field.NewOrderPercent(v)) +} + +//SetNoContAmts sets NoContAmts, Tag 518 +func (m ExecutionReport) SetNoContAmts(f NoContAmtsRepeatingGroup) { + m.SetGroup(f) +} + +//SetSecondaryClOrdID sets SecondaryClOrdID, Tag 526 +func (m ExecutionReport) SetSecondaryClOrdID(v string) { + m.Set(field.NewSecondaryClOrdID(v)) +} + +//SetSecondaryExecID sets SecondaryExecID, Tag 527 +func (m ExecutionReport) SetSecondaryExecID(v string) { + m.Set(field.NewSecondaryExecID(v)) +} + +//SetOrderCapacity sets OrderCapacity, Tag 528 +func (m ExecutionReport) SetOrderCapacity(v string) { + m.Set(field.NewOrderCapacity(v)) +} + +//SetOrderRestrictions sets OrderRestrictions, Tag 529 +func (m ExecutionReport) SetOrderRestrictions(v string) { + m.Set(field.NewOrderRestrictions(v)) +} + +//SetMaturityDate sets MaturityDate, Tag 541 +func (m ExecutionReport) SetMaturityDate(v string) { + m.Set(field.NewMaturityDate(v)) +} + +//SetInstrRegistry sets InstrRegistry, Tag 543 +func (m ExecutionReport) SetInstrRegistry(v string) { + m.Set(field.NewInstrRegistry(v)) +} + +//SetCashMargin sets CashMargin, Tag 544 +func (m ExecutionReport) SetCashMargin(v string) { + m.Set(field.NewCashMargin(v)) +} + +//SetCrossID sets CrossID, Tag 548 +func (m ExecutionReport) SetCrossID(v string) { + m.Set(field.NewCrossID(v)) +} + +//SetCrossType sets CrossType, Tag 549 +func (m ExecutionReport) SetCrossType(v int) { + m.Set(field.NewCrossType(v)) +} + +//SetOrigCrossID sets OrigCrossID, Tag 551 +func (m ExecutionReport) SetOrigCrossID(v string) { + m.Set(field.NewOrigCrossID(v)) +} + +//SetNoLegs sets NoLegs, Tag 555 +func (m ExecutionReport) SetNoLegs(f NoLegsRepeatingGroup) { + m.SetGroup(f) +} + +//SetAccountType sets AccountType, Tag 581 +func (m ExecutionReport) SetAccountType(v int) { + m.Set(field.NewAccountType(v)) +} + +//SetCustOrderCapacity sets CustOrderCapacity, Tag 582 +func (m ExecutionReport) SetCustOrderCapacity(v int) { + m.Set(field.NewCustOrderCapacity(v)) +} + +//SetClOrdLinkID sets ClOrdLinkID, Tag 583 +func (m ExecutionReport) SetClOrdLinkID(v string) { + m.Set(field.NewClOrdLinkID(v)) +} + +//SetMassStatusReqID sets MassStatusReqID, Tag 584 +func (m ExecutionReport) SetMassStatusReqID(v string) { + m.Set(field.NewMassStatusReqID(v)) +} + +//SetDayBookingInst sets DayBookingInst, Tag 589 +func (m ExecutionReport) SetDayBookingInst(v string) { + m.Set(field.NewDayBookingInst(v)) +} + +//SetBookingUnit sets BookingUnit, Tag 590 +func (m ExecutionReport) SetBookingUnit(v string) { + m.Set(field.NewBookingUnit(v)) +} + +//SetPreallocMethod sets PreallocMethod, Tag 591 +func (m ExecutionReport) SetPreallocMethod(v string) { + m.Set(field.NewPreallocMethod(v)) +} + +//SetTradingSessionSubID sets TradingSessionSubID, Tag 625 +func (m ExecutionReport) SetTradingSessionSubID(v string) { + m.Set(field.NewTradingSessionSubID(v)) +} + +//SetClearingFeeIndicator sets ClearingFeeIndicator, Tag 635 +func (m ExecutionReport) SetClearingFeeIndicator(v string) { + m.Set(field.NewClearingFeeIndicator(v)) +} + +//SetWorkingIndicator sets WorkingIndicator, Tag 636 +func (m ExecutionReport) SetWorkingIndicator(v bool) { + m.Set(field.NewWorkingIndicator(v)) +} + +//SetPriorityIndicator sets PriorityIndicator, Tag 638 +func (m ExecutionReport) SetPriorityIndicator(v int) { + m.Set(field.NewPriorityIndicator(v)) +} + +//SetPriceImprovement sets PriceImprovement, Tag 639 +func (m ExecutionReport) SetPriceImprovement(v float64) { + m.Set(field.NewPriceImprovement(v)) +} + +//SetLastForwardPoints2 sets LastForwardPoints2, Tag 641 +func (m ExecutionReport) SetLastForwardPoints2(v float64) { + m.Set(field.NewLastForwardPoints2(v)) +} + +//SetUnderlyingLastPx sets UnderlyingLastPx, Tag 651 +func (m ExecutionReport) SetUnderlyingLastPx(v float64) { + m.Set(field.NewUnderlyingLastPx(v)) +} + +//SetUnderlyingLastQty sets UnderlyingLastQty, Tag 652 +func (m ExecutionReport) SetUnderlyingLastQty(v float64) { + m.Set(field.NewUnderlyingLastQty(v)) +} + +//SetAcctIDSource sets AcctIDSource, Tag 660 +func (m ExecutionReport) SetAcctIDSource(v int) { + m.Set(field.NewAcctIDSource(v)) +} + +//SetBenchmarkPrice sets BenchmarkPrice, Tag 662 +func (m ExecutionReport) SetBenchmarkPrice(v float64) { + m.Set(field.NewBenchmarkPrice(v)) +} + +//SetBenchmarkPriceType sets BenchmarkPriceType, Tag 663 +func (m ExecutionReport) SetBenchmarkPriceType(v int) { + m.Set(field.NewBenchmarkPriceType(v)) +} + +//SetContractSettlMonth sets ContractSettlMonth, Tag 667 +func (m ExecutionReport) SetContractSettlMonth(v string) { + m.Set(field.NewContractSettlMonth(v)) +} + +//SetLastParPx sets LastParPx, Tag 669 +func (m ExecutionReport) SetLastParPx(v float64) { + m.Set(field.NewLastParPx(v)) +} + +//SetPool sets Pool, Tag 691 +func (m ExecutionReport) SetPool(v string) { + m.Set(field.NewPool(v)) +} + +//SetQuoteRespID sets QuoteRespID, Tag 693 +func (m ExecutionReport) SetQuoteRespID(v string) { + m.Set(field.NewQuoteRespID(v)) +} + +//SetYieldRedemptionDate sets YieldRedemptionDate, Tag 696 +func (m ExecutionReport) SetYieldRedemptionDate(v string) { + m.Set(field.NewYieldRedemptionDate(v)) +} + +//SetYieldRedemptionPrice sets YieldRedemptionPrice, Tag 697 +func (m ExecutionReport) SetYieldRedemptionPrice(v float64) { + m.Set(field.NewYieldRedemptionPrice(v)) +} + +//SetYieldRedemptionPriceType sets YieldRedemptionPriceType, Tag 698 +func (m ExecutionReport) SetYieldRedemptionPriceType(v int) { + m.Set(field.NewYieldRedemptionPriceType(v)) +} + +//SetBenchmarkSecurityID sets BenchmarkSecurityID, Tag 699 +func (m ExecutionReport) SetBenchmarkSecurityID(v string) { + m.Set(field.NewBenchmarkSecurityID(v)) +} + +//SetYieldCalcDate sets YieldCalcDate, Tag 701 +func (m ExecutionReport) SetYieldCalcDate(v string) { + m.Set(field.NewYieldCalcDate(v)) +} + +//SetNoUnderlyings sets NoUnderlyings, Tag 711 +func (m ExecutionReport) SetNoUnderlyings(f NoUnderlyingsRepeatingGroup) { + m.SetGroup(f) +} + +//SetInterestAtMaturity sets InterestAtMaturity, Tag 738 +func (m ExecutionReport) SetInterestAtMaturity(v float64) { + m.Set(field.NewInterestAtMaturity(v)) +} + +//SetBenchmarkSecurityIDSource sets BenchmarkSecurityIDSource, Tag 761 +func (m ExecutionReport) SetBenchmarkSecurityIDSource(v string) { + m.Set(field.NewBenchmarkSecurityIDSource(v)) +} + +//SetSecuritySubType sets SecuritySubType, Tag 762 +func (m ExecutionReport) SetSecuritySubType(v string) { + m.Set(field.NewSecuritySubType(v)) +} + +//SetBookingType sets BookingType, Tag 775 +func (m ExecutionReport) SetBookingType(v int) { + m.Set(field.NewBookingType(v)) +} + +//SetTerminationType sets TerminationType, Tag 788 +func (m ExecutionReport) SetTerminationType(v int) { + m.Set(field.NewTerminationType(v)) +} + +//SetOrdStatusReqID sets OrdStatusReqID, Tag 790 +func (m ExecutionReport) SetOrdStatusReqID(v string) { + m.Set(field.NewOrdStatusReqID(v)) +} + +//SetCopyMsgIndicator sets CopyMsgIndicator, Tag 797 +func (m ExecutionReport) SetCopyMsgIndicator(v bool) { + m.Set(field.NewCopyMsgIndicator(v)) +} + +//SetPegMoveType sets PegMoveType, Tag 835 +func (m ExecutionReport) SetPegMoveType(v int) { + m.Set(field.NewPegMoveType(v)) +} + +//SetPegOffsetType sets PegOffsetType, Tag 836 +func (m ExecutionReport) SetPegOffsetType(v int) { + m.Set(field.NewPegOffsetType(v)) +} + +//SetPegLimitType sets PegLimitType, Tag 837 +func (m ExecutionReport) SetPegLimitType(v int) { + m.Set(field.NewPegLimitType(v)) +} + +//SetPegRoundDirection sets PegRoundDirection, Tag 838 +func (m ExecutionReport) SetPegRoundDirection(v int) { + m.Set(field.NewPegRoundDirection(v)) +} + +//SetPeggedPrice sets PeggedPrice, Tag 839 +func (m ExecutionReport) SetPeggedPrice(v float64) { + m.Set(field.NewPeggedPrice(v)) +} + +//SetPegScope sets PegScope, Tag 840 +func (m ExecutionReport) SetPegScope(v int) { + m.Set(field.NewPegScope(v)) +} + +//SetDiscretionMoveType sets DiscretionMoveType, Tag 841 +func (m ExecutionReport) SetDiscretionMoveType(v int) { + m.Set(field.NewDiscretionMoveType(v)) +} + +//SetDiscretionOffsetType sets DiscretionOffsetType, Tag 842 +func (m ExecutionReport) SetDiscretionOffsetType(v int) { + m.Set(field.NewDiscretionOffsetType(v)) +} + +//SetDiscretionLimitType sets DiscretionLimitType, Tag 843 +func (m ExecutionReport) SetDiscretionLimitType(v int) { + m.Set(field.NewDiscretionLimitType(v)) +} + +//SetDiscretionRoundDirection sets DiscretionRoundDirection, Tag 844 +func (m ExecutionReport) SetDiscretionRoundDirection(v int) { + m.Set(field.NewDiscretionRoundDirection(v)) +} + +//SetDiscretionPrice sets DiscretionPrice, Tag 845 +func (m ExecutionReport) SetDiscretionPrice(v float64) { + m.Set(field.NewDiscretionPrice(v)) +} + +//SetDiscretionScope sets DiscretionScope, Tag 846 +func (m ExecutionReport) SetDiscretionScope(v int) { + m.Set(field.NewDiscretionScope(v)) +} + +//SetTargetStrategy sets TargetStrategy, Tag 847 +func (m ExecutionReport) SetTargetStrategy(v int) { + m.Set(field.NewTargetStrategy(v)) +} + +//SetTargetStrategyParameters sets TargetStrategyParameters, Tag 848 +func (m ExecutionReport) SetTargetStrategyParameters(v string) { + m.Set(field.NewTargetStrategyParameters(v)) +} + +//SetParticipationRate sets ParticipationRate, Tag 849 +func (m ExecutionReport) SetParticipationRate(v float64) { + m.Set(field.NewParticipationRate(v)) +} + +//SetTargetStrategyPerformance sets TargetStrategyPerformance, Tag 850 +func (m ExecutionReport) SetTargetStrategyPerformance(v float64) { + m.Set(field.NewTargetStrategyPerformance(v)) +} + +//SetLastLiquidityInd sets LastLiquidityInd, Tag 851 +func (m ExecutionReport) SetLastLiquidityInd(v int) { + m.Set(field.NewLastLiquidityInd(v)) +} + +//SetQtyType sets QtyType, Tag 854 +func (m ExecutionReport) SetQtyType(v int) { + m.Set(field.NewQtyType(v)) +} + +//SetNoEvents sets NoEvents, Tag 864 +func (m ExecutionReport) SetNoEvents(f NoEventsRepeatingGroup) { + m.SetGroup(f) +} + +//SetDatedDate sets DatedDate, Tag 873 +func (m ExecutionReport) SetDatedDate(v string) { + m.Set(field.NewDatedDate(v)) +} + +//SetInterestAccrualDate sets InterestAccrualDate, Tag 874 +func (m ExecutionReport) SetInterestAccrualDate(v string) { + m.Set(field.NewInterestAccrualDate(v)) +} + +//SetCPProgram sets CPProgram, Tag 875 +func (m ExecutionReport) SetCPProgram(v int) { + m.Set(field.NewCPProgram(v)) +} + +//SetCPRegType sets CPRegType, Tag 876 +func (m ExecutionReport) SetCPRegType(v string) { + m.Set(field.NewCPRegType(v)) +} + +//SetMarginRatio sets MarginRatio, Tag 898 +func (m ExecutionReport) SetMarginRatio(v float64) { + m.Set(field.NewMarginRatio(v)) +} + +//SetTotNumReports sets TotNumReports, Tag 911 +func (m ExecutionReport) SetTotNumReports(v int) { + m.Set(field.NewTotNumReports(v)) +} + +//SetLastRptRequested sets LastRptRequested, Tag 912 +func (m ExecutionReport) SetLastRptRequested(v bool) { + m.Set(field.NewLastRptRequested(v)) +} + +//SetAgreementDesc sets AgreementDesc, Tag 913 +func (m ExecutionReport) SetAgreementDesc(v string) { + m.Set(field.NewAgreementDesc(v)) +} + +//SetAgreementID sets AgreementID, Tag 914 +func (m ExecutionReport) SetAgreementID(v string) { + m.Set(field.NewAgreementID(v)) +} + +//SetAgreementDate sets AgreementDate, Tag 915 +func (m ExecutionReport) SetAgreementDate(v string) { + m.Set(field.NewAgreementDate(v)) +} + +//SetStartDate sets StartDate, Tag 916 +func (m ExecutionReport) SetStartDate(v string) { + m.Set(field.NewStartDate(v)) +} + +//SetEndDate sets EndDate, Tag 917 +func (m ExecutionReport) SetEndDate(v string) { + m.Set(field.NewEndDate(v)) +} + +//SetAgreementCurrency sets AgreementCurrency, Tag 918 +func (m ExecutionReport) SetAgreementCurrency(v string) { + m.Set(field.NewAgreementCurrency(v)) +} + +//SetDeliveryType sets DeliveryType, Tag 919 +func (m ExecutionReport) SetDeliveryType(v int) { + m.Set(field.NewDeliveryType(v)) +} + +//SetEndAccruedInterestAmt sets EndAccruedInterestAmt, Tag 920 +func (m ExecutionReport) SetEndAccruedInterestAmt(v float64) { + m.Set(field.NewEndAccruedInterestAmt(v)) +} + +//SetStartCash sets StartCash, Tag 921 +func (m ExecutionReport) SetStartCash(v float64) { + m.Set(field.NewStartCash(v)) +} + +//SetEndCash sets EndCash, Tag 922 +func (m ExecutionReport) SetEndCash(v float64) { + m.Set(field.NewEndCash(v)) +} + +//SetTimeBracket sets TimeBracket, Tag 943 +func (m ExecutionReport) SetTimeBracket(v string) { + m.Set(field.NewTimeBracket(v)) +} + +//SetStrikeCurrency sets StrikeCurrency, Tag 947 +func (m ExecutionReport) SetStrikeCurrency(v string) { + m.Set(field.NewStrikeCurrency(v)) +} + +//GetAccount gets Account, Tag 1 +func (m ExecutionReport) GetAccount() (f field.AccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAvgPx gets AvgPx, Tag 6 +func (m ExecutionReport) GetAvgPx() (f field.AvgPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdID gets ClOrdID, Tag 11 +func (m ExecutionReport) GetClOrdID() (f field.ClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommission gets Commission, Tag 12 +func (m ExecutionReport) GetCommission() (f field.CommissionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommType gets CommType, Tag 13 +func (m ExecutionReport) GetCommType() (f field.CommTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCumQty gets CumQty, Tag 14 +func (m ExecutionReport) GetCumQty() (f field.CumQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCurrency gets Currency, Tag 15 +func (m ExecutionReport) GetCurrency() (f field.CurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecID gets ExecID, Tag 17 +func (m ExecutionReport) GetExecID() (f field.ExecIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecInst gets ExecInst, Tag 18 +func (m ExecutionReport) GetExecInst() (f field.ExecInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecRefID gets ExecRefID, Tag 19 +func (m ExecutionReport) GetExecRefID() (f field.ExecRefIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetHandlInst gets HandlInst, Tag 21 +func (m ExecutionReport) GetHandlInst() (f field.HandlInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityIDSource gets SecurityIDSource, Tag 22 +func (m ExecutionReport) GetSecurityIDSource() (f field.SecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastCapacity gets LastCapacity, Tag 29 +func (m ExecutionReport) GetLastCapacity() (f field.LastCapacityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastMkt gets LastMkt, Tag 30 +func (m ExecutionReport) GetLastMkt() (f field.LastMktField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastPx gets LastPx, Tag 31 +func (m ExecutionReport) GetLastPx() (f field.LastPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastQty gets LastQty, Tag 32 +func (m ExecutionReport) GetLastQty() (f field.LastQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderID gets OrderID, Tag 37 +func (m ExecutionReport) GetOrderID() (f field.OrderIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty gets OrderQty, Tag 38 +func (m ExecutionReport) GetOrderQty() (f field.OrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdStatus gets OrdStatus, Tag 39 +func (m ExecutionReport) GetOrdStatus() (f field.OrdStatusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdType gets OrdType, Tag 40 +func (m ExecutionReport) GetOrdType() (f field.OrdTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrigClOrdID gets OrigClOrdID, Tag 41 +func (m ExecutionReport) GetOrigClOrdID() (f field.OrigClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrice gets Price, Tag 44 +func (m ExecutionReport) GetPrice() (f field.PriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m ExecutionReport) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSide gets Side, Tag 54 +func (m ExecutionReport) GetSide() (f field.SideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbol gets Symbol, Tag 55 +func (m ExecutionReport) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetText gets Text, Tag 58 +func (m ExecutionReport) GetText() (f field.TextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTimeInForce gets TimeInForce, Tag 59 +func (m ExecutionReport) GetTimeInForce() (f field.TimeInForceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTransactTime gets TransactTime, Tag 60 +func (m ExecutionReport) GetTransactTime() (f field.TransactTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlType gets SettlType, Tag 63 +func (m ExecutionReport) GetSettlType() (f field.SettlTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlDate gets SettlDate, Tag 64 +func (m ExecutionReport) GetSettlDate() (f field.SettlDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m ExecutionReport) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetListID gets ListID, Tag 66 +func (m ExecutionReport) GetListID() (f field.ListIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradeDate gets TradeDate, Tag 75 +func (m ExecutionReport) GetTradeDate() (f field.TradeDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPositionEffect gets PositionEffect, Tag 77 +func (m ExecutionReport) GetPositionEffect() (f field.PositionEffectField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStopPx gets StopPx, Tag 99 +func (m ExecutionReport) GetStopPx() (f field.StopPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdRejReason gets OrdRejReason, Tag 103 +func (m ExecutionReport) GetOrdRejReason() (f field.OrdRejReasonField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m ExecutionReport) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m ExecutionReport) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMinQty gets MinQty, Tag 110 +func (m ExecutionReport) GetMinQty() (f field.MinQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxFloor gets MaxFloor, Tag 111 +func (m ExecutionReport) GetMaxFloor() (f field.MaxFloorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetReportToExch gets ReportToExch, Tag 113 +func (m ExecutionReport) GetReportToExch() (f field.ReportToExchField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNetMoney gets NetMoney, Tag 118 +func (m ExecutionReport) GetNetMoney() (f field.NetMoneyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrAmt gets SettlCurrAmt, Tag 119 +func (m ExecutionReport) GetSettlCurrAmt() (f field.SettlCurrAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrency gets SettlCurrency, Tag 120 +func (m ExecutionReport) GetSettlCurrency() (f field.SettlCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireTime gets ExpireTime, Tag 126 +func (m ExecutionReport) GetExpireTime() (f field.ExpireTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoMiscFees gets NoMiscFees, Tag 136 +func (m ExecutionReport) GetNoMiscFees() (NoMiscFeesRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoMiscFeesRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetExecType gets ExecType, Tag 150 +func (m ExecutionReport) GetExecType() (f field.ExecTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLeavesQty gets LeavesQty, Tag 151 +func (m ExecutionReport) GetLeavesQty() (f field.LeavesQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashOrderQty gets CashOrderQty, Tag 152 +func (m ExecutionReport) GetCashOrderQty() (f field.CashOrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrFxRate gets SettlCurrFxRate, Tag 155 +func (m ExecutionReport) GetSettlCurrFxRate() (f field.SettlCurrFxRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrFxRateCalc gets SettlCurrFxRateCalc, Tag 156 +func (m ExecutionReport) GetSettlCurrFxRateCalc() (f field.SettlCurrFxRateCalcField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNumDaysInterest gets NumDaysInterest, Tag 157 +func (m ExecutionReport) GetNumDaysInterest() (f field.NumDaysInterestField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAccruedInterestRate gets AccruedInterestRate, Tag 158 +func (m ExecutionReport) GetAccruedInterestRate() (f field.AccruedInterestRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAccruedInterestAmt gets AccruedInterestAmt, Tag 159 +func (m ExecutionReport) GetAccruedInterestAmt() (f field.AccruedInterestAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityType gets SecurityType, Tag 167 +func (m ExecutionReport) GetSecurityType() (f field.SecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEffectiveTime gets EffectiveTime, Tag 168 +func (m ExecutionReport) GetEffectiveTime() (f field.EffectiveTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty2 gets OrderQty2, Tag 192 +func (m ExecutionReport) GetOrderQty2() (f field.OrderQty2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlDate2 gets SettlDate2, Tag 193 +func (m ExecutionReport) GetSettlDate2() (f field.SettlDate2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastSpotRate gets LastSpotRate, Tag 194 +func (m ExecutionReport) GetLastSpotRate() (f field.LastSpotRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastForwardPoints gets LastForwardPoints, Tag 195 +func (m ExecutionReport) GetLastForwardPoints() (f field.LastForwardPointsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecondaryOrderID gets SecondaryOrderID, Tag 198 +func (m ExecutionReport) GetSecondaryOrderID() (f field.SecondaryOrderIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityMonthYear gets MaturityMonthYear, Tag 200 +func (m ExecutionReport) GetMaturityMonthYear() (f field.MaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikePrice gets StrikePrice, Tag 202 +func (m ExecutionReport) GetStrikePrice() (f field.StrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOptAttribute gets OptAttribute, Tag 206 +func (m ExecutionReport) GetOptAttribute() (f field.OptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityExchange gets SecurityExchange, Tag 207 +func (m ExecutionReport) GetSecurityExchange() (f field.SecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxShow gets MaxShow, Tag 210 +func (m ExecutionReport) GetMaxShow() (f field.MaxShowField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegOffsetValue gets PegOffsetValue, Tag 211 +func (m ExecutionReport) GetPegOffsetValue() (f field.PegOffsetValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSpread gets Spread, Tag 218 +func (m ExecutionReport) GetSpread() (f field.SpreadField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkCurveCurrency gets BenchmarkCurveCurrency, Tag 220 +func (m ExecutionReport) GetBenchmarkCurveCurrency() (f field.BenchmarkCurveCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkCurveName gets BenchmarkCurveName, Tag 221 +func (m ExecutionReport) GetBenchmarkCurveName() (f field.BenchmarkCurveNameField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkCurvePoint gets BenchmarkCurvePoint, Tag 222 +func (m ExecutionReport) GetBenchmarkCurvePoint() (f field.BenchmarkCurvePointField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponRate gets CouponRate, Tag 223 +func (m ExecutionReport) GetCouponRate() (f field.CouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponPaymentDate gets CouponPaymentDate, Tag 224 +func (m ExecutionReport) GetCouponPaymentDate() (f field.CouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssueDate gets IssueDate, Tag 225 +func (m ExecutionReport) GetIssueDate() (f field.IssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseTerm gets RepurchaseTerm, Tag 226 +func (m ExecutionReport) GetRepurchaseTerm() (f field.RepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseRate gets RepurchaseRate, Tag 227 +func (m ExecutionReport) GetRepurchaseRate() (f field.RepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFactor gets Factor, Tag 228 +func (m ExecutionReport) GetFactor() (f field.FactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradeOriginationDate gets TradeOriginationDate, Tag 229 +func (m ExecutionReport) GetTradeOriginationDate() (f field.TradeOriginationDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExDate gets ExDate, Tag 230 +func (m ExecutionReport) GetExDate() (f field.ExDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractMultiplier gets ContractMultiplier, Tag 231 +func (m ExecutionReport) GetContractMultiplier() (f field.ContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoStipulations gets NoStipulations, Tag 232 +func (m ExecutionReport) GetNoStipulations() (NoStipulationsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoStipulationsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetYieldType gets YieldType, Tag 235 +func (m ExecutionReport) GetYieldType() (f field.YieldTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYield gets Yield, Tag 236 +func (m ExecutionReport) GetYield() (f field.YieldField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTotalTakedown gets TotalTakedown, Tag 237 +func (m ExecutionReport) GetTotalTakedown() (f field.TotalTakedownField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetConcession gets Concession, Tag 238 +func (m ExecutionReport) GetConcession() (f field.ConcessionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepoCollateralSecurityType gets RepoCollateralSecurityType, Tag 239 +func (m ExecutionReport) GetRepoCollateralSecurityType() (f field.RepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRedemptionDate gets RedemptionDate, Tag 240 +func (m ExecutionReport) GetRedemptionDate() (f field.RedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCreditRating gets CreditRating, Tag 255 +func (m ExecutionReport) GetCreditRating() (f field.CreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradedFlatSwitch gets TradedFlatSwitch, Tag 258 +func (m ExecutionReport) GetTradedFlatSwitch() (f field.TradedFlatSwitchField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBasisFeatureDate gets BasisFeatureDate, Tag 259 +func (m ExecutionReport) GetBasisFeatureDate() (f field.BasisFeatureDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBasisFeaturePrice gets BasisFeaturePrice, Tag 260 +func (m ExecutionReport) GetBasisFeaturePrice() (f field.BasisFeaturePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradingSessionID gets TradingSessionID, Tag 336 +func (m ExecutionReport) GetTradingSessionID() (f field.TradingSessionIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuerLen gets EncodedIssuerLen, Tag 348 +func (m ExecutionReport) GetEncodedIssuerLen() (f field.EncodedIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuer gets EncodedIssuer, Tag 349 +func (m ExecutionReport) GetEncodedIssuer() (f field.EncodedIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDescLen gets EncodedSecurityDescLen, Tag 350 +func (m ExecutionReport) GetEncodedSecurityDescLen() (f field.EncodedSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDesc gets EncodedSecurityDesc, Tag 351 +func (m ExecutionReport) GetEncodedSecurityDesc() (f field.EncodedSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedTextLen gets EncodedTextLen, Tag 354 +func (m ExecutionReport) GetEncodedTextLen() (f field.EncodedTextLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedText gets EncodedText, Tag 355 +func (m ExecutionReport) GetEncodedText() (f field.EncodedTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetComplianceID gets ComplianceID, Tag 376 +func (m ExecutionReport) GetComplianceID() (f field.ComplianceIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSolicitedFlag gets SolicitedFlag, Tag 377 +func (m ExecutionReport) GetSolicitedFlag() (f field.SolicitedFlagField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecRestatementReason gets ExecRestatementReason, Tag 378 +func (m ExecutionReport) GetExecRestatementReason() (f field.ExecRestatementReasonField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetGrossTradeAmt gets GrossTradeAmt, Tag 381 +func (m ExecutionReport) GetGrossTradeAmt() (f field.GrossTradeAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoContraBrokers gets NoContraBrokers, Tag 382 +func (m ExecutionReport) GetNoContraBrokers() (NoContraBrokersRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoContraBrokersRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetDiscretionInst gets DiscretionInst, Tag 388 +func (m ExecutionReport) GetDiscretionInst() (f field.DiscretionInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionOffsetValue gets DiscretionOffsetValue, Tag 389 +func (m ExecutionReport) GetDiscretionOffsetValue() (f field.DiscretionOffsetValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPriceType gets PriceType, Tag 423 +func (m ExecutionReport) GetPriceType() (f field.PriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDayOrderQty gets DayOrderQty, Tag 424 +func (m ExecutionReport) GetDayOrderQty() (f field.DayOrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDayCumQty gets DayCumQty, Tag 425 +func (m ExecutionReport) GetDayCumQty() (f field.DayCumQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDayAvgPx gets DayAvgPx, Tag 426 +func (m ExecutionReport) GetDayAvgPx() (f field.DayAvgPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetGTBookingInst gets GTBookingInst, Tag 427 +func (m ExecutionReport) GetGTBookingInst() (f field.GTBookingInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireDate gets ExpireDate, Tag 432 +func (m ExecutionReport) GetExpireDate() (f field.ExpireDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMultiLegReportingType gets MultiLegReportingType, Tag 442 +func (m ExecutionReport) GetMultiLegReportingType() (f field.MultiLegReportingTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoPartyIDs gets NoPartyIDs, Tag 453 +func (m ExecutionReport) GetNoPartyIDs() (NoPartyIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoPartyIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetNoSecurityAltID gets NoSecurityAltID, Tag 454 +func (m ExecutionReport) GetNoSecurityAltID() (NoSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetProduct gets Product, Tag 460 +func (m ExecutionReport) GetProduct() (f field.ProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCFICode gets CFICode, Tag 461 +func (m ExecutionReport) GetCFICode() (f field.CFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRoundingDirection gets RoundingDirection, Tag 468 +func (m ExecutionReport) GetRoundingDirection() (f field.RoundingDirectionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRoundingModulus gets RoundingModulus, Tag 469 +func (m ExecutionReport) GetRoundingModulus() (f field.RoundingModulusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCountryOfIssue gets CountryOfIssue, Tag 470 +func (m ExecutionReport) GetCountryOfIssue() (f field.CountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStateOrProvinceOfIssue gets StateOrProvinceOfIssue, Tag 471 +func (m ExecutionReport) GetStateOrProvinceOfIssue() (f field.StateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLocaleOfIssue gets LocaleOfIssue, Tag 472 +func (m ExecutionReport) GetLocaleOfIssue() (f field.LocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommCurrency gets CommCurrency, Tag 479 +func (m ExecutionReport) GetCommCurrency() (f field.CommCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCancellationRights gets CancellationRights, Tag 480 +func (m ExecutionReport) GetCancellationRights() (f field.CancellationRightsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMoneyLaunderingStatus gets MoneyLaunderingStatus, Tag 481 +func (m ExecutionReport) GetMoneyLaunderingStatus() (f field.MoneyLaunderingStatusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTransBkdTime gets TransBkdTime, Tag 483 +func (m ExecutionReport) GetTransBkdTime() (f field.TransBkdTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecPriceType gets ExecPriceType, Tag 484 +func (m ExecutionReport) GetExecPriceType() (f field.ExecPriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecPriceAdjustment gets ExecPriceAdjustment, Tag 485 +func (m ExecutionReport) GetExecPriceAdjustment() (f field.ExecPriceAdjustmentField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDesignation gets Designation, Tag 494 +func (m ExecutionReport) GetDesignation() (f field.DesignationField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFundRenewWaiv gets FundRenewWaiv, Tag 497 +func (m ExecutionReport) GetFundRenewWaiv() (f field.FundRenewWaivField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRegistID gets RegistID, Tag 513 +func (m ExecutionReport) GetRegistID() (f field.RegistIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecValuationPoint gets ExecValuationPoint, Tag 515 +func (m ExecutionReport) GetExecValuationPoint() (f field.ExecValuationPointField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderPercent gets OrderPercent, Tag 516 +func (m ExecutionReport) GetOrderPercent() (f field.OrderPercentField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoContAmts gets NoContAmts, Tag 518 +func (m ExecutionReport) GetNoContAmts() (NoContAmtsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoContAmtsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetSecondaryClOrdID gets SecondaryClOrdID, Tag 526 +func (m ExecutionReport) GetSecondaryClOrdID() (f field.SecondaryClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecondaryExecID gets SecondaryExecID, Tag 527 +func (m ExecutionReport) GetSecondaryExecID() (f field.SecondaryExecIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderCapacity gets OrderCapacity, Tag 528 +func (m ExecutionReport) GetOrderCapacity() (f field.OrderCapacityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderRestrictions gets OrderRestrictions, Tag 529 +func (m ExecutionReport) GetOrderRestrictions() (f field.OrderRestrictionsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityDate gets MaturityDate, Tag 541 +func (m ExecutionReport) GetMaturityDate() (f field.MaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrRegistry gets InstrRegistry, Tag 543 +func (m ExecutionReport) GetInstrRegistry() (f field.InstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashMargin gets CashMargin, Tag 544 +func (m ExecutionReport) GetCashMargin() (f field.CashMarginField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCrossID gets CrossID, Tag 548 +func (m ExecutionReport) GetCrossID() (f field.CrossIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCrossType gets CrossType, Tag 549 +func (m ExecutionReport) GetCrossType() (f field.CrossTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrigCrossID gets OrigCrossID, Tag 551 +func (m ExecutionReport) GetOrigCrossID() (f field.OrigCrossIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoLegs gets NoLegs, Tag 555 +func (m ExecutionReport) GetNoLegs() (NoLegsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoLegsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetAccountType gets AccountType, Tag 581 +func (m ExecutionReport) GetAccountType() (f field.AccountTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCustOrderCapacity gets CustOrderCapacity, Tag 582 +func (m ExecutionReport) GetCustOrderCapacity() (f field.CustOrderCapacityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdLinkID gets ClOrdLinkID, Tag 583 +func (m ExecutionReport) GetClOrdLinkID() (f field.ClOrdLinkIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMassStatusReqID gets MassStatusReqID, Tag 584 +func (m ExecutionReport) GetMassStatusReqID() (f field.MassStatusReqIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDayBookingInst gets DayBookingInst, Tag 589 +func (m ExecutionReport) GetDayBookingInst() (f field.DayBookingInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBookingUnit gets BookingUnit, Tag 590 +func (m ExecutionReport) GetBookingUnit() (f field.BookingUnitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPreallocMethod gets PreallocMethod, Tag 591 +func (m ExecutionReport) GetPreallocMethod() (f field.PreallocMethodField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradingSessionSubID gets TradingSessionSubID, Tag 625 +func (m ExecutionReport) GetTradingSessionSubID() (f field.TradingSessionSubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClearingFeeIndicator gets ClearingFeeIndicator, Tag 635 +func (m ExecutionReport) GetClearingFeeIndicator() (f field.ClearingFeeIndicatorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetWorkingIndicator gets WorkingIndicator, Tag 636 +func (m ExecutionReport) GetWorkingIndicator() (f field.WorkingIndicatorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPriorityIndicator gets PriorityIndicator, Tag 638 +func (m ExecutionReport) GetPriorityIndicator() (f field.PriorityIndicatorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPriceImprovement gets PriceImprovement, Tag 639 +func (m ExecutionReport) GetPriceImprovement() (f field.PriceImprovementField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastForwardPoints2 gets LastForwardPoints2, Tag 641 +func (m ExecutionReport) GetLastForwardPoints2() (f field.LastForwardPoints2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingLastPx gets UnderlyingLastPx, Tag 651 +func (m ExecutionReport) GetUnderlyingLastPx() (f field.UnderlyingLastPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingLastQty gets UnderlyingLastQty, Tag 652 +func (m ExecutionReport) GetUnderlyingLastQty() (f field.UnderlyingLastQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAcctIDSource gets AcctIDSource, Tag 660 +func (m ExecutionReport) GetAcctIDSource() (f field.AcctIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkPrice gets BenchmarkPrice, Tag 662 +func (m ExecutionReport) GetBenchmarkPrice() (f field.BenchmarkPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkPriceType gets BenchmarkPriceType, Tag 663 +func (m ExecutionReport) GetBenchmarkPriceType() (f field.BenchmarkPriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractSettlMonth gets ContractSettlMonth, Tag 667 +func (m ExecutionReport) GetContractSettlMonth() (f field.ContractSettlMonthField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastParPx gets LastParPx, Tag 669 +func (m ExecutionReport) GetLastParPx() (f field.LastParPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPool gets Pool, Tag 691 +func (m ExecutionReport) GetPool() (f field.PoolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetQuoteRespID gets QuoteRespID, Tag 693 +func (m ExecutionReport) GetQuoteRespID() (f field.QuoteRespIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYieldRedemptionDate gets YieldRedemptionDate, Tag 696 +func (m ExecutionReport) GetYieldRedemptionDate() (f field.YieldRedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYieldRedemptionPrice gets YieldRedemptionPrice, Tag 697 +func (m ExecutionReport) GetYieldRedemptionPrice() (f field.YieldRedemptionPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYieldRedemptionPriceType gets YieldRedemptionPriceType, Tag 698 +func (m ExecutionReport) GetYieldRedemptionPriceType() (f field.YieldRedemptionPriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkSecurityID gets BenchmarkSecurityID, Tag 699 +func (m ExecutionReport) GetBenchmarkSecurityID() (f field.BenchmarkSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYieldCalcDate gets YieldCalcDate, Tag 701 +func (m ExecutionReport) GetYieldCalcDate() (f field.YieldCalcDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyings gets NoUnderlyings, Tag 711 +func (m ExecutionReport) GetNoUnderlyings() (NoUnderlyingsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetInterestAtMaturity gets InterestAtMaturity, Tag 738 +func (m ExecutionReport) GetInterestAtMaturity() (f field.InterestAtMaturityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkSecurityIDSource gets BenchmarkSecurityIDSource, Tag 761 +func (m ExecutionReport) GetBenchmarkSecurityIDSource() (f field.BenchmarkSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecuritySubType gets SecuritySubType, Tag 762 +func (m ExecutionReport) GetSecuritySubType() (f field.SecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBookingType gets BookingType, Tag 775 +func (m ExecutionReport) GetBookingType() (f field.BookingTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTerminationType gets TerminationType, Tag 788 +func (m ExecutionReport) GetTerminationType() (f field.TerminationTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdStatusReqID gets OrdStatusReqID, Tag 790 +func (m ExecutionReport) GetOrdStatusReqID() (f field.OrdStatusReqIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCopyMsgIndicator gets CopyMsgIndicator, Tag 797 +func (m ExecutionReport) GetCopyMsgIndicator() (f field.CopyMsgIndicatorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegMoveType gets PegMoveType, Tag 835 +func (m ExecutionReport) GetPegMoveType() (f field.PegMoveTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegOffsetType gets PegOffsetType, Tag 836 +func (m ExecutionReport) GetPegOffsetType() (f field.PegOffsetTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegLimitType gets PegLimitType, Tag 837 +func (m ExecutionReport) GetPegLimitType() (f field.PegLimitTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegRoundDirection gets PegRoundDirection, Tag 838 +func (m ExecutionReport) GetPegRoundDirection() (f field.PegRoundDirectionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPeggedPrice gets PeggedPrice, Tag 839 +func (m ExecutionReport) GetPeggedPrice() (f field.PeggedPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegScope gets PegScope, Tag 840 +func (m ExecutionReport) GetPegScope() (f field.PegScopeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionMoveType gets DiscretionMoveType, Tag 841 +func (m ExecutionReport) GetDiscretionMoveType() (f field.DiscretionMoveTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionOffsetType gets DiscretionOffsetType, Tag 842 +func (m ExecutionReport) GetDiscretionOffsetType() (f field.DiscretionOffsetTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionLimitType gets DiscretionLimitType, Tag 843 +func (m ExecutionReport) GetDiscretionLimitType() (f field.DiscretionLimitTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionRoundDirection gets DiscretionRoundDirection, Tag 844 +func (m ExecutionReport) GetDiscretionRoundDirection() (f field.DiscretionRoundDirectionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionPrice gets DiscretionPrice, Tag 845 +func (m ExecutionReport) GetDiscretionPrice() (f field.DiscretionPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionScope gets DiscretionScope, Tag 846 +func (m ExecutionReport) GetDiscretionScope() (f field.DiscretionScopeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTargetStrategy gets TargetStrategy, Tag 847 +func (m ExecutionReport) GetTargetStrategy() (f field.TargetStrategyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTargetStrategyParameters gets TargetStrategyParameters, Tag 848 +func (m ExecutionReport) GetTargetStrategyParameters() (f field.TargetStrategyParametersField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetParticipationRate gets ParticipationRate, Tag 849 +func (m ExecutionReport) GetParticipationRate() (f field.ParticipationRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTargetStrategyPerformance gets TargetStrategyPerformance, Tag 850 +func (m ExecutionReport) GetTargetStrategyPerformance() (f field.TargetStrategyPerformanceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastLiquidityInd gets LastLiquidityInd, Tag 851 +func (m ExecutionReport) GetLastLiquidityInd() (f field.LastLiquidityIndField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetQtyType gets QtyType, Tag 854 +func (m ExecutionReport) GetQtyType() (f field.QtyTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoEvents gets NoEvents, Tag 864 +func (m ExecutionReport) GetNoEvents() (NoEventsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoEventsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetDatedDate gets DatedDate, Tag 873 +func (m ExecutionReport) GetDatedDate() (f field.DatedDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInterestAccrualDate gets InterestAccrualDate, Tag 874 +func (m ExecutionReport) GetInterestAccrualDate() (f field.InterestAccrualDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCPProgram gets CPProgram, Tag 875 +func (m ExecutionReport) GetCPProgram() (f field.CPProgramField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCPRegType gets CPRegType, Tag 876 +func (m ExecutionReport) GetCPRegType() (f field.CPRegTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMarginRatio gets MarginRatio, Tag 898 +func (m ExecutionReport) GetMarginRatio() (f field.MarginRatioField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTotNumReports gets TotNumReports, Tag 911 +func (m ExecutionReport) GetTotNumReports() (f field.TotNumReportsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastRptRequested gets LastRptRequested, Tag 912 +func (m ExecutionReport) GetLastRptRequested() (f field.LastRptRequestedField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementDesc gets AgreementDesc, Tag 913 +func (m ExecutionReport) GetAgreementDesc() (f field.AgreementDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementID gets AgreementID, Tag 914 +func (m ExecutionReport) GetAgreementID() (f field.AgreementIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementDate gets AgreementDate, Tag 915 +func (m ExecutionReport) GetAgreementDate() (f field.AgreementDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStartDate gets StartDate, Tag 916 +func (m ExecutionReport) GetStartDate() (f field.StartDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEndDate gets EndDate, Tag 917 +func (m ExecutionReport) GetEndDate() (f field.EndDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementCurrency gets AgreementCurrency, Tag 918 +func (m ExecutionReport) GetAgreementCurrency() (f field.AgreementCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDeliveryType gets DeliveryType, Tag 919 +func (m ExecutionReport) GetDeliveryType() (f field.DeliveryTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEndAccruedInterestAmt gets EndAccruedInterestAmt, Tag 920 +func (m ExecutionReport) GetEndAccruedInterestAmt() (f field.EndAccruedInterestAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStartCash gets StartCash, Tag 921 +func (m ExecutionReport) GetStartCash() (f field.StartCashField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEndCash gets EndCash, Tag 922 +func (m ExecutionReport) GetEndCash() (f field.EndCashField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTimeBracket gets TimeBracket, Tag 943 +func (m ExecutionReport) GetTimeBracket() (f field.TimeBracketField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikeCurrency gets StrikeCurrency, Tag 947 +func (m ExecutionReport) GetStrikeCurrency() (f field.StrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasAccount returns true if Account is present, Tag 1 +func (m ExecutionReport) HasAccount() bool { + return m.Has(tag.Account) +} + +//HasAvgPx returns true if AvgPx is present, Tag 6 +func (m ExecutionReport) HasAvgPx() bool { + return m.Has(tag.AvgPx) +} + +//HasClOrdID returns true if ClOrdID is present, Tag 11 +func (m ExecutionReport) HasClOrdID() bool { + return m.Has(tag.ClOrdID) +} + +//HasCommission returns true if Commission is present, Tag 12 +func (m ExecutionReport) HasCommission() bool { + return m.Has(tag.Commission) +} + +//HasCommType returns true if CommType is present, Tag 13 +func (m ExecutionReport) HasCommType() bool { + return m.Has(tag.CommType) +} + +//HasCumQty returns true if CumQty is present, Tag 14 +func (m ExecutionReport) HasCumQty() bool { + return m.Has(tag.CumQty) +} + +//HasCurrency returns true if Currency is present, Tag 15 +func (m ExecutionReport) HasCurrency() bool { + return m.Has(tag.Currency) +} + +//HasExecID returns true if ExecID is present, Tag 17 +func (m ExecutionReport) HasExecID() bool { + return m.Has(tag.ExecID) +} + +//HasExecInst returns true if ExecInst is present, Tag 18 +func (m ExecutionReport) HasExecInst() bool { + return m.Has(tag.ExecInst) +} + +//HasExecRefID returns true if ExecRefID is present, Tag 19 +func (m ExecutionReport) HasExecRefID() bool { + return m.Has(tag.ExecRefID) +} + +//HasHandlInst returns true if HandlInst is present, Tag 21 +func (m ExecutionReport) HasHandlInst() bool { + return m.Has(tag.HandlInst) +} + +//HasSecurityIDSource returns true if SecurityIDSource is present, Tag 22 +func (m ExecutionReport) HasSecurityIDSource() bool { + return m.Has(tag.SecurityIDSource) +} + +//HasLastCapacity returns true if LastCapacity is present, Tag 29 +func (m ExecutionReport) HasLastCapacity() bool { + return m.Has(tag.LastCapacity) +} + +//HasLastMkt returns true if LastMkt is present, Tag 30 +func (m ExecutionReport) HasLastMkt() bool { + return m.Has(tag.LastMkt) +} + +//HasLastPx returns true if LastPx is present, Tag 31 +func (m ExecutionReport) HasLastPx() bool { + return m.Has(tag.LastPx) +} + +//HasLastQty returns true if LastQty is present, Tag 32 +func (m ExecutionReport) HasLastQty() bool { + return m.Has(tag.LastQty) +} + +//HasOrderID returns true if OrderID is present, Tag 37 +func (m ExecutionReport) HasOrderID() bool { + return m.Has(tag.OrderID) +} + +//HasOrderQty returns true if OrderQty is present, Tag 38 +func (m ExecutionReport) HasOrderQty() bool { + return m.Has(tag.OrderQty) +} + +//HasOrdStatus returns true if OrdStatus is present, Tag 39 +func (m ExecutionReport) HasOrdStatus() bool { + return m.Has(tag.OrdStatus) +} + +//HasOrdType returns true if OrdType is present, Tag 40 +func (m ExecutionReport) HasOrdType() bool { + return m.Has(tag.OrdType) +} + +//HasOrigClOrdID returns true if OrigClOrdID is present, Tag 41 +func (m ExecutionReport) HasOrigClOrdID() bool { + return m.Has(tag.OrigClOrdID) +} + +//HasPrice returns true if Price is present, Tag 44 +func (m ExecutionReport) HasPrice() bool { + return m.Has(tag.Price) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m ExecutionReport) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSide returns true if Side is present, Tag 54 +func (m ExecutionReport) HasSide() bool { + return m.Has(tag.Side) +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m ExecutionReport) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasText returns true if Text is present, Tag 58 +func (m ExecutionReport) HasText() bool { + return m.Has(tag.Text) +} + +//HasTimeInForce returns true if TimeInForce is present, Tag 59 +func (m ExecutionReport) HasTimeInForce() bool { + return m.Has(tag.TimeInForce) +} + +//HasTransactTime returns true if TransactTime is present, Tag 60 +func (m ExecutionReport) HasTransactTime() bool { + return m.Has(tag.TransactTime) +} + +//HasSettlType returns true if SettlType is present, Tag 63 +func (m ExecutionReport) HasSettlType() bool { + return m.Has(tag.SettlType) +} + +//HasSettlDate returns true if SettlDate is present, Tag 64 +func (m ExecutionReport) HasSettlDate() bool { + return m.Has(tag.SettlDate) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m ExecutionReport) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasListID returns true if ListID is present, Tag 66 +func (m ExecutionReport) HasListID() bool { + return m.Has(tag.ListID) +} + +//HasTradeDate returns true if TradeDate is present, Tag 75 +func (m ExecutionReport) HasTradeDate() bool { + return m.Has(tag.TradeDate) +} + +//HasPositionEffect returns true if PositionEffect is present, Tag 77 +func (m ExecutionReport) HasPositionEffect() bool { + return m.Has(tag.PositionEffect) +} + +//HasStopPx returns true if StopPx is present, Tag 99 +func (m ExecutionReport) HasStopPx() bool { + return m.Has(tag.StopPx) +} + +//HasOrdRejReason returns true if OrdRejReason is present, Tag 103 +func (m ExecutionReport) HasOrdRejReason() bool { + return m.Has(tag.OrdRejReason) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m ExecutionReport) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m ExecutionReport) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasMinQty returns true if MinQty is present, Tag 110 +func (m ExecutionReport) HasMinQty() bool { + return m.Has(tag.MinQty) +} + +//HasMaxFloor returns true if MaxFloor is present, Tag 111 +func (m ExecutionReport) HasMaxFloor() bool { + return m.Has(tag.MaxFloor) +} + +//HasReportToExch returns true if ReportToExch is present, Tag 113 +func (m ExecutionReport) HasReportToExch() bool { + return m.Has(tag.ReportToExch) +} + +//HasNetMoney returns true if NetMoney is present, Tag 118 +func (m ExecutionReport) HasNetMoney() bool { + return m.Has(tag.NetMoney) +} + +//HasSettlCurrAmt returns true if SettlCurrAmt is present, Tag 119 +func (m ExecutionReport) HasSettlCurrAmt() bool { + return m.Has(tag.SettlCurrAmt) +} + +//HasSettlCurrency returns true if SettlCurrency is present, Tag 120 +func (m ExecutionReport) HasSettlCurrency() bool { + return m.Has(tag.SettlCurrency) +} + +//HasExpireTime returns true if ExpireTime is present, Tag 126 +func (m ExecutionReport) HasExpireTime() bool { + return m.Has(tag.ExpireTime) +} + +//HasNoMiscFees returns true if NoMiscFees is present, Tag 136 +func (m ExecutionReport) HasNoMiscFees() bool { + return m.Has(tag.NoMiscFees) +} + +//HasExecType returns true if ExecType is present, Tag 150 +func (m ExecutionReport) HasExecType() bool { + return m.Has(tag.ExecType) +} + +//HasLeavesQty returns true if LeavesQty is present, Tag 151 +func (m ExecutionReport) HasLeavesQty() bool { + return m.Has(tag.LeavesQty) +} + +//HasCashOrderQty returns true if CashOrderQty is present, Tag 152 +func (m ExecutionReport) HasCashOrderQty() bool { + return m.Has(tag.CashOrderQty) +} + +//HasSettlCurrFxRate returns true if SettlCurrFxRate is present, Tag 155 +func (m ExecutionReport) HasSettlCurrFxRate() bool { + return m.Has(tag.SettlCurrFxRate) +} + +//HasSettlCurrFxRateCalc returns true if SettlCurrFxRateCalc is present, Tag 156 +func (m ExecutionReport) HasSettlCurrFxRateCalc() bool { + return m.Has(tag.SettlCurrFxRateCalc) +} + +//HasNumDaysInterest returns true if NumDaysInterest is present, Tag 157 +func (m ExecutionReport) HasNumDaysInterest() bool { + return m.Has(tag.NumDaysInterest) +} + +//HasAccruedInterestRate returns true if AccruedInterestRate is present, Tag 158 +func (m ExecutionReport) HasAccruedInterestRate() bool { + return m.Has(tag.AccruedInterestRate) +} + +//HasAccruedInterestAmt returns true if AccruedInterestAmt is present, Tag 159 +func (m ExecutionReport) HasAccruedInterestAmt() bool { + return m.Has(tag.AccruedInterestAmt) +} + +//HasSecurityType returns true if SecurityType is present, Tag 167 +func (m ExecutionReport) HasSecurityType() bool { + return m.Has(tag.SecurityType) +} + +//HasEffectiveTime returns true if EffectiveTime is present, Tag 168 +func (m ExecutionReport) HasEffectiveTime() bool { + return m.Has(tag.EffectiveTime) +} + +//HasOrderQty2 returns true if OrderQty2 is present, Tag 192 +func (m ExecutionReport) HasOrderQty2() bool { + return m.Has(tag.OrderQty2) +} + +//HasSettlDate2 returns true if SettlDate2 is present, Tag 193 +func (m ExecutionReport) HasSettlDate2() bool { + return m.Has(tag.SettlDate2) +} + +//HasLastSpotRate returns true if LastSpotRate is present, Tag 194 +func (m ExecutionReport) HasLastSpotRate() bool { + return m.Has(tag.LastSpotRate) +} + +//HasLastForwardPoints returns true if LastForwardPoints is present, Tag 195 +func (m ExecutionReport) HasLastForwardPoints() bool { + return m.Has(tag.LastForwardPoints) +} + +//HasSecondaryOrderID returns true if SecondaryOrderID is present, Tag 198 +func (m ExecutionReport) HasSecondaryOrderID() bool { + return m.Has(tag.SecondaryOrderID) +} + +//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200 +func (m ExecutionReport) HasMaturityMonthYear() bool { + return m.Has(tag.MaturityMonthYear) +} + +//HasStrikePrice returns true if StrikePrice is present, Tag 202 +func (m ExecutionReport) HasStrikePrice() bool { + return m.Has(tag.StrikePrice) +} + +//HasOptAttribute returns true if OptAttribute is present, Tag 206 +func (m ExecutionReport) HasOptAttribute() bool { + return m.Has(tag.OptAttribute) +} + +//HasSecurityExchange returns true if SecurityExchange is present, Tag 207 +func (m ExecutionReport) HasSecurityExchange() bool { + return m.Has(tag.SecurityExchange) +} + +//HasMaxShow returns true if MaxShow is present, Tag 210 +func (m ExecutionReport) HasMaxShow() bool { + return m.Has(tag.MaxShow) +} + +//HasPegOffsetValue returns true if PegOffsetValue is present, Tag 211 +func (m ExecutionReport) HasPegOffsetValue() bool { + return m.Has(tag.PegOffsetValue) +} + +//HasSpread returns true if Spread is present, Tag 218 +func (m ExecutionReport) HasSpread() bool { + return m.Has(tag.Spread) +} + +//HasBenchmarkCurveCurrency returns true if BenchmarkCurveCurrency is present, Tag 220 +func (m ExecutionReport) HasBenchmarkCurveCurrency() bool { + return m.Has(tag.BenchmarkCurveCurrency) +} + +//HasBenchmarkCurveName returns true if BenchmarkCurveName is present, Tag 221 +func (m ExecutionReport) HasBenchmarkCurveName() bool { + return m.Has(tag.BenchmarkCurveName) +} + +//HasBenchmarkCurvePoint returns true if BenchmarkCurvePoint is present, Tag 222 +func (m ExecutionReport) HasBenchmarkCurvePoint() bool { + return m.Has(tag.BenchmarkCurvePoint) +} + +//HasCouponRate returns true if CouponRate is present, Tag 223 +func (m ExecutionReport) HasCouponRate() bool { + return m.Has(tag.CouponRate) +} + +//HasCouponPaymentDate returns true if CouponPaymentDate is present, Tag 224 +func (m ExecutionReport) HasCouponPaymentDate() bool { + return m.Has(tag.CouponPaymentDate) +} + +//HasIssueDate returns true if IssueDate is present, Tag 225 +func (m ExecutionReport) HasIssueDate() bool { + return m.Has(tag.IssueDate) +} + +//HasRepurchaseTerm returns true if RepurchaseTerm is present, Tag 226 +func (m ExecutionReport) HasRepurchaseTerm() bool { + return m.Has(tag.RepurchaseTerm) +} + +//HasRepurchaseRate returns true if RepurchaseRate is present, Tag 227 +func (m ExecutionReport) HasRepurchaseRate() bool { + return m.Has(tag.RepurchaseRate) +} + +//HasFactor returns true if Factor is present, Tag 228 +func (m ExecutionReport) HasFactor() bool { + return m.Has(tag.Factor) +} + +//HasTradeOriginationDate returns true if TradeOriginationDate is present, Tag 229 +func (m ExecutionReport) HasTradeOriginationDate() bool { + return m.Has(tag.TradeOriginationDate) +} + +//HasExDate returns true if ExDate is present, Tag 230 +func (m ExecutionReport) HasExDate() bool { + return m.Has(tag.ExDate) +} + +//HasContractMultiplier returns true if ContractMultiplier is present, Tag 231 +func (m ExecutionReport) HasContractMultiplier() bool { + return m.Has(tag.ContractMultiplier) +} + +//HasNoStipulations returns true if NoStipulations is present, Tag 232 +func (m ExecutionReport) HasNoStipulations() bool { + return m.Has(tag.NoStipulations) +} + +//HasYieldType returns true if YieldType is present, Tag 235 +func (m ExecutionReport) HasYieldType() bool { + return m.Has(tag.YieldType) +} + +//HasYield returns true if Yield is present, Tag 236 +func (m ExecutionReport) HasYield() bool { + return m.Has(tag.Yield) +} + +//HasTotalTakedown returns true if TotalTakedown is present, Tag 237 +func (m ExecutionReport) HasTotalTakedown() bool { + return m.Has(tag.TotalTakedown) +} + +//HasConcession returns true if Concession is present, Tag 238 +func (m ExecutionReport) HasConcession() bool { + return m.Has(tag.Concession) +} + +//HasRepoCollateralSecurityType returns true if RepoCollateralSecurityType is present, Tag 239 +func (m ExecutionReport) HasRepoCollateralSecurityType() bool { + return m.Has(tag.RepoCollateralSecurityType) +} + +//HasRedemptionDate returns true if RedemptionDate is present, Tag 240 +func (m ExecutionReport) HasRedemptionDate() bool { + return m.Has(tag.RedemptionDate) +} + +//HasCreditRating returns true if CreditRating is present, Tag 255 +func (m ExecutionReport) HasCreditRating() bool { + return m.Has(tag.CreditRating) +} + +//HasTradedFlatSwitch returns true if TradedFlatSwitch is present, Tag 258 +func (m ExecutionReport) HasTradedFlatSwitch() bool { + return m.Has(tag.TradedFlatSwitch) +} + +//HasBasisFeatureDate returns true if BasisFeatureDate is present, Tag 259 +func (m ExecutionReport) HasBasisFeatureDate() bool { + return m.Has(tag.BasisFeatureDate) +} + +//HasBasisFeaturePrice returns true if BasisFeaturePrice is present, Tag 260 +func (m ExecutionReport) HasBasisFeaturePrice() bool { + return m.Has(tag.BasisFeaturePrice) +} + +//HasTradingSessionID returns true if TradingSessionID is present, Tag 336 +func (m ExecutionReport) HasTradingSessionID() bool { + return m.Has(tag.TradingSessionID) +} + +//HasEncodedIssuerLen returns true if EncodedIssuerLen is present, Tag 348 +func (m ExecutionReport) HasEncodedIssuerLen() bool { + return m.Has(tag.EncodedIssuerLen) +} + +//HasEncodedIssuer returns true if EncodedIssuer is present, Tag 349 +func (m ExecutionReport) HasEncodedIssuer() bool { + return m.Has(tag.EncodedIssuer) +} + +//HasEncodedSecurityDescLen returns true if EncodedSecurityDescLen is present, Tag 350 +func (m ExecutionReport) HasEncodedSecurityDescLen() bool { + return m.Has(tag.EncodedSecurityDescLen) +} + +//HasEncodedSecurityDesc returns true if EncodedSecurityDesc is present, Tag 351 +func (m ExecutionReport) HasEncodedSecurityDesc() bool { + return m.Has(tag.EncodedSecurityDesc) +} + +//HasEncodedTextLen returns true if EncodedTextLen is present, Tag 354 +func (m ExecutionReport) HasEncodedTextLen() bool { + return m.Has(tag.EncodedTextLen) +} + +//HasEncodedText returns true if EncodedText is present, Tag 355 +func (m ExecutionReport) HasEncodedText() bool { + return m.Has(tag.EncodedText) +} + +//HasComplianceID returns true if ComplianceID is present, Tag 376 +func (m ExecutionReport) HasComplianceID() bool { + return m.Has(tag.ComplianceID) +} + +//HasSolicitedFlag returns true if SolicitedFlag is present, Tag 377 +func (m ExecutionReport) HasSolicitedFlag() bool { + return m.Has(tag.SolicitedFlag) +} + +//HasExecRestatementReason returns true if ExecRestatementReason is present, Tag 378 +func (m ExecutionReport) HasExecRestatementReason() bool { + return m.Has(tag.ExecRestatementReason) +} + +//HasGrossTradeAmt returns true if GrossTradeAmt is present, Tag 381 +func (m ExecutionReport) HasGrossTradeAmt() bool { + return m.Has(tag.GrossTradeAmt) +} + +//HasNoContraBrokers returns true if NoContraBrokers is present, Tag 382 +func (m ExecutionReport) HasNoContraBrokers() bool { + return m.Has(tag.NoContraBrokers) +} + +//HasDiscretionInst returns true if DiscretionInst is present, Tag 388 +func (m ExecutionReport) HasDiscretionInst() bool { + return m.Has(tag.DiscretionInst) +} + +//HasDiscretionOffsetValue returns true if DiscretionOffsetValue is present, Tag 389 +func (m ExecutionReport) HasDiscretionOffsetValue() bool { + return m.Has(tag.DiscretionOffsetValue) +} + +//HasPriceType returns true if PriceType is present, Tag 423 +func (m ExecutionReport) HasPriceType() bool { + return m.Has(tag.PriceType) +} + +//HasDayOrderQty returns true if DayOrderQty is present, Tag 424 +func (m ExecutionReport) HasDayOrderQty() bool { + return m.Has(tag.DayOrderQty) +} + +//HasDayCumQty returns true if DayCumQty is present, Tag 425 +func (m ExecutionReport) HasDayCumQty() bool { + return m.Has(tag.DayCumQty) +} + +//HasDayAvgPx returns true if DayAvgPx is present, Tag 426 +func (m ExecutionReport) HasDayAvgPx() bool { + return m.Has(tag.DayAvgPx) +} + +//HasGTBookingInst returns true if GTBookingInst is present, Tag 427 +func (m ExecutionReport) HasGTBookingInst() bool { + return m.Has(tag.GTBookingInst) +} + +//HasExpireDate returns true if ExpireDate is present, Tag 432 +func (m ExecutionReport) HasExpireDate() bool { + return m.Has(tag.ExpireDate) +} + +//HasMultiLegReportingType returns true if MultiLegReportingType is present, Tag 442 +func (m ExecutionReport) HasMultiLegReportingType() bool { + return m.Has(tag.MultiLegReportingType) +} + +//HasNoPartyIDs returns true if NoPartyIDs is present, Tag 453 +func (m ExecutionReport) HasNoPartyIDs() bool { + return m.Has(tag.NoPartyIDs) +} + +//HasNoSecurityAltID returns true if NoSecurityAltID is present, Tag 454 +func (m ExecutionReport) HasNoSecurityAltID() bool { + return m.Has(tag.NoSecurityAltID) +} + +//HasProduct returns true if Product is present, Tag 460 +func (m ExecutionReport) HasProduct() bool { + return m.Has(tag.Product) +} + +//HasCFICode returns true if CFICode is present, Tag 461 +func (m ExecutionReport) HasCFICode() bool { + return m.Has(tag.CFICode) +} + +//HasRoundingDirection returns true if RoundingDirection is present, Tag 468 +func (m ExecutionReport) HasRoundingDirection() bool { + return m.Has(tag.RoundingDirection) +} + +//HasRoundingModulus returns true if RoundingModulus is present, Tag 469 +func (m ExecutionReport) HasRoundingModulus() bool { + return m.Has(tag.RoundingModulus) +} + +//HasCountryOfIssue returns true if CountryOfIssue is present, Tag 470 +func (m ExecutionReport) HasCountryOfIssue() bool { + return m.Has(tag.CountryOfIssue) +} + +//HasStateOrProvinceOfIssue returns true if StateOrProvinceOfIssue is present, Tag 471 +func (m ExecutionReport) HasStateOrProvinceOfIssue() bool { + return m.Has(tag.StateOrProvinceOfIssue) +} + +//HasLocaleOfIssue returns true if LocaleOfIssue is present, Tag 472 +func (m ExecutionReport) HasLocaleOfIssue() bool { + return m.Has(tag.LocaleOfIssue) +} + +//HasCommCurrency returns true if CommCurrency is present, Tag 479 +func (m ExecutionReport) HasCommCurrency() bool { + return m.Has(tag.CommCurrency) +} + +//HasCancellationRights returns true if CancellationRights is present, Tag 480 +func (m ExecutionReport) HasCancellationRights() bool { + return m.Has(tag.CancellationRights) +} + +//HasMoneyLaunderingStatus returns true if MoneyLaunderingStatus is present, Tag 481 +func (m ExecutionReport) HasMoneyLaunderingStatus() bool { + return m.Has(tag.MoneyLaunderingStatus) +} + +//HasTransBkdTime returns true if TransBkdTime is present, Tag 483 +func (m ExecutionReport) HasTransBkdTime() bool { + return m.Has(tag.TransBkdTime) +} + +//HasExecPriceType returns true if ExecPriceType is present, Tag 484 +func (m ExecutionReport) HasExecPriceType() bool { + return m.Has(tag.ExecPriceType) +} + +//HasExecPriceAdjustment returns true if ExecPriceAdjustment is present, Tag 485 +func (m ExecutionReport) HasExecPriceAdjustment() bool { + return m.Has(tag.ExecPriceAdjustment) +} + +//HasDesignation returns true if Designation is present, Tag 494 +func (m ExecutionReport) HasDesignation() bool { + return m.Has(tag.Designation) +} + +//HasFundRenewWaiv returns true if FundRenewWaiv is present, Tag 497 +func (m ExecutionReport) HasFundRenewWaiv() bool { + return m.Has(tag.FundRenewWaiv) +} + +//HasRegistID returns true if RegistID is present, Tag 513 +func (m ExecutionReport) HasRegistID() bool { + return m.Has(tag.RegistID) +} + +//HasExecValuationPoint returns true if ExecValuationPoint is present, Tag 515 +func (m ExecutionReport) HasExecValuationPoint() bool { + return m.Has(tag.ExecValuationPoint) +} + +//HasOrderPercent returns true if OrderPercent is present, Tag 516 +func (m ExecutionReport) HasOrderPercent() bool { + return m.Has(tag.OrderPercent) +} + +//HasNoContAmts returns true if NoContAmts is present, Tag 518 +func (m ExecutionReport) HasNoContAmts() bool { + return m.Has(tag.NoContAmts) +} + +//HasSecondaryClOrdID returns true if SecondaryClOrdID is present, Tag 526 +func (m ExecutionReport) HasSecondaryClOrdID() bool { + return m.Has(tag.SecondaryClOrdID) +} + +//HasSecondaryExecID returns true if SecondaryExecID is present, Tag 527 +func (m ExecutionReport) HasSecondaryExecID() bool { + return m.Has(tag.SecondaryExecID) +} + +//HasOrderCapacity returns true if OrderCapacity is present, Tag 528 +func (m ExecutionReport) HasOrderCapacity() bool { + return m.Has(tag.OrderCapacity) +} + +//HasOrderRestrictions returns true if OrderRestrictions is present, Tag 529 +func (m ExecutionReport) HasOrderRestrictions() bool { + return m.Has(tag.OrderRestrictions) +} + +//HasMaturityDate returns true if MaturityDate is present, Tag 541 +func (m ExecutionReport) HasMaturityDate() bool { + return m.Has(tag.MaturityDate) +} + +//HasInstrRegistry returns true if InstrRegistry is present, Tag 543 +func (m ExecutionReport) HasInstrRegistry() bool { + return m.Has(tag.InstrRegistry) +} + +//HasCashMargin returns true if CashMargin is present, Tag 544 +func (m ExecutionReport) HasCashMargin() bool { + return m.Has(tag.CashMargin) +} + +//HasCrossID returns true if CrossID is present, Tag 548 +func (m ExecutionReport) HasCrossID() bool { + return m.Has(tag.CrossID) +} + +//HasCrossType returns true if CrossType is present, Tag 549 +func (m ExecutionReport) HasCrossType() bool { + return m.Has(tag.CrossType) +} + +//HasOrigCrossID returns true if OrigCrossID is present, Tag 551 +func (m ExecutionReport) HasOrigCrossID() bool { + return m.Has(tag.OrigCrossID) +} + +//HasNoLegs returns true if NoLegs is present, Tag 555 +func (m ExecutionReport) HasNoLegs() bool { + return m.Has(tag.NoLegs) +} + +//HasAccountType returns true if AccountType is present, Tag 581 +func (m ExecutionReport) HasAccountType() bool { + return m.Has(tag.AccountType) +} + +//HasCustOrderCapacity returns true if CustOrderCapacity is present, Tag 582 +func (m ExecutionReport) HasCustOrderCapacity() bool { + return m.Has(tag.CustOrderCapacity) +} + +//HasClOrdLinkID returns true if ClOrdLinkID is present, Tag 583 +func (m ExecutionReport) HasClOrdLinkID() bool { + return m.Has(tag.ClOrdLinkID) +} + +//HasMassStatusReqID returns true if MassStatusReqID is present, Tag 584 +func (m ExecutionReport) HasMassStatusReqID() bool { + return m.Has(tag.MassStatusReqID) +} + +//HasDayBookingInst returns true if DayBookingInst is present, Tag 589 +func (m ExecutionReport) HasDayBookingInst() bool { + return m.Has(tag.DayBookingInst) +} + +//HasBookingUnit returns true if BookingUnit is present, Tag 590 +func (m ExecutionReport) HasBookingUnit() bool { + return m.Has(tag.BookingUnit) +} + +//HasPreallocMethod returns true if PreallocMethod is present, Tag 591 +func (m ExecutionReport) HasPreallocMethod() bool { + return m.Has(tag.PreallocMethod) +} + +//HasTradingSessionSubID returns true if TradingSessionSubID is present, Tag 625 +func (m ExecutionReport) HasTradingSessionSubID() bool { + return m.Has(tag.TradingSessionSubID) +} + +//HasClearingFeeIndicator returns true if ClearingFeeIndicator is present, Tag 635 +func (m ExecutionReport) HasClearingFeeIndicator() bool { + return m.Has(tag.ClearingFeeIndicator) +} + +//HasWorkingIndicator returns true if WorkingIndicator is present, Tag 636 +func (m ExecutionReport) HasWorkingIndicator() bool { + return m.Has(tag.WorkingIndicator) +} + +//HasPriorityIndicator returns true if PriorityIndicator is present, Tag 638 +func (m ExecutionReport) HasPriorityIndicator() bool { + return m.Has(tag.PriorityIndicator) +} + +//HasPriceImprovement returns true if PriceImprovement is present, Tag 639 +func (m ExecutionReport) HasPriceImprovement() bool { + return m.Has(tag.PriceImprovement) +} + +//HasLastForwardPoints2 returns true if LastForwardPoints2 is present, Tag 641 +func (m ExecutionReport) HasLastForwardPoints2() bool { + return m.Has(tag.LastForwardPoints2) +} + +//HasUnderlyingLastPx returns true if UnderlyingLastPx is present, Tag 651 +func (m ExecutionReport) HasUnderlyingLastPx() bool { + return m.Has(tag.UnderlyingLastPx) +} + +//HasUnderlyingLastQty returns true if UnderlyingLastQty is present, Tag 652 +func (m ExecutionReport) HasUnderlyingLastQty() bool { + return m.Has(tag.UnderlyingLastQty) +} + +//HasAcctIDSource returns true if AcctIDSource is present, Tag 660 +func (m ExecutionReport) HasAcctIDSource() bool { + return m.Has(tag.AcctIDSource) +} + +//HasBenchmarkPrice returns true if BenchmarkPrice is present, Tag 662 +func (m ExecutionReport) HasBenchmarkPrice() bool { + return m.Has(tag.BenchmarkPrice) +} + +//HasBenchmarkPriceType returns true if BenchmarkPriceType is present, Tag 663 +func (m ExecutionReport) HasBenchmarkPriceType() bool { + return m.Has(tag.BenchmarkPriceType) +} + +//HasContractSettlMonth returns true if ContractSettlMonth is present, Tag 667 +func (m ExecutionReport) HasContractSettlMonth() bool { + return m.Has(tag.ContractSettlMonth) +} + +//HasLastParPx returns true if LastParPx is present, Tag 669 +func (m ExecutionReport) HasLastParPx() bool { + return m.Has(tag.LastParPx) +} + +//HasPool returns true if Pool is present, Tag 691 +func (m ExecutionReport) HasPool() bool { + return m.Has(tag.Pool) +} + +//HasQuoteRespID returns true if QuoteRespID is present, Tag 693 +func (m ExecutionReport) HasQuoteRespID() bool { + return m.Has(tag.QuoteRespID) +} + +//HasYieldRedemptionDate returns true if YieldRedemptionDate is present, Tag 696 +func (m ExecutionReport) HasYieldRedemptionDate() bool { + return m.Has(tag.YieldRedemptionDate) +} + +//HasYieldRedemptionPrice returns true if YieldRedemptionPrice is present, Tag 697 +func (m ExecutionReport) HasYieldRedemptionPrice() bool { + return m.Has(tag.YieldRedemptionPrice) +} + +//HasYieldRedemptionPriceType returns true if YieldRedemptionPriceType is present, Tag 698 +func (m ExecutionReport) HasYieldRedemptionPriceType() bool { + return m.Has(tag.YieldRedemptionPriceType) +} + +//HasBenchmarkSecurityID returns true if BenchmarkSecurityID is present, Tag 699 +func (m ExecutionReport) HasBenchmarkSecurityID() bool { + return m.Has(tag.BenchmarkSecurityID) +} + +//HasYieldCalcDate returns true if YieldCalcDate is present, Tag 701 +func (m ExecutionReport) HasYieldCalcDate() bool { + return m.Has(tag.YieldCalcDate) +} + +//HasNoUnderlyings returns true if NoUnderlyings is present, Tag 711 +func (m ExecutionReport) HasNoUnderlyings() bool { + return m.Has(tag.NoUnderlyings) +} + +//HasInterestAtMaturity returns true if InterestAtMaturity is present, Tag 738 +func (m ExecutionReport) HasInterestAtMaturity() bool { + return m.Has(tag.InterestAtMaturity) +} + +//HasBenchmarkSecurityIDSource returns true if BenchmarkSecurityIDSource is present, Tag 761 +func (m ExecutionReport) HasBenchmarkSecurityIDSource() bool { + return m.Has(tag.BenchmarkSecurityIDSource) +} + +//HasSecuritySubType returns true if SecuritySubType is present, Tag 762 +func (m ExecutionReport) HasSecuritySubType() bool { + return m.Has(tag.SecuritySubType) +} + +//HasBookingType returns true if BookingType is present, Tag 775 +func (m ExecutionReport) HasBookingType() bool { + return m.Has(tag.BookingType) +} + +//HasTerminationType returns true if TerminationType is present, Tag 788 +func (m ExecutionReport) HasTerminationType() bool { + return m.Has(tag.TerminationType) +} + +//HasOrdStatusReqID returns true if OrdStatusReqID is present, Tag 790 +func (m ExecutionReport) HasOrdStatusReqID() bool { + return m.Has(tag.OrdStatusReqID) +} + +//HasCopyMsgIndicator returns true if CopyMsgIndicator is present, Tag 797 +func (m ExecutionReport) HasCopyMsgIndicator() bool { + return m.Has(tag.CopyMsgIndicator) +} + +//HasPegMoveType returns true if PegMoveType is present, Tag 835 +func (m ExecutionReport) HasPegMoveType() bool { + return m.Has(tag.PegMoveType) +} + +//HasPegOffsetType returns true if PegOffsetType is present, Tag 836 +func (m ExecutionReport) HasPegOffsetType() bool { + return m.Has(tag.PegOffsetType) +} + +//HasPegLimitType returns true if PegLimitType is present, Tag 837 +func (m ExecutionReport) HasPegLimitType() bool { + return m.Has(tag.PegLimitType) +} + +//HasPegRoundDirection returns true if PegRoundDirection is present, Tag 838 +func (m ExecutionReport) HasPegRoundDirection() bool { + return m.Has(tag.PegRoundDirection) +} + +//HasPeggedPrice returns true if PeggedPrice is present, Tag 839 +func (m ExecutionReport) HasPeggedPrice() bool { + return m.Has(tag.PeggedPrice) +} + +//HasPegScope returns true if PegScope is present, Tag 840 +func (m ExecutionReport) HasPegScope() bool { + return m.Has(tag.PegScope) +} + +//HasDiscretionMoveType returns true if DiscretionMoveType is present, Tag 841 +func (m ExecutionReport) HasDiscretionMoveType() bool { + return m.Has(tag.DiscretionMoveType) +} + +//HasDiscretionOffsetType returns true if DiscretionOffsetType is present, Tag 842 +func (m ExecutionReport) HasDiscretionOffsetType() bool { + return m.Has(tag.DiscretionOffsetType) +} + +//HasDiscretionLimitType returns true if DiscretionLimitType is present, Tag 843 +func (m ExecutionReport) HasDiscretionLimitType() bool { + return m.Has(tag.DiscretionLimitType) +} + +//HasDiscretionRoundDirection returns true if DiscretionRoundDirection is present, Tag 844 +func (m ExecutionReport) HasDiscretionRoundDirection() bool { + return m.Has(tag.DiscretionRoundDirection) +} + +//HasDiscretionPrice returns true if DiscretionPrice is present, Tag 845 +func (m ExecutionReport) HasDiscretionPrice() bool { + return m.Has(tag.DiscretionPrice) +} + +//HasDiscretionScope returns true if DiscretionScope is present, Tag 846 +func (m ExecutionReport) HasDiscretionScope() bool { + return m.Has(tag.DiscretionScope) +} + +//HasTargetStrategy returns true if TargetStrategy is present, Tag 847 +func (m ExecutionReport) HasTargetStrategy() bool { + return m.Has(tag.TargetStrategy) +} + +//HasTargetStrategyParameters returns true if TargetStrategyParameters is present, Tag 848 +func (m ExecutionReport) HasTargetStrategyParameters() bool { + return m.Has(tag.TargetStrategyParameters) +} + +//HasParticipationRate returns true if ParticipationRate is present, Tag 849 +func (m ExecutionReport) HasParticipationRate() bool { + return m.Has(tag.ParticipationRate) +} + +//HasTargetStrategyPerformance returns true if TargetStrategyPerformance is present, Tag 850 +func (m ExecutionReport) HasTargetStrategyPerformance() bool { + return m.Has(tag.TargetStrategyPerformance) +} + +//HasLastLiquidityInd returns true if LastLiquidityInd is present, Tag 851 +func (m ExecutionReport) HasLastLiquidityInd() bool { + return m.Has(tag.LastLiquidityInd) +} + +//HasQtyType returns true if QtyType is present, Tag 854 +func (m ExecutionReport) HasQtyType() bool { + return m.Has(tag.QtyType) +} + +//HasNoEvents returns true if NoEvents is present, Tag 864 +func (m ExecutionReport) HasNoEvents() bool { + return m.Has(tag.NoEvents) +} + +//HasDatedDate returns true if DatedDate is present, Tag 873 +func (m ExecutionReport) HasDatedDate() bool { + return m.Has(tag.DatedDate) +} + +//HasInterestAccrualDate returns true if InterestAccrualDate is present, Tag 874 +func (m ExecutionReport) HasInterestAccrualDate() bool { + return m.Has(tag.InterestAccrualDate) +} + +//HasCPProgram returns true if CPProgram is present, Tag 875 +func (m ExecutionReport) HasCPProgram() bool { + return m.Has(tag.CPProgram) +} + +//HasCPRegType returns true if CPRegType is present, Tag 876 +func (m ExecutionReport) HasCPRegType() bool { + return m.Has(tag.CPRegType) +} + +//HasMarginRatio returns true if MarginRatio is present, Tag 898 +func (m ExecutionReport) HasMarginRatio() bool { + return m.Has(tag.MarginRatio) +} + +//HasTotNumReports returns true if TotNumReports is present, Tag 911 +func (m ExecutionReport) HasTotNumReports() bool { + return m.Has(tag.TotNumReports) +} + +//HasLastRptRequested returns true if LastRptRequested is present, Tag 912 +func (m ExecutionReport) HasLastRptRequested() bool { + return m.Has(tag.LastRptRequested) +} + +//HasAgreementDesc returns true if AgreementDesc is present, Tag 913 +func (m ExecutionReport) HasAgreementDesc() bool { + return m.Has(tag.AgreementDesc) +} + +//HasAgreementID returns true if AgreementID is present, Tag 914 +func (m ExecutionReport) HasAgreementID() bool { + return m.Has(tag.AgreementID) +} + +//HasAgreementDate returns true if AgreementDate is present, Tag 915 +func (m ExecutionReport) HasAgreementDate() bool { + return m.Has(tag.AgreementDate) +} + +//HasStartDate returns true if StartDate is present, Tag 916 +func (m ExecutionReport) HasStartDate() bool { + return m.Has(tag.StartDate) +} + +//HasEndDate returns true if EndDate is present, Tag 917 +func (m ExecutionReport) HasEndDate() bool { + return m.Has(tag.EndDate) +} + +//HasAgreementCurrency returns true if AgreementCurrency is present, Tag 918 +func (m ExecutionReport) HasAgreementCurrency() bool { + return m.Has(tag.AgreementCurrency) +} + +//HasDeliveryType returns true if DeliveryType is present, Tag 919 +func (m ExecutionReport) HasDeliveryType() bool { + return m.Has(tag.DeliveryType) +} + +//HasEndAccruedInterestAmt returns true if EndAccruedInterestAmt is present, Tag 920 +func (m ExecutionReport) HasEndAccruedInterestAmt() bool { + return m.Has(tag.EndAccruedInterestAmt) +} + +//HasStartCash returns true if StartCash is present, Tag 921 +func (m ExecutionReport) HasStartCash() bool { + return m.Has(tag.StartCash) +} + +//HasEndCash returns true if EndCash is present, Tag 922 +func (m ExecutionReport) HasEndCash() bool { + return m.Has(tag.EndCash) +} + +//HasTimeBracket returns true if TimeBracket is present, Tag 943 +func (m ExecutionReport) HasTimeBracket() bool { + return m.Has(tag.TimeBracket) +} + +//HasStrikeCurrency returns true if StrikeCurrency is present, Tag 947 +func (m ExecutionReport) HasStrikeCurrency() bool { + return m.Has(tag.StrikeCurrency) +} + +//NoMiscFees is a repeating group element, Tag 136 +type NoMiscFees struct { + quickfix.Group +} + +//SetMiscFeeAmt sets MiscFeeAmt, Tag 137 +func (m NoMiscFees) SetMiscFeeAmt(v float64) { + m.Set(field.NewMiscFeeAmt(v)) +} + +//SetMiscFeeCurr sets MiscFeeCurr, Tag 138 +func (m NoMiscFees) SetMiscFeeCurr(v string) { + m.Set(field.NewMiscFeeCurr(v)) +} + +//SetMiscFeeType sets MiscFeeType, Tag 139 +func (m NoMiscFees) SetMiscFeeType(v string) { + m.Set(field.NewMiscFeeType(v)) +} + +//SetMiscFeeBasis sets MiscFeeBasis, Tag 891 +func (m NoMiscFees) SetMiscFeeBasis(v int) { + m.Set(field.NewMiscFeeBasis(v)) +} + +//GetMiscFeeAmt gets MiscFeeAmt, Tag 137 +func (m NoMiscFees) GetMiscFeeAmt() (f field.MiscFeeAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMiscFeeCurr gets MiscFeeCurr, Tag 138 +func (m NoMiscFees) GetMiscFeeCurr() (f field.MiscFeeCurrField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMiscFeeType gets MiscFeeType, Tag 139 +func (m NoMiscFees) GetMiscFeeType() (f field.MiscFeeTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMiscFeeBasis gets MiscFeeBasis, Tag 891 +func (m NoMiscFees) GetMiscFeeBasis() (f field.MiscFeeBasisField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasMiscFeeAmt returns true if MiscFeeAmt is present, Tag 137 +func (m NoMiscFees) HasMiscFeeAmt() bool { + return m.Has(tag.MiscFeeAmt) +} + +//HasMiscFeeCurr returns true if MiscFeeCurr is present, Tag 138 +func (m NoMiscFees) HasMiscFeeCurr() bool { + return m.Has(tag.MiscFeeCurr) +} + +//HasMiscFeeType returns true if MiscFeeType is present, Tag 139 +func (m NoMiscFees) HasMiscFeeType() bool { + return m.Has(tag.MiscFeeType) +} + +//HasMiscFeeBasis returns true if MiscFeeBasis is present, Tag 891 +func (m NoMiscFees) HasMiscFeeBasis() bool { + return m.Has(tag.MiscFeeBasis) +} + +//NoMiscFeesRepeatingGroup is a repeating group, Tag 136 +type NoMiscFeesRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoMiscFeesRepeatingGroup returns an initialized, NoMiscFeesRepeatingGroup +func NewNoMiscFeesRepeatingGroup() NoMiscFeesRepeatingGroup { + return NoMiscFeesRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoMiscFees, + quickfix.GroupTemplate{quickfix.GroupElement(tag.MiscFeeAmt), quickfix.GroupElement(tag.MiscFeeCurr), quickfix.GroupElement(tag.MiscFeeType), quickfix.GroupElement(tag.MiscFeeBasis)})} +} + +//Add create and append a new NoMiscFees to this group +func (m NoMiscFeesRepeatingGroup) Add() NoMiscFees { + g := m.RepeatingGroup.Add() + return NoMiscFees{g} +} + +//Get returns the ith NoMiscFees in the NoMiscFeesRepeatinGroup +func (m NoMiscFeesRepeatingGroup) Get(i int) NoMiscFees { + return NoMiscFees{m.RepeatingGroup.Get(i)} +} + +//NoStipulations is a repeating group element, Tag 232 +type NoStipulations struct { + quickfix.Group +} + +//SetStipulationType sets StipulationType, Tag 233 +func (m NoStipulations) SetStipulationType(v string) { + m.Set(field.NewStipulationType(v)) +} + +//SetStipulationValue sets StipulationValue, Tag 234 +func (m NoStipulations) SetStipulationValue(v string) { + m.Set(field.NewStipulationValue(v)) +} + +//GetStipulationType gets StipulationType, Tag 233 +func (m NoStipulations) GetStipulationType() (f field.StipulationTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStipulationValue gets StipulationValue, Tag 234 +func (m NoStipulations) GetStipulationValue() (f field.StipulationValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasStipulationType returns true if StipulationType is present, Tag 233 +func (m NoStipulations) HasStipulationType() bool { + return m.Has(tag.StipulationType) +} + +//HasStipulationValue returns true if StipulationValue is present, Tag 234 +func (m NoStipulations) HasStipulationValue() bool { + return m.Has(tag.StipulationValue) +} + +//NoStipulationsRepeatingGroup is a repeating group, Tag 232 +type NoStipulationsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoStipulationsRepeatingGroup returns an initialized, NoStipulationsRepeatingGroup +func NewNoStipulationsRepeatingGroup() NoStipulationsRepeatingGroup { + return NoStipulationsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoStipulations, + quickfix.GroupTemplate{quickfix.GroupElement(tag.StipulationType), quickfix.GroupElement(tag.StipulationValue)})} +} + +//Add create and append a new NoStipulations to this group +func (m NoStipulationsRepeatingGroup) Add() NoStipulations { + g := m.RepeatingGroup.Add() + return NoStipulations{g} +} + +//Get returns the ith NoStipulations in the NoStipulationsRepeatinGroup +func (m NoStipulationsRepeatingGroup) Get(i int) NoStipulations { + return NoStipulations{m.RepeatingGroup.Get(i)} +} + +//NoContraBrokers is a repeating group element, Tag 382 +type NoContraBrokers struct { + quickfix.Group +} + +//SetContraBroker sets ContraBroker, Tag 375 +func (m NoContraBrokers) SetContraBroker(v string) { + m.Set(field.NewContraBroker(v)) +} + +//SetContraTrader sets ContraTrader, Tag 337 +func (m NoContraBrokers) SetContraTrader(v string) { + m.Set(field.NewContraTrader(v)) +} + +//SetContraTradeQty sets ContraTradeQty, Tag 437 +func (m NoContraBrokers) SetContraTradeQty(v float64) { + m.Set(field.NewContraTradeQty(v)) +} + +//SetContraTradeTime sets ContraTradeTime, Tag 438 +func (m NoContraBrokers) SetContraTradeTime(v time.Time) { + m.Set(field.NewContraTradeTime(v)) +} + +//SetContraLegRefID sets ContraLegRefID, Tag 655 +func (m NoContraBrokers) SetContraLegRefID(v string) { + m.Set(field.NewContraLegRefID(v)) +} + +//GetContraBroker gets ContraBroker, Tag 375 +func (m NoContraBrokers) GetContraBroker() (f field.ContraBrokerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContraTrader gets ContraTrader, Tag 337 +func (m NoContraBrokers) GetContraTrader() (f field.ContraTraderField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContraTradeQty gets ContraTradeQty, Tag 437 +func (m NoContraBrokers) GetContraTradeQty() (f field.ContraTradeQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContraTradeTime gets ContraTradeTime, Tag 438 +func (m NoContraBrokers) GetContraTradeTime() (f field.ContraTradeTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContraLegRefID gets ContraLegRefID, Tag 655 +func (m NoContraBrokers) GetContraLegRefID() (f field.ContraLegRefIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasContraBroker returns true if ContraBroker is present, Tag 375 +func (m NoContraBrokers) HasContraBroker() bool { + return m.Has(tag.ContraBroker) +} + +//HasContraTrader returns true if ContraTrader is present, Tag 337 +func (m NoContraBrokers) HasContraTrader() bool { + return m.Has(tag.ContraTrader) +} + +//HasContraTradeQty returns true if ContraTradeQty is present, Tag 437 +func (m NoContraBrokers) HasContraTradeQty() bool { + return m.Has(tag.ContraTradeQty) +} + +//HasContraTradeTime returns true if ContraTradeTime is present, Tag 438 +func (m NoContraBrokers) HasContraTradeTime() bool { + return m.Has(tag.ContraTradeTime) +} + +//HasContraLegRefID returns true if ContraLegRefID is present, Tag 655 +func (m NoContraBrokers) HasContraLegRefID() bool { + return m.Has(tag.ContraLegRefID) +} + +//NoContraBrokersRepeatingGroup is a repeating group, Tag 382 +type NoContraBrokersRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoContraBrokersRepeatingGroup returns an initialized, NoContraBrokersRepeatingGroup +func NewNoContraBrokersRepeatingGroup() NoContraBrokersRepeatingGroup { + return NoContraBrokersRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoContraBrokers, + quickfix.GroupTemplate{quickfix.GroupElement(tag.ContraBroker), quickfix.GroupElement(tag.ContraTrader), quickfix.GroupElement(tag.ContraTradeQty), quickfix.GroupElement(tag.ContraTradeTime), quickfix.GroupElement(tag.ContraLegRefID)})} +} + +//Add create and append a new NoContraBrokers to this group +func (m NoContraBrokersRepeatingGroup) Add() NoContraBrokers { + g := m.RepeatingGroup.Add() + return NoContraBrokers{g} +} + +//Get returns the ith NoContraBrokers in the NoContraBrokersRepeatinGroup +func (m NoContraBrokersRepeatingGroup) Get(i int) NoContraBrokers { + return NoContraBrokers{m.RepeatingGroup.Get(i)} +} + +//NoPartyIDs is a repeating group element, Tag 453 +type NoPartyIDs struct { + quickfix.Group +} + +//SetPartyID sets PartyID, Tag 448 +func (m NoPartyIDs) SetPartyID(v string) { + m.Set(field.NewPartyID(v)) +} + +//SetPartyIDSource sets PartyIDSource, Tag 447 +func (m NoPartyIDs) SetPartyIDSource(v string) { + m.Set(field.NewPartyIDSource(v)) +} + +//SetPartyRole sets PartyRole, Tag 452 +func (m NoPartyIDs) SetPartyRole(v int) { + m.Set(field.NewPartyRole(v)) +} + +//SetNoPartySubIDs sets NoPartySubIDs, Tag 802 +func (m NoPartyIDs) SetNoPartySubIDs(f NoPartySubIDsRepeatingGroup) { + m.SetGroup(f) +} + +//GetPartyID gets PartyID, Tag 448 +func (m NoPartyIDs) GetPartyID() (f field.PartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartyIDSource gets PartyIDSource, Tag 447 +func (m NoPartyIDs) GetPartyIDSource() (f field.PartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartyRole gets PartyRole, Tag 452 +func (m NoPartyIDs) GetPartyRole() (f field.PartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoPartySubIDs gets NoPartySubIDs, Tag 802 +func (m NoPartyIDs) GetNoPartySubIDs() (NoPartySubIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoPartySubIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasPartyID returns true if PartyID is present, Tag 448 +func (m NoPartyIDs) HasPartyID() bool { + return m.Has(tag.PartyID) +} + +//HasPartyIDSource returns true if PartyIDSource is present, Tag 447 +func (m NoPartyIDs) HasPartyIDSource() bool { + return m.Has(tag.PartyIDSource) +} + +//HasPartyRole returns true if PartyRole is present, Tag 452 +func (m NoPartyIDs) HasPartyRole() bool { + return m.Has(tag.PartyRole) +} + +//HasNoPartySubIDs returns true if NoPartySubIDs is present, Tag 802 +func (m NoPartyIDs) HasNoPartySubIDs() bool { + return m.Has(tag.NoPartySubIDs) +} + +//NoPartySubIDs is a repeating group element, Tag 802 +type NoPartySubIDs struct { + quickfix.Group +} + +//SetPartySubID sets PartySubID, Tag 523 +func (m NoPartySubIDs) SetPartySubID(v string) { + m.Set(field.NewPartySubID(v)) +} + +//SetPartySubIDType sets PartySubIDType, Tag 803 +func (m NoPartySubIDs) SetPartySubIDType(v int) { + m.Set(field.NewPartySubIDType(v)) +} + +//GetPartySubID gets PartySubID, Tag 523 +func (m NoPartySubIDs) GetPartySubID() (f field.PartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartySubIDType gets PartySubIDType, Tag 803 +func (m NoPartySubIDs) GetPartySubIDType() (f field.PartySubIDTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasPartySubID returns true if PartySubID is present, Tag 523 +func (m NoPartySubIDs) HasPartySubID() bool { + return m.Has(tag.PartySubID) +} + +//HasPartySubIDType returns true if PartySubIDType is present, Tag 803 +func (m NoPartySubIDs) HasPartySubIDType() bool { + return m.Has(tag.PartySubIDType) +} + +//NoPartySubIDsRepeatingGroup is a repeating group, Tag 802 +type NoPartySubIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoPartySubIDsRepeatingGroup returns an initialized, NoPartySubIDsRepeatingGroup +func NewNoPartySubIDsRepeatingGroup() NoPartySubIDsRepeatingGroup { + return NoPartySubIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoPartySubIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.PartySubID), quickfix.GroupElement(tag.PartySubIDType)})} +} + +//Add create and append a new NoPartySubIDs to this group +func (m NoPartySubIDsRepeatingGroup) Add() NoPartySubIDs { + g := m.RepeatingGroup.Add() + return NoPartySubIDs{g} +} + +//Get returns the ith NoPartySubIDs in the NoPartySubIDsRepeatinGroup +func (m NoPartySubIDsRepeatingGroup) Get(i int) NoPartySubIDs { + return NoPartySubIDs{m.RepeatingGroup.Get(i)} +} + +//NoPartyIDsRepeatingGroup is a repeating group, Tag 453 +type NoPartyIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoPartyIDsRepeatingGroup returns an initialized, NoPartyIDsRepeatingGroup +func NewNoPartyIDsRepeatingGroup() NoPartyIDsRepeatingGroup { + return NoPartyIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoPartyIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.PartyID), quickfix.GroupElement(tag.PartyIDSource), quickfix.GroupElement(tag.PartyRole), NewNoPartySubIDsRepeatingGroup()})} +} + +//Add create and append a new NoPartyIDs to this group +func (m NoPartyIDsRepeatingGroup) Add() NoPartyIDs { + g := m.RepeatingGroup.Add() + return NoPartyIDs{g} +} + +//Get returns the ith NoPartyIDs in the NoPartyIDsRepeatinGroup +func (m NoPartyIDsRepeatingGroup) Get(i int) NoPartyIDs { + return NoPartyIDs{m.RepeatingGroup.Get(i)} +} + +//NoSecurityAltID is a repeating group element, Tag 454 +type NoSecurityAltID struct { + quickfix.Group +} + +//SetSecurityAltID sets SecurityAltID, Tag 455 +func (m NoSecurityAltID) SetSecurityAltID(v string) { + m.Set(field.NewSecurityAltID(v)) +} + +//SetSecurityAltIDSource sets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) SetSecurityAltIDSource(v string) { + m.Set(field.NewSecurityAltIDSource(v)) +} + +//GetSecurityAltID gets SecurityAltID, Tag 455 +func (m NoSecurityAltID) GetSecurityAltID() (f field.SecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityAltIDSource gets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) GetSecurityAltIDSource() (f field.SecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasSecurityAltID returns true if SecurityAltID is present, Tag 455 +func (m NoSecurityAltID) HasSecurityAltID() bool { + return m.Has(tag.SecurityAltID) +} + +//HasSecurityAltIDSource returns true if SecurityAltIDSource is present, Tag 456 +func (m NoSecurityAltID) HasSecurityAltIDSource() bool { + return m.Has(tag.SecurityAltIDSource) +} + +//NoSecurityAltIDRepeatingGroup is a repeating group, Tag 454 +type NoSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoSecurityAltIDRepeatingGroup returns an initialized, NoSecurityAltIDRepeatingGroup +func NewNoSecurityAltIDRepeatingGroup() NoSecurityAltIDRepeatingGroup { + return NoSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.SecurityAltID), quickfix.GroupElement(tag.SecurityAltIDSource)})} +} + +//Add create and append a new NoSecurityAltID to this group +func (m NoSecurityAltIDRepeatingGroup) Add() NoSecurityAltID { + g := m.RepeatingGroup.Add() + return NoSecurityAltID{g} +} + +//Get returns the ith NoSecurityAltID in the NoSecurityAltIDRepeatinGroup +func (m NoSecurityAltIDRepeatingGroup) Get(i int) NoSecurityAltID { + return NoSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoContAmts is a repeating group element, Tag 518 +type NoContAmts struct { + quickfix.Group +} + +//SetContAmtType sets ContAmtType, Tag 519 +func (m NoContAmts) SetContAmtType(v int) { + m.Set(field.NewContAmtType(v)) +} + +//SetContAmtValue sets ContAmtValue, Tag 520 +func (m NoContAmts) SetContAmtValue(v float64) { + m.Set(field.NewContAmtValue(v)) +} + +//SetContAmtCurr sets ContAmtCurr, Tag 521 +func (m NoContAmts) SetContAmtCurr(v string) { + m.Set(field.NewContAmtCurr(v)) +} + +//GetContAmtType gets ContAmtType, Tag 519 +func (m NoContAmts) GetContAmtType() (f field.ContAmtTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContAmtValue gets ContAmtValue, Tag 520 +func (m NoContAmts) GetContAmtValue() (f field.ContAmtValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContAmtCurr gets ContAmtCurr, Tag 521 +func (m NoContAmts) GetContAmtCurr() (f field.ContAmtCurrField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasContAmtType returns true if ContAmtType is present, Tag 519 +func (m NoContAmts) HasContAmtType() bool { + return m.Has(tag.ContAmtType) +} + +//HasContAmtValue returns true if ContAmtValue is present, Tag 520 +func (m NoContAmts) HasContAmtValue() bool { + return m.Has(tag.ContAmtValue) +} + +//HasContAmtCurr returns true if ContAmtCurr is present, Tag 521 +func (m NoContAmts) HasContAmtCurr() bool { + return m.Has(tag.ContAmtCurr) +} + +//NoContAmtsRepeatingGroup is a repeating group, Tag 518 +type NoContAmtsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoContAmtsRepeatingGroup returns an initialized, NoContAmtsRepeatingGroup +func NewNoContAmtsRepeatingGroup() NoContAmtsRepeatingGroup { + return NoContAmtsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoContAmts, + quickfix.GroupTemplate{quickfix.GroupElement(tag.ContAmtType), quickfix.GroupElement(tag.ContAmtValue), quickfix.GroupElement(tag.ContAmtCurr)})} +} + +//Add create and append a new NoContAmts to this group +func (m NoContAmtsRepeatingGroup) Add() NoContAmts { + g := m.RepeatingGroup.Add() + return NoContAmts{g} +} + +//Get returns the ith NoContAmts in the NoContAmtsRepeatinGroup +func (m NoContAmtsRepeatingGroup) Get(i int) NoContAmts { + return NoContAmts{m.RepeatingGroup.Get(i)} +} + +//NoLegs is a repeating group element, Tag 555 +type NoLegs struct { + quickfix.Group +} + +//SetLegSymbol sets LegSymbol, Tag 600 +func (m NoLegs) SetLegSymbol(v string) { + m.Set(field.NewLegSymbol(v)) +} + +//SetLegSymbolSfx sets LegSymbolSfx, Tag 601 +func (m NoLegs) SetLegSymbolSfx(v string) { + m.Set(field.NewLegSymbolSfx(v)) +} + +//SetLegSecurityID sets LegSecurityID, Tag 602 +func (m NoLegs) SetLegSecurityID(v string) { + m.Set(field.NewLegSecurityID(v)) +} + +//SetLegSecurityIDSource sets LegSecurityIDSource, Tag 603 +func (m NoLegs) SetLegSecurityIDSource(v string) { + m.Set(field.NewLegSecurityIDSource(v)) +} + +//SetNoLegSecurityAltID sets NoLegSecurityAltID, Tag 604 +func (m NoLegs) SetNoLegSecurityAltID(f NoLegSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetLegProduct sets LegProduct, Tag 607 +func (m NoLegs) SetLegProduct(v int) { + m.Set(field.NewLegProduct(v)) +} + +//SetLegCFICode sets LegCFICode, Tag 608 +func (m NoLegs) SetLegCFICode(v string) { + m.Set(field.NewLegCFICode(v)) +} + +//SetLegSecurityType sets LegSecurityType, Tag 609 +func (m NoLegs) SetLegSecurityType(v string) { + m.Set(field.NewLegSecurityType(v)) +} + +//SetLegSecuritySubType sets LegSecuritySubType, Tag 764 +func (m NoLegs) SetLegSecuritySubType(v string) { + m.Set(field.NewLegSecuritySubType(v)) +} + +//SetLegMaturityMonthYear sets LegMaturityMonthYear, Tag 610 +func (m NoLegs) SetLegMaturityMonthYear(v string) { + m.Set(field.NewLegMaturityMonthYear(v)) +} + +//SetLegMaturityDate sets LegMaturityDate, Tag 611 +func (m NoLegs) SetLegMaturityDate(v string) { + m.Set(field.NewLegMaturityDate(v)) +} + +//SetLegCouponPaymentDate sets LegCouponPaymentDate, Tag 248 +func (m NoLegs) SetLegCouponPaymentDate(v string) { + m.Set(field.NewLegCouponPaymentDate(v)) +} + +//SetLegIssueDate sets LegIssueDate, Tag 249 +func (m NoLegs) SetLegIssueDate(v string) { + m.Set(field.NewLegIssueDate(v)) +} + +//SetLegRepoCollateralSecurityType sets LegRepoCollateralSecurityType, Tag 250 +func (m NoLegs) SetLegRepoCollateralSecurityType(v int) { + m.Set(field.NewLegRepoCollateralSecurityType(v)) +} + +//SetLegRepurchaseTerm sets LegRepurchaseTerm, Tag 251 +func (m NoLegs) SetLegRepurchaseTerm(v int) { + m.Set(field.NewLegRepurchaseTerm(v)) +} + +//SetLegRepurchaseRate sets LegRepurchaseRate, Tag 252 +func (m NoLegs) SetLegRepurchaseRate(v float64) { + m.Set(field.NewLegRepurchaseRate(v)) +} + +//SetLegFactor sets LegFactor, Tag 253 +func (m NoLegs) SetLegFactor(v float64) { + m.Set(field.NewLegFactor(v)) +} + +//SetLegCreditRating sets LegCreditRating, Tag 257 +func (m NoLegs) SetLegCreditRating(v string) { + m.Set(field.NewLegCreditRating(v)) +} + +//SetLegInstrRegistry sets LegInstrRegistry, Tag 599 +func (m NoLegs) SetLegInstrRegistry(v string) { + m.Set(field.NewLegInstrRegistry(v)) +} + +//SetLegCountryOfIssue sets LegCountryOfIssue, Tag 596 +func (m NoLegs) SetLegCountryOfIssue(v string) { + m.Set(field.NewLegCountryOfIssue(v)) +} + +//SetLegStateOrProvinceOfIssue sets LegStateOrProvinceOfIssue, Tag 597 +func (m NoLegs) SetLegStateOrProvinceOfIssue(v string) { + m.Set(field.NewLegStateOrProvinceOfIssue(v)) +} + +//SetLegLocaleOfIssue sets LegLocaleOfIssue, Tag 598 +func (m NoLegs) SetLegLocaleOfIssue(v string) { + m.Set(field.NewLegLocaleOfIssue(v)) +} + +//SetLegRedemptionDate sets LegRedemptionDate, Tag 254 +func (m NoLegs) SetLegRedemptionDate(v string) { + m.Set(field.NewLegRedemptionDate(v)) +} + +//SetLegStrikePrice sets LegStrikePrice, Tag 612 +func (m NoLegs) SetLegStrikePrice(v float64) { + m.Set(field.NewLegStrikePrice(v)) +} + +//SetLegStrikeCurrency sets LegStrikeCurrency, Tag 942 +func (m NoLegs) SetLegStrikeCurrency(v string) { + m.Set(field.NewLegStrikeCurrency(v)) +} + +//SetLegOptAttribute sets LegOptAttribute, Tag 613 +func (m NoLegs) SetLegOptAttribute(v string) { + m.Set(field.NewLegOptAttribute(v)) +} + +//SetLegContractMultiplier sets LegContractMultiplier, Tag 614 +func (m NoLegs) SetLegContractMultiplier(v float64) { + m.Set(field.NewLegContractMultiplier(v)) +} + +//SetLegCouponRate sets LegCouponRate, Tag 615 +func (m NoLegs) SetLegCouponRate(v float64) { + m.Set(field.NewLegCouponRate(v)) +} + +//SetLegSecurityExchange sets LegSecurityExchange, Tag 616 +func (m NoLegs) SetLegSecurityExchange(v string) { + m.Set(field.NewLegSecurityExchange(v)) +} + +//SetLegIssuer sets LegIssuer, Tag 617 +func (m NoLegs) SetLegIssuer(v string) { + m.Set(field.NewLegIssuer(v)) +} + +//SetEncodedLegIssuerLen sets EncodedLegIssuerLen, Tag 618 +func (m NoLegs) SetEncodedLegIssuerLen(v int) { + m.Set(field.NewEncodedLegIssuerLen(v)) +} + +//SetEncodedLegIssuer sets EncodedLegIssuer, Tag 619 +func (m NoLegs) SetEncodedLegIssuer(v string) { + m.Set(field.NewEncodedLegIssuer(v)) +} + +//SetLegSecurityDesc sets LegSecurityDesc, Tag 620 +func (m NoLegs) SetLegSecurityDesc(v string) { + m.Set(field.NewLegSecurityDesc(v)) +} + +//SetEncodedLegSecurityDescLen sets EncodedLegSecurityDescLen, Tag 621 +func (m NoLegs) SetEncodedLegSecurityDescLen(v int) { + m.Set(field.NewEncodedLegSecurityDescLen(v)) +} + +//SetEncodedLegSecurityDesc sets EncodedLegSecurityDesc, Tag 622 +func (m NoLegs) SetEncodedLegSecurityDesc(v string) { + m.Set(field.NewEncodedLegSecurityDesc(v)) +} + +//SetLegRatioQty sets LegRatioQty, Tag 623 +func (m NoLegs) SetLegRatioQty(v float64) { + m.Set(field.NewLegRatioQty(v)) +} + +//SetLegSide sets LegSide, Tag 624 +func (m NoLegs) SetLegSide(v string) { + m.Set(field.NewLegSide(v)) +} + +//SetLegCurrency sets LegCurrency, Tag 556 +func (m NoLegs) SetLegCurrency(v string) { + m.Set(field.NewLegCurrency(v)) +} + +//SetLegPool sets LegPool, Tag 740 +func (m NoLegs) SetLegPool(v string) { + m.Set(field.NewLegPool(v)) +} + +//SetLegDatedDate sets LegDatedDate, Tag 739 +func (m NoLegs) SetLegDatedDate(v string) { + m.Set(field.NewLegDatedDate(v)) +} + +//SetLegContractSettlMonth sets LegContractSettlMonth, Tag 955 +func (m NoLegs) SetLegContractSettlMonth(v string) { + m.Set(field.NewLegContractSettlMonth(v)) +} + +//SetLegInterestAccrualDate sets LegInterestAccrualDate, Tag 956 +func (m NoLegs) SetLegInterestAccrualDate(v string) { + m.Set(field.NewLegInterestAccrualDate(v)) +} + +//SetLegQty sets LegQty, Tag 687 +func (m NoLegs) SetLegQty(v float64) { + m.Set(field.NewLegQty(v)) +} + +//SetLegSwapType sets LegSwapType, Tag 690 +func (m NoLegs) SetLegSwapType(v int) { + m.Set(field.NewLegSwapType(v)) +} + +//SetNoLegStipulations sets NoLegStipulations, Tag 683 +func (m NoLegs) SetNoLegStipulations(f NoLegStipulationsRepeatingGroup) { + m.SetGroup(f) +} + +//SetLegPositionEffect sets LegPositionEffect, Tag 564 +func (m NoLegs) SetLegPositionEffect(v string) { + m.Set(field.NewLegPositionEffect(v)) +} + +//SetLegCoveredOrUncovered sets LegCoveredOrUncovered, Tag 565 +func (m NoLegs) SetLegCoveredOrUncovered(v int) { + m.Set(field.NewLegCoveredOrUncovered(v)) +} + +//SetNoNestedPartyIDs sets NoNestedPartyIDs, Tag 539 +func (m NoLegs) SetNoNestedPartyIDs(f NoNestedPartyIDsRepeatingGroup) { + m.SetGroup(f) +} + +//SetLegRefID sets LegRefID, Tag 654 +func (m NoLegs) SetLegRefID(v string) { + m.Set(field.NewLegRefID(v)) +} + +//SetLegPrice sets LegPrice, Tag 566 +func (m NoLegs) SetLegPrice(v float64) { + m.Set(field.NewLegPrice(v)) +} + +//SetLegSettlType sets LegSettlType, Tag 587 +func (m NoLegs) SetLegSettlType(v string) { + m.Set(field.NewLegSettlType(v)) +} + +//SetLegSettlDate sets LegSettlDate, Tag 588 +func (m NoLegs) SetLegSettlDate(v string) { + m.Set(field.NewLegSettlDate(v)) +} + +//SetLegLastPx sets LegLastPx, Tag 637 +func (m NoLegs) SetLegLastPx(v float64) { + m.Set(field.NewLegLastPx(v)) +} + +//GetLegSymbol gets LegSymbol, Tag 600 +func (m NoLegs) GetLegSymbol() (f field.LegSymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSymbolSfx gets LegSymbolSfx, Tag 601 +func (m NoLegs) GetLegSymbolSfx() (f field.LegSymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityID gets LegSecurityID, Tag 602 +func (m NoLegs) GetLegSecurityID() (f field.LegSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityIDSource gets LegSecurityIDSource, Tag 603 +func (m NoLegs) GetLegSecurityIDSource() (f field.LegSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoLegSecurityAltID gets NoLegSecurityAltID, Tag 604 +func (m NoLegs) GetNoLegSecurityAltID() (NoLegSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoLegSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetLegProduct gets LegProduct, Tag 607 +func (m NoLegs) GetLegProduct() (f field.LegProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCFICode gets LegCFICode, Tag 608 +func (m NoLegs) GetLegCFICode() (f field.LegCFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityType gets LegSecurityType, Tag 609 +func (m NoLegs) GetLegSecurityType() (f field.LegSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecuritySubType gets LegSecuritySubType, Tag 764 +func (m NoLegs) GetLegSecuritySubType() (f field.LegSecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegMaturityMonthYear gets LegMaturityMonthYear, Tag 610 +func (m NoLegs) GetLegMaturityMonthYear() (f field.LegMaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegMaturityDate gets LegMaturityDate, Tag 611 +func (m NoLegs) GetLegMaturityDate() (f field.LegMaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCouponPaymentDate gets LegCouponPaymentDate, Tag 248 +func (m NoLegs) GetLegCouponPaymentDate() (f field.LegCouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegIssueDate gets LegIssueDate, Tag 249 +func (m NoLegs) GetLegIssueDate() (f field.LegIssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRepoCollateralSecurityType gets LegRepoCollateralSecurityType, Tag 250 +func (m NoLegs) GetLegRepoCollateralSecurityType() (f field.LegRepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRepurchaseTerm gets LegRepurchaseTerm, Tag 251 +func (m NoLegs) GetLegRepurchaseTerm() (f field.LegRepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRepurchaseRate gets LegRepurchaseRate, Tag 252 +func (m NoLegs) GetLegRepurchaseRate() (f field.LegRepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegFactor gets LegFactor, Tag 253 +func (m NoLegs) GetLegFactor() (f field.LegFactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCreditRating gets LegCreditRating, Tag 257 +func (m NoLegs) GetLegCreditRating() (f field.LegCreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegInstrRegistry gets LegInstrRegistry, Tag 599 +func (m NoLegs) GetLegInstrRegistry() (f field.LegInstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCountryOfIssue gets LegCountryOfIssue, Tag 596 +func (m NoLegs) GetLegCountryOfIssue() (f field.LegCountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegStateOrProvinceOfIssue gets LegStateOrProvinceOfIssue, Tag 597 +func (m NoLegs) GetLegStateOrProvinceOfIssue() (f field.LegStateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegLocaleOfIssue gets LegLocaleOfIssue, Tag 598 +func (m NoLegs) GetLegLocaleOfIssue() (f field.LegLocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRedemptionDate gets LegRedemptionDate, Tag 254 +func (m NoLegs) GetLegRedemptionDate() (f field.LegRedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegStrikePrice gets LegStrikePrice, Tag 612 +func (m NoLegs) GetLegStrikePrice() (f field.LegStrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegStrikeCurrency gets LegStrikeCurrency, Tag 942 +func (m NoLegs) GetLegStrikeCurrency() (f field.LegStrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegOptAttribute gets LegOptAttribute, Tag 613 +func (m NoLegs) GetLegOptAttribute() (f field.LegOptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegContractMultiplier gets LegContractMultiplier, Tag 614 +func (m NoLegs) GetLegContractMultiplier() (f field.LegContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCouponRate gets LegCouponRate, Tag 615 +func (m NoLegs) GetLegCouponRate() (f field.LegCouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityExchange gets LegSecurityExchange, Tag 616 +func (m NoLegs) GetLegSecurityExchange() (f field.LegSecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegIssuer gets LegIssuer, Tag 617 +func (m NoLegs) GetLegIssuer() (f field.LegIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegIssuerLen gets EncodedLegIssuerLen, Tag 618 +func (m NoLegs) GetEncodedLegIssuerLen() (f field.EncodedLegIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegIssuer gets EncodedLegIssuer, Tag 619 +func (m NoLegs) GetEncodedLegIssuer() (f field.EncodedLegIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityDesc gets LegSecurityDesc, Tag 620 +func (m NoLegs) GetLegSecurityDesc() (f field.LegSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegSecurityDescLen gets EncodedLegSecurityDescLen, Tag 621 +func (m NoLegs) GetEncodedLegSecurityDescLen() (f field.EncodedLegSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegSecurityDesc gets EncodedLegSecurityDesc, Tag 622 +func (m NoLegs) GetEncodedLegSecurityDesc() (f field.EncodedLegSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRatioQty gets LegRatioQty, Tag 623 +func (m NoLegs) GetLegRatioQty() (f field.LegRatioQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSide gets LegSide, Tag 624 +func (m NoLegs) GetLegSide() (f field.LegSideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCurrency gets LegCurrency, Tag 556 +func (m NoLegs) GetLegCurrency() (f field.LegCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegPool gets LegPool, Tag 740 +func (m NoLegs) GetLegPool() (f field.LegPoolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegDatedDate gets LegDatedDate, Tag 739 +func (m NoLegs) GetLegDatedDate() (f field.LegDatedDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegContractSettlMonth gets LegContractSettlMonth, Tag 955 +func (m NoLegs) GetLegContractSettlMonth() (f field.LegContractSettlMonthField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegInterestAccrualDate gets LegInterestAccrualDate, Tag 956 +func (m NoLegs) GetLegInterestAccrualDate() (f field.LegInterestAccrualDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegQty gets LegQty, Tag 687 +func (m NoLegs) GetLegQty() (f field.LegQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSwapType gets LegSwapType, Tag 690 +func (m NoLegs) GetLegSwapType() (f field.LegSwapTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoLegStipulations gets NoLegStipulations, Tag 683 +func (m NoLegs) GetNoLegStipulations() (NoLegStipulationsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoLegStipulationsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetLegPositionEffect gets LegPositionEffect, Tag 564 +func (m NoLegs) GetLegPositionEffect() (f field.LegPositionEffectField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCoveredOrUncovered gets LegCoveredOrUncovered, Tag 565 +func (m NoLegs) GetLegCoveredOrUncovered() (f field.LegCoveredOrUncoveredField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoNestedPartyIDs gets NoNestedPartyIDs, Tag 539 +func (m NoLegs) GetNoNestedPartyIDs() (NoNestedPartyIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoNestedPartyIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetLegRefID gets LegRefID, Tag 654 +func (m NoLegs) GetLegRefID() (f field.LegRefIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegPrice gets LegPrice, Tag 566 +func (m NoLegs) GetLegPrice() (f field.LegPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSettlType gets LegSettlType, Tag 587 +func (m NoLegs) GetLegSettlType() (f field.LegSettlTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSettlDate gets LegSettlDate, Tag 588 +func (m NoLegs) GetLegSettlDate() (f field.LegSettlDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegLastPx gets LegLastPx, Tag 637 +func (m NoLegs) GetLegLastPx() (f field.LegLastPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasLegSymbol returns true if LegSymbol is present, Tag 600 +func (m NoLegs) HasLegSymbol() bool { + return m.Has(tag.LegSymbol) +} + +//HasLegSymbolSfx returns true if LegSymbolSfx is present, Tag 601 +func (m NoLegs) HasLegSymbolSfx() bool { + return m.Has(tag.LegSymbolSfx) +} + +//HasLegSecurityID returns true if LegSecurityID is present, Tag 602 +func (m NoLegs) HasLegSecurityID() bool { + return m.Has(tag.LegSecurityID) +} + +//HasLegSecurityIDSource returns true if LegSecurityIDSource is present, Tag 603 +func (m NoLegs) HasLegSecurityIDSource() bool { + return m.Has(tag.LegSecurityIDSource) +} + +//HasNoLegSecurityAltID returns true if NoLegSecurityAltID is present, Tag 604 +func (m NoLegs) HasNoLegSecurityAltID() bool { + return m.Has(tag.NoLegSecurityAltID) +} + +//HasLegProduct returns true if LegProduct is present, Tag 607 +func (m NoLegs) HasLegProduct() bool { + return m.Has(tag.LegProduct) +} + +//HasLegCFICode returns true if LegCFICode is present, Tag 608 +func (m NoLegs) HasLegCFICode() bool { + return m.Has(tag.LegCFICode) +} + +//HasLegSecurityType returns true if LegSecurityType is present, Tag 609 +func (m NoLegs) HasLegSecurityType() bool { + return m.Has(tag.LegSecurityType) +} + +//HasLegSecuritySubType returns true if LegSecuritySubType is present, Tag 764 +func (m NoLegs) HasLegSecuritySubType() bool { + return m.Has(tag.LegSecuritySubType) +} + +//HasLegMaturityMonthYear returns true if LegMaturityMonthYear is present, Tag 610 +func (m NoLegs) HasLegMaturityMonthYear() bool { + return m.Has(tag.LegMaturityMonthYear) +} + +//HasLegMaturityDate returns true if LegMaturityDate is present, Tag 611 +func (m NoLegs) HasLegMaturityDate() bool { + return m.Has(tag.LegMaturityDate) +} + +//HasLegCouponPaymentDate returns true if LegCouponPaymentDate is present, Tag 248 +func (m NoLegs) HasLegCouponPaymentDate() bool { + return m.Has(tag.LegCouponPaymentDate) +} + +//HasLegIssueDate returns true if LegIssueDate is present, Tag 249 +func (m NoLegs) HasLegIssueDate() bool { + return m.Has(tag.LegIssueDate) +} + +//HasLegRepoCollateralSecurityType returns true if LegRepoCollateralSecurityType is present, Tag 250 +func (m NoLegs) HasLegRepoCollateralSecurityType() bool { + return m.Has(tag.LegRepoCollateralSecurityType) +} + +//HasLegRepurchaseTerm returns true if LegRepurchaseTerm is present, Tag 251 +func (m NoLegs) HasLegRepurchaseTerm() bool { + return m.Has(tag.LegRepurchaseTerm) +} + +//HasLegRepurchaseRate returns true if LegRepurchaseRate is present, Tag 252 +func (m NoLegs) HasLegRepurchaseRate() bool { + return m.Has(tag.LegRepurchaseRate) +} + +//HasLegFactor returns true if LegFactor is present, Tag 253 +func (m NoLegs) HasLegFactor() bool { + return m.Has(tag.LegFactor) +} + +//HasLegCreditRating returns true if LegCreditRating is present, Tag 257 +func (m NoLegs) HasLegCreditRating() bool { + return m.Has(tag.LegCreditRating) +} + +//HasLegInstrRegistry returns true if LegInstrRegistry is present, Tag 599 +func (m NoLegs) HasLegInstrRegistry() bool { + return m.Has(tag.LegInstrRegistry) +} + +//HasLegCountryOfIssue returns true if LegCountryOfIssue is present, Tag 596 +func (m NoLegs) HasLegCountryOfIssue() bool { + return m.Has(tag.LegCountryOfIssue) +} + +//HasLegStateOrProvinceOfIssue returns true if LegStateOrProvinceOfIssue is present, Tag 597 +func (m NoLegs) HasLegStateOrProvinceOfIssue() bool { + return m.Has(tag.LegStateOrProvinceOfIssue) +} + +//HasLegLocaleOfIssue returns true if LegLocaleOfIssue is present, Tag 598 +func (m NoLegs) HasLegLocaleOfIssue() bool { + return m.Has(tag.LegLocaleOfIssue) +} + +//HasLegRedemptionDate returns true if LegRedemptionDate is present, Tag 254 +func (m NoLegs) HasLegRedemptionDate() bool { + return m.Has(tag.LegRedemptionDate) +} + +//HasLegStrikePrice returns true if LegStrikePrice is present, Tag 612 +func (m NoLegs) HasLegStrikePrice() bool { + return m.Has(tag.LegStrikePrice) +} + +//HasLegStrikeCurrency returns true if LegStrikeCurrency is present, Tag 942 +func (m NoLegs) HasLegStrikeCurrency() bool { + return m.Has(tag.LegStrikeCurrency) +} + +//HasLegOptAttribute returns true if LegOptAttribute is present, Tag 613 +func (m NoLegs) HasLegOptAttribute() bool { + return m.Has(tag.LegOptAttribute) +} + +//HasLegContractMultiplier returns true if LegContractMultiplier is present, Tag 614 +func (m NoLegs) HasLegContractMultiplier() bool { + return m.Has(tag.LegContractMultiplier) +} + +//HasLegCouponRate returns true if LegCouponRate is present, Tag 615 +func (m NoLegs) HasLegCouponRate() bool { + return m.Has(tag.LegCouponRate) +} + +//HasLegSecurityExchange returns true if LegSecurityExchange is present, Tag 616 +func (m NoLegs) HasLegSecurityExchange() bool { + return m.Has(tag.LegSecurityExchange) +} + +//HasLegIssuer returns true if LegIssuer is present, Tag 617 +func (m NoLegs) HasLegIssuer() bool { + return m.Has(tag.LegIssuer) +} + +//HasEncodedLegIssuerLen returns true if EncodedLegIssuerLen is present, Tag 618 +func (m NoLegs) HasEncodedLegIssuerLen() bool { + return m.Has(tag.EncodedLegIssuerLen) +} + +//HasEncodedLegIssuer returns true if EncodedLegIssuer is present, Tag 619 +func (m NoLegs) HasEncodedLegIssuer() bool { + return m.Has(tag.EncodedLegIssuer) +} + +//HasLegSecurityDesc returns true if LegSecurityDesc is present, Tag 620 +func (m NoLegs) HasLegSecurityDesc() bool { + return m.Has(tag.LegSecurityDesc) +} + +//HasEncodedLegSecurityDescLen returns true if EncodedLegSecurityDescLen is present, Tag 621 +func (m NoLegs) HasEncodedLegSecurityDescLen() bool { + return m.Has(tag.EncodedLegSecurityDescLen) +} + +//HasEncodedLegSecurityDesc returns true if EncodedLegSecurityDesc is present, Tag 622 +func (m NoLegs) HasEncodedLegSecurityDesc() bool { + return m.Has(tag.EncodedLegSecurityDesc) +} + +//HasLegRatioQty returns true if LegRatioQty is present, Tag 623 +func (m NoLegs) HasLegRatioQty() bool { + return m.Has(tag.LegRatioQty) +} + +//HasLegSide returns true if LegSide is present, Tag 624 +func (m NoLegs) HasLegSide() bool { + return m.Has(tag.LegSide) +} + +//HasLegCurrency returns true if LegCurrency is present, Tag 556 +func (m NoLegs) HasLegCurrency() bool { + return m.Has(tag.LegCurrency) +} + +//HasLegPool returns true if LegPool is present, Tag 740 +func (m NoLegs) HasLegPool() bool { + return m.Has(tag.LegPool) +} + +//HasLegDatedDate returns true if LegDatedDate is present, Tag 739 +func (m NoLegs) HasLegDatedDate() bool { + return m.Has(tag.LegDatedDate) +} + +//HasLegContractSettlMonth returns true if LegContractSettlMonth is present, Tag 955 +func (m NoLegs) HasLegContractSettlMonth() bool { + return m.Has(tag.LegContractSettlMonth) +} + +//HasLegInterestAccrualDate returns true if LegInterestAccrualDate is present, Tag 956 +func (m NoLegs) HasLegInterestAccrualDate() bool { + return m.Has(tag.LegInterestAccrualDate) +} + +//HasLegQty returns true if LegQty is present, Tag 687 +func (m NoLegs) HasLegQty() bool { + return m.Has(tag.LegQty) +} + +//HasLegSwapType returns true if LegSwapType is present, Tag 690 +func (m NoLegs) HasLegSwapType() bool { + return m.Has(tag.LegSwapType) +} + +//HasNoLegStipulations returns true if NoLegStipulations is present, Tag 683 +func (m NoLegs) HasNoLegStipulations() bool { + return m.Has(tag.NoLegStipulations) +} + +//HasLegPositionEffect returns true if LegPositionEffect is present, Tag 564 +func (m NoLegs) HasLegPositionEffect() bool { + return m.Has(tag.LegPositionEffect) +} + +//HasLegCoveredOrUncovered returns true if LegCoveredOrUncovered is present, Tag 565 +func (m NoLegs) HasLegCoveredOrUncovered() bool { + return m.Has(tag.LegCoveredOrUncovered) +} + +//HasNoNestedPartyIDs returns true if NoNestedPartyIDs is present, Tag 539 +func (m NoLegs) HasNoNestedPartyIDs() bool { + return m.Has(tag.NoNestedPartyIDs) +} + +//HasLegRefID returns true if LegRefID is present, Tag 654 +func (m NoLegs) HasLegRefID() bool { + return m.Has(tag.LegRefID) +} + +//HasLegPrice returns true if LegPrice is present, Tag 566 +func (m NoLegs) HasLegPrice() bool { + return m.Has(tag.LegPrice) +} + +//HasLegSettlType returns true if LegSettlType is present, Tag 587 +func (m NoLegs) HasLegSettlType() bool { + return m.Has(tag.LegSettlType) +} + +//HasLegSettlDate returns true if LegSettlDate is present, Tag 588 +func (m NoLegs) HasLegSettlDate() bool { + return m.Has(tag.LegSettlDate) +} + +//HasLegLastPx returns true if LegLastPx is present, Tag 637 +func (m NoLegs) HasLegLastPx() bool { + return m.Has(tag.LegLastPx) +} + +//NoLegSecurityAltID is a repeating group element, Tag 604 +type NoLegSecurityAltID struct { + quickfix.Group +} + +//SetLegSecurityAltID sets LegSecurityAltID, Tag 605 +func (m NoLegSecurityAltID) SetLegSecurityAltID(v string) { + m.Set(field.NewLegSecurityAltID(v)) +} + +//SetLegSecurityAltIDSource sets LegSecurityAltIDSource, Tag 606 +func (m NoLegSecurityAltID) SetLegSecurityAltIDSource(v string) { + m.Set(field.NewLegSecurityAltIDSource(v)) +} + +//GetLegSecurityAltID gets LegSecurityAltID, Tag 605 +func (m NoLegSecurityAltID) GetLegSecurityAltID() (f field.LegSecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityAltIDSource gets LegSecurityAltIDSource, Tag 606 +func (m NoLegSecurityAltID) GetLegSecurityAltIDSource() (f field.LegSecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasLegSecurityAltID returns true if LegSecurityAltID is present, Tag 605 +func (m NoLegSecurityAltID) HasLegSecurityAltID() bool { + return m.Has(tag.LegSecurityAltID) +} + +//HasLegSecurityAltIDSource returns true if LegSecurityAltIDSource is present, Tag 606 +func (m NoLegSecurityAltID) HasLegSecurityAltIDSource() bool { + return m.Has(tag.LegSecurityAltIDSource) +} + +//NoLegSecurityAltIDRepeatingGroup is a repeating group, Tag 604 +type NoLegSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoLegSecurityAltIDRepeatingGroup returns an initialized, NoLegSecurityAltIDRepeatingGroup +func NewNoLegSecurityAltIDRepeatingGroup() NoLegSecurityAltIDRepeatingGroup { + return NoLegSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoLegSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.LegSecurityAltID), quickfix.GroupElement(tag.LegSecurityAltIDSource)})} +} + +//Add create and append a new NoLegSecurityAltID to this group +func (m NoLegSecurityAltIDRepeatingGroup) Add() NoLegSecurityAltID { + g := m.RepeatingGroup.Add() + return NoLegSecurityAltID{g} +} + +//Get returns the ith NoLegSecurityAltID in the NoLegSecurityAltIDRepeatinGroup +func (m NoLegSecurityAltIDRepeatingGroup) Get(i int) NoLegSecurityAltID { + return NoLegSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoLegStipulations is a repeating group element, Tag 683 +type NoLegStipulations struct { + quickfix.Group +} + +//SetLegStipulationType sets LegStipulationType, Tag 688 +func (m NoLegStipulations) SetLegStipulationType(v string) { + m.Set(field.NewLegStipulationType(v)) +} + +//SetLegStipulationValue sets LegStipulationValue, Tag 689 +func (m NoLegStipulations) SetLegStipulationValue(v string) { + m.Set(field.NewLegStipulationValue(v)) +} + +//GetLegStipulationType gets LegStipulationType, Tag 688 +func (m NoLegStipulations) GetLegStipulationType() (f field.LegStipulationTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegStipulationValue gets LegStipulationValue, Tag 689 +func (m NoLegStipulations) GetLegStipulationValue() (f field.LegStipulationValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasLegStipulationType returns true if LegStipulationType is present, Tag 688 +func (m NoLegStipulations) HasLegStipulationType() bool { + return m.Has(tag.LegStipulationType) +} + +//HasLegStipulationValue returns true if LegStipulationValue is present, Tag 689 +func (m NoLegStipulations) HasLegStipulationValue() bool { + return m.Has(tag.LegStipulationValue) +} + +//NoLegStipulationsRepeatingGroup is a repeating group, Tag 683 +type NoLegStipulationsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoLegStipulationsRepeatingGroup returns an initialized, NoLegStipulationsRepeatingGroup +func NewNoLegStipulationsRepeatingGroup() NoLegStipulationsRepeatingGroup { + return NoLegStipulationsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoLegStipulations, + quickfix.GroupTemplate{quickfix.GroupElement(tag.LegStipulationType), quickfix.GroupElement(tag.LegStipulationValue)})} +} + +//Add create and append a new NoLegStipulations to this group +func (m NoLegStipulationsRepeatingGroup) Add() NoLegStipulations { + g := m.RepeatingGroup.Add() + return NoLegStipulations{g} +} + +//Get returns the ith NoLegStipulations in the NoLegStipulationsRepeatinGroup +func (m NoLegStipulationsRepeatingGroup) Get(i int) NoLegStipulations { + return NoLegStipulations{m.RepeatingGroup.Get(i)} +} + +//NoNestedPartyIDs is a repeating group element, Tag 539 +type NoNestedPartyIDs struct { + quickfix.Group +} + +//SetNestedPartyID sets NestedPartyID, Tag 524 +func (m NoNestedPartyIDs) SetNestedPartyID(v string) { + m.Set(field.NewNestedPartyID(v)) +} + +//SetNestedPartyIDSource sets NestedPartyIDSource, Tag 525 +func (m NoNestedPartyIDs) SetNestedPartyIDSource(v string) { + m.Set(field.NewNestedPartyIDSource(v)) +} + +//SetNestedPartyRole sets NestedPartyRole, Tag 538 +func (m NoNestedPartyIDs) SetNestedPartyRole(v int) { + m.Set(field.NewNestedPartyRole(v)) +} + +//SetNoNestedPartySubIDs sets NoNestedPartySubIDs, Tag 804 +func (m NoNestedPartyIDs) SetNoNestedPartySubIDs(f NoNestedPartySubIDsRepeatingGroup) { + m.SetGroup(f) +} + +//GetNestedPartyID gets NestedPartyID, Tag 524 +func (m NoNestedPartyIDs) GetNestedPartyID() (f field.NestedPartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNestedPartyIDSource gets NestedPartyIDSource, Tag 525 +func (m NoNestedPartyIDs) GetNestedPartyIDSource() (f field.NestedPartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNestedPartyRole gets NestedPartyRole, Tag 538 +func (m NoNestedPartyIDs) GetNestedPartyRole() (f field.NestedPartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoNestedPartySubIDs gets NoNestedPartySubIDs, Tag 804 +func (m NoNestedPartyIDs) GetNoNestedPartySubIDs() (NoNestedPartySubIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoNestedPartySubIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasNestedPartyID returns true if NestedPartyID is present, Tag 524 +func (m NoNestedPartyIDs) HasNestedPartyID() bool { + return m.Has(tag.NestedPartyID) +} + +//HasNestedPartyIDSource returns true if NestedPartyIDSource is present, Tag 525 +func (m NoNestedPartyIDs) HasNestedPartyIDSource() bool { + return m.Has(tag.NestedPartyIDSource) +} + +//HasNestedPartyRole returns true if NestedPartyRole is present, Tag 538 +func (m NoNestedPartyIDs) HasNestedPartyRole() bool { + return m.Has(tag.NestedPartyRole) +} + +//HasNoNestedPartySubIDs returns true if NoNestedPartySubIDs is present, Tag 804 +func (m NoNestedPartyIDs) HasNoNestedPartySubIDs() bool { + return m.Has(tag.NoNestedPartySubIDs) +} + +//NoNestedPartySubIDs is a repeating group element, Tag 804 +type NoNestedPartySubIDs struct { + quickfix.Group +} + +//SetNestedPartySubID sets NestedPartySubID, Tag 545 +func (m NoNestedPartySubIDs) SetNestedPartySubID(v string) { + m.Set(field.NewNestedPartySubID(v)) +} + +//SetNestedPartySubIDType sets NestedPartySubIDType, Tag 805 +func (m NoNestedPartySubIDs) SetNestedPartySubIDType(v int) { + m.Set(field.NewNestedPartySubIDType(v)) +} + +//GetNestedPartySubID gets NestedPartySubID, Tag 545 +func (m NoNestedPartySubIDs) GetNestedPartySubID() (f field.NestedPartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNestedPartySubIDType gets NestedPartySubIDType, Tag 805 +func (m NoNestedPartySubIDs) GetNestedPartySubIDType() (f field.NestedPartySubIDTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasNestedPartySubID returns true if NestedPartySubID is present, Tag 545 +func (m NoNestedPartySubIDs) HasNestedPartySubID() bool { + return m.Has(tag.NestedPartySubID) +} + +//HasNestedPartySubIDType returns true if NestedPartySubIDType is present, Tag 805 +func (m NoNestedPartySubIDs) HasNestedPartySubIDType() bool { + return m.Has(tag.NestedPartySubIDType) +} + +//NoNestedPartySubIDsRepeatingGroup is a repeating group, Tag 804 +type NoNestedPartySubIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoNestedPartySubIDsRepeatingGroup returns an initialized, NoNestedPartySubIDsRepeatingGroup +func NewNoNestedPartySubIDsRepeatingGroup() NoNestedPartySubIDsRepeatingGroup { + return NoNestedPartySubIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoNestedPartySubIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.NestedPartySubID), quickfix.GroupElement(tag.NestedPartySubIDType)})} +} + +//Add create and append a new NoNestedPartySubIDs to this group +func (m NoNestedPartySubIDsRepeatingGroup) Add() NoNestedPartySubIDs { + g := m.RepeatingGroup.Add() + return NoNestedPartySubIDs{g} +} + +//Get returns the ith NoNestedPartySubIDs in the NoNestedPartySubIDsRepeatinGroup +func (m NoNestedPartySubIDsRepeatingGroup) Get(i int) NoNestedPartySubIDs { + return NoNestedPartySubIDs{m.RepeatingGroup.Get(i)} +} + +//NoNestedPartyIDsRepeatingGroup is a repeating group, Tag 539 +type NoNestedPartyIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoNestedPartyIDsRepeatingGroup returns an initialized, NoNestedPartyIDsRepeatingGroup +func NewNoNestedPartyIDsRepeatingGroup() NoNestedPartyIDsRepeatingGroup { + return NoNestedPartyIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoNestedPartyIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.NestedPartyID), quickfix.GroupElement(tag.NestedPartyIDSource), quickfix.GroupElement(tag.NestedPartyRole), NewNoNestedPartySubIDsRepeatingGroup()})} +} + +//Add create and append a new NoNestedPartyIDs to this group +func (m NoNestedPartyIDsRepeatingGroup) Add() NoNestedPartyIDs { + g := m.RepeatingGroup.Add() + return NoNestedPartyIDs{g} +} + +//Get returns the ith NoNestedPartyIDs in the NoNestedPartyIDsRepeatinGroup +func (m NoNestedPartyIDsRepeatingGroup) Get(i int) NoNestedPartyIDs { + return NoNestedPartyIDs{m.RepeatingGroup.Get(i)} +} + +//NoLegsRepeatingGroup is a repeating group, Tag 555 +type NoLegsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoLegsRepeatingGroup returns an initialized, NoLegsRepeatingGroup +func NewNoLegsRepeatingGroup() NoLegsRepeatingGroup { + return NoLegsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoLegs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.LegSymbol), quickfix.GroupElement(tag.LegSymbolSfx), quickfix.GroupElement(tag.LegSecurityID), quickfix.GroupElement(tag.LegSecurityIDSource), NewNoLegSecurityAltIDRepeatingGroup(), quickfix.GroupElement(tag.LegProduct), quickfix.GroupElement(tag.LegCFICode), quickfix.GroupElement(tag.LegSecurityType), quickfix.GroupElement(tag.LegSecuritySubType), quickfix.GroupElement(tag.LegMaturityMonthYear), quickfix.GroupElement(tag.LegMaturityDate), quickfix.GroupElement(tag.LegCouponPaymentDate), quickfix.GroupElement(tag.LegIssueDate), quickfix.GroupElement(tag.LegRepoCollateralSecurityType), quickfix.GroupElement(tag.LegRepurchaseTerm), quickfix.GroupElement(tag.LegRepurchaseRate), quickfix.GroupElement(tag.LegFactor), quickfix.GroupElement(tag.LegCreditRating), quickfix.GroupElement(tag.LegInstrRegistry), quickfix.GroupElement(tag.LegCountryOfIssue), quickfix.GroupElement(tag.LegStateOrProvinceOfIssue), quickfix.GroupElement(tag.LegLocaleOfIssue), quickfix.GroupElement(tag.LegRedemptionDate), quickfix.GroupElement(tag.LegStrikePrice), quickfix.GroupElement(tag.LegStrikeCurrency), quickfix.GroupElement(tag.LegOptAttribute), quickfix.GroupElement(tag.LegContractMultiplier), quickfix.GroupElement(tag.LegCouponRate), quickfix.GroupElement(tag.LegSecurityExchange), quickfix.GroupElement(tag.LegIssuer), quickfix.GroupElement(tag.EncodedLegIssuerLen), quickfix.GroupElement(tag.EncodedLegIssuer), quickfix.GroupElement(tag.LegSecurityDesc), quickfix.GroupElement(tag.EncodedLegSecurityDescLen), quickfix.GroupElement(tag.EncodedLegSecurityDesc), quickfix.GroupElement(tag.LegRatioQty), quickfix.GroupElement(tag.LegSide), quickfix.GroupElement(tag.LegCurrency), quickfix.GroupElement(tag.LegPool), quickfix.GroupElement(tag.LegDatedDate), quickfix.GroupElement(tag.LegContractSettlMonth), quickfix.GroupElement(tag.LegInterestAccrualDate), quickfix.GroupElement(tag.LegQty), quickfix.GroupElement(tag.LegSwapType), NewNoLegStipulationsRepeatingGroup(), quickfix.GroupElement(tag.LegPositionEffect), quickfix.GroupElement(tag.LegCoveredOrUncovered), NewNoNestedPartyIDsRepeatingGroup(), quickfix.GroupElement(tag.LegRefID), quickfix.GroupElement(tag.LegPrice), quickfix.GroupElement(tag.LegSettlType), quickfix.GroupElement(tag.LegSettlDate), quickfix.GroupElement(tag.LegLastPx)})} +} + +//Add create and append a new NoLegs to this group +func (m NoLegsRepeatingGroup) Add() NoLegs { + g := m.RepeatingGroup.Add() + return NoLegs{g} +} + +//Get returns the ith NoLegs in the NoLegsRepeatinGroup +func (m NoLegsRepeatingGroup) Get(i int) NoLegs { + return NoLegs{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyings is a repeating group element, Tag 711 +type NoUnderlyings struct { + quickfix.Group +} + +//SetUnderlyingSymbol sets UnderlyingSymbol, Tag 311 +func (m NoUnderlyings) SetUnderlyingSymbol(v string) { + m.Set(field.NewUnderlyingSymbol(v)) +} + +//SetUnderlyingSymbolSfx sets UnderlyingSymbolSfx, Tag 312 +func (m NoUnderlyings) SetUnderlyingSymbolSfx(v string) { + m.Set(field.NewUnderlyingSymbolSfx(v)) +} + +//SetUnderlyingSecurityID sets UnderlyingSecurityID, Tag 309 +func (m NoUnderlyings) SetUnderlyingSecurityID(v string) { + m.Set(field.NewUnderlyingSecurityID(v)) +} + +//SetUnderlyingSecurityIDSource sets UnderlyingSecurityIDSource, Tag 305 +func (m NoUnderlyings) SetUnderlyingSecurityIDSource(v string) { + m.Set(field.NewUnderlyingSecurityIDSource(v)) +} + +//SetNoUnderlyingSecurityAltID sets NoUnderlyingSecurityAltID, Tag 457 +func (m NoUnderlyings) SetNoUnderlyingSecurityAltID(f NoUnderlyingSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetUnderlyingProduct sets UnderlyingProduct, Tag 462 +func (m NoUnderlyings) SetUnderlyingProduct(v int) { + m.Set(field.NewUnderlyingProduct(v)) +} + +//SetUnderlyingCFICode sets UnderlyingCFICode, Tag 463 +func (m NoUnderlyings) SetUnderlyingCFICode(v string) { + m.Set(field.NewUnderlyingCFICode(v)) +} + +//SetUnderlyingSecurityType sets UnderlyingSecurityType, Tag 310 +func (m NoUnderlyings) SetUnderlyingSecurityType(v string) { + m.Set(field.NewUnderlyingSecurityType(v)) +} + +//SetUnderlyingSecuritySubType sets UnderlyingSecuritySubType, Tag 763 +func (m NoUnderlyings) SetUnderlyingSecuritySubType(v string) { + m.Set(field.NewUnderlyingSecuritySubType(v)) +} + +//SetUnderlyingMaturityMonthYear sets UnderlyingMaturityMonthYear, Tag 313 +func (m NoUnderlyings) SetUnderlyingMaturityMonthYear(v string) { + m.Set(field.NewUnderlyingMaturityMonthYear(v)) +} + +//SetUnderlyingMaturityDate sets UnderlyingMaturityDate, Tag 542 +func (m NoUnderlyings) SetUnderlyingMaturityDate(v string) { + m.Set(field.NewUnderlyingMaturityDate(v)) +} + +//SetUnderlyingCouponPaymentDate sets UnderlyingCouponPaymentDate, Tag 241 +func (m NoUnderlyings) SetUnderlyingCouponPaymentDate(v string) { + m.Set(field.NewUnderlyingCouponPaymentDate(v)) +} + +//SetUnderlyingIssueDate sets UnderlyingIssueDate, Tag 242 +func (m NoUnderlyings) SetUnderlyingIssueDate(v string) { + m.Set(field.NewUnderlyingIssueDate(v)) +} + +//SetUnderlyingRepoCollateralSecurityType sets UnderlyingRepoCollateralSecurityType, Tag 243 +func (m NoUnderlyings) SetUnderlyingRepoCollateralSecurityType(v int) { + m.Set(field.NewUnderlyingRepoCollateralSecurityType(v)) +} + +//SetUnderlyingRepurchaseTerm sets UnderlyingRepurchaseTerm, Tag 244 +func (m NoUnderlyings) SetUnderlyingRepurchaseTerm(v int) { + m.Set(field.NewUnderlyingRepurchaseTerm(v)) +} + +//SetUnderlyingRepurchaseRate sets UnderlyingRepurchaseRate, Tag 245 +func (m NoUnderlyings) SetUnderlyingRepurchaseRate(v float64) { + m.Set(field.NewUnderlyingRepurchaseRate(v)) +} + +//SetUnderlyingFactor sets UnderlyingFactor, Tag 246 +func (m NoUnderlyings) SetUnderlyingFactor(v float64) { + m.Set(field.NewUnderlyingFactor(v)) +} + +//SetUnderlyingCreditRating sets UnderlyingCreditRating, Tag 256 +func (m NoUnderlyings) SetUnderlyingCreditRating(v string) { + m.Set(field.NewUnderlyingCreditRating(v)) +} + +//SetUnderlyingInstrRegistry sets UnderlyingInstrRegistry, Tag 595 +func (m NoUnderlyings) SetUnderlyingInstrRegistry(v string) { + m.Set(field.NewUnderlyingInstrRegistry(v)) +} + +//SetUnderlyingCountryOfIssue sets UnderlyingCountryOfIssue, Tag 592 +func (m NoUnderlyings) SetUnderlyingCountryOfIssue(v string) { + m.Set(field.NewUnderlyingCountryOfIssue(v)) +} + +//SetUnderlyingStateOrProvinceOfIssue sets UnderlyingStateOrProvinceOfIssue, Tag 593 +func (m NoUnderlyings) SetUnderlyingStateOrProvinceOfIssue(v string) { + m.Set(field.NewUnderlyingStateOrProvinceOfIssue(v)) +} + +//SetUnderlyingLocaleOfIssue sets UnderlyingLocaleOfIssue, Tag 594 +func (m NoUnderlyings) SetUnderlyingLocaleOfIssue(v string) { + m.Set(field.NewUnderlyingLocaleOfIssue(v)) +} + +//SetUnderlyingRedemptionDate sets UnderlyingRedemptionDate, Tag 247 +func (m NoUnderlyings) SetUnderlyingRedemptionDate(v string) { + m.Set(field.NewUnderlyingRedemptionDate(v)) +} + +//SetUnderlyingStrikePrice sets UnderlyingStrikePrice, Tag 316 +func (m NoUnderlyings) SetUnderlyingStrikePrice(v float64) { + m.Set(field.NewUnderlyingStrikePrice(v)) +} + +//SetUnderlyingStrikeCurrency sets UnderlyingStrikeCurrency, Tag 941 +func (m NoUnderlyings) SetUnderlyingStrikeCurrency(v string) { + m.Set(field.NewUnderlyingStrikeCurrency(v)) +} + +//SetUnderlyingOptAttribute sets UnderlyingOptAttribute, Tag 317 +func (m NoUnderlyings) SetUnderlyingOptAttribute(v string) { + m.Set(field.NewUnderlyingOptAttribute(v)) +} + +//SetUnderlyingContractMultiplier sets UnderlyingContractMultiplier, Tag 436 +func (m NoUnderlyings) SetUnderlyingContractMultiplier(v float64) { + m.Set(field.NewUnderlyingContractMultiplier(v)) +} + +//SetUnderlyingCouponRate sets UnderlyingCouponRate, Tag 435 +func (m NoUnderlyings) SetUnderlyingCouponRate(v float64) { + m.Set(field.NewUnderlyingCouponRate(v)) +} + +//SetUnderlyingSecurityExchange sets UnderlyingSecurityExchange, Tag 308 +func (m NoUnderlyings) SetUnderlyingSecurityExchange(v string) { + m.Set(field.NewUnderlyingSecurityExchange(v)) +} + +//SetUnderlyingIssuer sets UnderlyingIssuer, Tag 306 +func (m NoUnderlyings) SetUnderlyingIssuer(v string) { + m.Set(field.NewUnderlyingIssuer(v)) +} + +//SetEncodedUnderlyingIssuerLen sets EncodedUnderlyingIssuerLen, Tag 362 +func (m NoUnderlyings) SetEncodedUnderlyingIssuerLen(v int) { + m.Set(field.NewEncodedUnderlyingIssuerLen(v)) +} + +//SetEncodedUnderlyingIssuer sets EncodedUnderlyingIssuer, Tag 363 +func (m NoUnderlyings) SetEncodedUnderlyingIssuer(v string) { + m.Set(field.NewEncodedUnderlyingIssuer(v)) +} + +//SetUnderlyingSecurityDesc sets UnderlyingSecurityDesc, Tag 307 +func (m NoUnderlyings) SetUnderlyingSecurityDesc(v string) { + m.Set(field.NewUnderlyingSecurityDesc(v)) +} + +//SetEncodedUnderlyingSecurityDescLen sets EncodedUnderlyingSecurityDescLen, Tag 364 +func (m NoUnderlyings) SetEncodedUnderlyingSecurityDescLen(v int) { + m.Set(field.NewEncodedUnderlyingSecurityDescLen(v)) +} + +//SetEncodedUnderlyingSecurityDesc sets EncodedUnderlyingSecurityDesc, Tag 365 +func (m NoUnderlyings) SetEncodedUnderlyingSecurityDesc(v string) { + m.Set(field.NewEncodedUnderlyingSecurityDesc(v)) +} + +//SetUnderlyingCPProgram sets UnderlyingCPProgram, Tag 877 +func (m NoUnderlyings) SetUnderlyingCPProgram(v string) { + m.Set(field.NewUnderlyingCPProgram(v)) +} + +//SetUnderlyingCPRegType sets UnderlyingCPRegType, Tag 878 +func (m NoUnderlyings) SetUnderlyingCPRegType(v string) { + m.Set(field.NewUnderlyingCPRegType(v)) +} + +//SetUnderlyingCurrency sets UnderlyingCurrency, Tag 318 +func (m NoUnderlyings) SetUnderlyingCurrency(v string) { + m.Set(field.NewUnderlyingCurrency(v)) +} + +//SetUnderlyingQty sets UnderlyingQty, Tag 879 +func (m NoUnderlyings) SetUnderlyingQty(v float64) { + m.Set(field.NewUnderlyingQty(v)) +} + +//SetUnderlyingPx sets UnderlyingPx, Tag 810 +func (m NoUnderlyings) SetUnderlyingPx(v float64) { + m.Set(field.NewUnderlyingPx(v)) +} + +//SetUnderlyingDirtyPrice sets UnderlyingDirtyPrice, Tag 882 +func (m NoUnderlyings) SetUnderlyingDirtyPrice(v float64) { + m.Set(field.NewUnderlyingDirtyPrice(v)) +} + +//SetUnderlyingEndPrice sets UnderlyingEndPrice, Tag 883 +func (m NoUnderlyings) SetUnderlyingEndPrice(v float64) { + m.Set(field.NewUnderlyingEndPrice(v)) +} + +//SetUnderlyingStartValue sets UnderlyingStartValue, Tag 884 +func (m NoUnderlyings) SetUnderlyingStartValue(v float64) { + m.Set(field.NewUnderlyingStartValue(v)) +} + +//SetUnderlyingCurrentValue sets UnderlyingCurrentValue, Tag 885 +func (m NoUnderlyings) SetUnderlyingCurrentValue(v float64) { + m.Set(field.NewUnderlyingCurrentValue(v)) +} + +//SetUnderlyingEndValue sets UnderlyingEndValue, Tag 886 +func (m NoUnderlyings) SetUnderlyingEndValue(v float64) { + m.Set(field.NewUnderlyingEndValue(v)) +} + +//SetNoUnderlyingStips sets NoUnderlyingStips, Tag 887 +func (m NoUnderlyings) SetNoUnderlyingStips(f NoUnderlyingStipsRepeatingGroup) { + m.SetGroup(f) +} + +//GetUnderlyingSymbol gets UnderlyingSymbol, Tag 311 +func (m NoUnderlyings) GetUnderlyingSymbol() (f field.UnderlyingSymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSymbolSfx gets UnderlyingSymbolSfx, Tag 312 +func (m NoUnderlyings) GetUnderlyingSymbolSfx() (f field.UnderlyingSymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityID gets UnderlyingSecurityID, Tag 309 +func (m NoUnderlyings) GetUnderlyingSecurityID() (f field.UnderlyingSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityIDSource gets UnderlyingSecurityIDSource, Tag 305 +func (m NoUnderlyings) GetUnderlyingSecurityIDSource() (f field.UnderlyingSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyingSecurityAltID gets NoUnderlyingSecurityAltID, Tag 457 +func (m NoUnderlyings) GetNoUnderlyingSecurityAltID() (NoUnderlyingSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetUnderlyingProduct gets UnderlyingProduct, Tag 462 +func (m NoUnderlyings) GetUnderlyingProduct() (f field.UnderlyingProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCFICode gets UnderlyingCFICode, Tag 463 +func (m NoUnderlyings) GetUnderlyingCFICode() (f field.UnderlyingCFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityType gets UnderlyingSecurityType, Tag 310 +func (m NoUnderlyings) GetUnderlyingSecurityType() (f field.UnderlyingSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecuritySubType gets UnderlyingSecuritySubType, Tag 763 +func (m NoUnderlyings) GetUnderlyingSecuritySubType() (f field.UnderlyingSecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingMaturityMonthYear gets UnderlyingMaturityMonthYear, Tag 313 +func (m NoUnderlyings) GetUnderlyingMaturityMonthYear() (f field.UnderlyingMaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingMaturityDate gets UnderlyingMaturityDate, Tag 542 +func (m NoUnderlyings) GetUnderlyingMaturityDate() (f field.UnderlyingMaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCouponPaymentDate gets UnderlyingCouponPaymentDate, Tag 241 +func (m NoUnderlyings) GetUnderlyingCouponPaymentDate() (f field.UnderlyingCouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingIssueDate gets UnderlyingIssueDate, Tag 242 +func (m NoUnderlyings) GetUnderlyingIssueDate() (f field.UnderlyingIssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepoCollateralSecurityType gets UnderlyingRepoCollateralSecurityType, Tag 243 +func (m NoUnderlyings) GetUnderlyingRepoCollateralSecurityType() (f field.UnderlyingRepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepurchaseTerm gets UnderlyingRepurchaseTerm, Tag 244 +func (m NoUnderlyings) GetUnderlyingRepurchaseTerm() (f field.UnderlyingRepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepurchaseRate gets UnderlyingRepurchaseRate, Tag 245 +func (m NoUnderlyings) GetUnderlyingRepurchaseRate() (f field.UnderlyingRepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingFactor gets UnderlyingFactor, Tag 246 +func (m NoUnderlyings) GetUnderlyingFactor() (f field.UnderlyingFactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCreditRating gets UnderlyingCreditRating, Tag 256 +func (m NoUnderlyings) GetUnderlyingCreditRating() (f field.UnderlyingCreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingInstrRegistry gets UnderlyingInstrRegistry, Tag 595 +func (m NoUnderlyings) GetUnderlyingInstrRegistry() (f field.UnderlyingInstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCountryOfIssue gets UnderlyingCountryOfIssue, Tag 592 +func (m NoUnderlyings) GetUnderlyingCountryOfIssue() (f field.UnderlyingCountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStateOrProvinceOfIssue gets UnderlyingStateOrProvinceOfIssue, Tag 593 +func (m NoUnderlyings) GetUnderlyingStateOrProvinceOfIssue() (f field.UnderlyingStateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingLocaleOfIssue gets UnderlyingLocaleOfIssue, Tag 594 +func (m NoUnderlyings) GetUnderlyingLocaleOfIssue() (f field.UnderlyingLocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRedemptionDate gets UnderlyingRedemptionDate, Tag 247 +func (m NoUnderlyings) GetUnderlyingRedemptionDate() (f field.UnderlyingRedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStrikePrice gets UnderlyingStrikePrice, Tag 316 +func (m NoUnderlyings) GetUnderlyingStrikePrice() (f field.UnderlyingStrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStrikeCurrency gets UnderlyingStrikeCurrency, Tag 941 +func (m NoUnderlyings) GetUnderlyingStrikeCurrency() (f field.UnderlyingStrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingOptAttribute gets UnderlyingOptAttribute, Tag 317 +func (m NoUnderlyings) GetUnderlyingOptAttribute() (f field.UnderlyingOptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingContractMultiplier gets UnderlyingContractMultiplier, Tag 436 +func (m NoUnderlyings) GetUnderlyingContractMultiplier() (f field.UnderlyingContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCouponRate gets UnderlyingCouponRate, Tag 435 +func (m NoUnderlyings) GetUnderlyingCouponRate() (f field.UnderlyingCouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityExchange gets UnderlyingSecurityExchange, Tag 308 +func (m NoUnderlyings) GetUnderlyingSecurityExchange() (f field.UnderlyingSecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingIssuer gets UnderlyingIssuer, Tag 306 +func (m NoUnderlyings) GetUnderlyingIssuer() (f field.UnderlyingIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingIssuerLen gets EncodedUnderlyingIssuerLen, Tag 362 +func (m NoUnderlyings) GetEncodedUnderlyingIssuerLen() (f field.EncodedUnderlyingIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingIssuer gets EncodedUnderlyingIssuer, Tag 363 +func (m NoUnderlyings) GetEncodedUnderlyingIssuer() (f field.EncodedUnderlyingIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityDesc gets UnderlyingSecurityDesc, Tag 307 +func (m NoUnderlyings) GetUnderlyingSecurityDesc() (f field.UnderlyingSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingSecurityDescLen gets EncodedUnderlyingSecurityDescLen, Tag 364 +func (m NoUnderlyings) GetEncodedUnderlyingSecurityDescLen() (f field.EncodedUnderlyingSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingSecurityDesc gets EncodedUnderlyingSecurityDesc, Tag 365 +func (m NoUnderlyings) GetEncodedUnderlyingSecurityDesc() (f field.EncodedUnderlyingSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCPProgram gets UnderlyingCPProgram, Tag 877 +func (m NoUnderlyings) GetUnderlyingCPProgram() (f field.UnderlyingCPProgramField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCPRegType gets UnderlyingCPRegType, Tag 878 +func (m NoUnderlyings) GetUnderlyingCPRegType() (f field.UnderlyingCPRegTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCurrency gets UnderlyingCurrency, Tag 318 +func (m NoUnderlyings) GetUnderlyingCurrency() (f field.UnderlyingCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingQty gets UnderlyingQty, Tag 879 +func (m NoUnderlyings) GetUnderlyingQty() (f field.UnderlyingQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingPx gets UnderlyingPx, Tag 810 +func (m NoUnderlyings) GetUnderlyingPx() (f field.UnderlyingPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingDirtyPrice gets UnderlyingDirtyPrice, Tag 882 +func (m NoUnderlyings) GetUnderlyingDirtyPrice() (f field.UnderlyingDirtyPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingEndPrice gets UnderlyingEndPrice, Tag 883 +func (m NoUnderlyings) GetUnderlyingEndPrice() (f field.UnderlyingEndPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStartValue gets UnderlyingStartValue, Tag 884 +func (m NoUnderlyings) GetUnderlyingStartValue() (f field.UnderlyingStartValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCurrentValue gets UnderlyingCurrentValue, Tag 885 +func (m NoUnderlyings) GetUnderlyingCurrentValue() (f field.UnderlyingCurrentValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingEndValue gets UnderlyingEndValue, Tag 886 +func (m NoUnderlyings) GetUnderlyingEndValue() (f field.UnderlyingEndValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyingStips gets NoUnderlyingStips, Tag 887 +func (m NoUnderlyings) GetNoUnderlyingStips() (NoUnderlyingStipsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingStipsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasUnderlyingSymbol returns true if UnderlyingSymbol is present, Tag 311 +func (m NoUnderlyings) HasUnderlyingSymbol() bool { + return m.Has(tag.UnderlyingSymbol) +} + +//HasUnderlyingSymbolSfx returns true if UnderlyingSymbolSfx is present, Tag 312 +func (m NoUnderlyings) HasUnderlyingSymbolSfx() bool { + return m.Has(tag.UnderlyingSymbolSfx) +} + +//HasUnderlyingSecurityID returns true if UnderlyingSecurityID is present, Tag 309 +func (m NoUnderlyings) HasUnderlyingSecurityID() bool { + return m.Has(tag.UnderlyingSecurityID) +} + +//HasUnderlyingSecurityIDSource returns true if UnderlyingSecurityIDSource is present, Tag 305 +func (m NoUnderlyings) HasUnderlyingSecurityIDSource() bool { + return m.Has(tag.UnderlyingSecurityIDSource) +} + +//HasNoUnderlyingSecurityAltID returns true if NoUnderlyingSecurityAltID is present, Tag 457 +func (m NoUnderlyings) HasNoUnderlyingSecurityAltID() bool { + return m.Has(tag.NoUnderlyingSecurityAltID) +} + +//HasUnderlyingProduct returns true if UnderlyingProduct is present, Tag 462 +func (m NoUnderlyings) HasUnderlyingProduct() bool { + return m.Has(tag.UnderlyingProduct) +} + +//HasUnderlyingCFICode returns true if UnderlyingCFICode is present, Tag 463 +func (m NoUnderlyings) HasUnderlyingCFICode() bool { + return m.Has(tag.UnderlyingCFICode) +} + +//HasUnderlyingSecurityType returns true if UnderlyingSecurityType is present, Tag 310 +func (m NoUnderlyings) HasUnderlyingSecurityType() bool { + return m.Has(tag.UnderlyingSecurityType) +} + +//HasUnderlyingSecuritySubType returns true if UnderlyingSecuritySubType is present, Tag 763 +func (m NoUnderlyings) HasUnderlyingSecuritySubType() bool { + return m.Has(tag.UnderlyingSecuritySubType) +} + +//HasUnderlyingMaturityMonthYear returns true if UnderlyingMaturityMonthYear is present, Tag 313 +func (m NoUnderlyings) HasUnderlyingMaturityMonthYear() bool { + return m.Has(tag.UnderlyingMaturityMonthYear) +} + +//HasUnderlyingMaturityDate returns true if UnderlyingMaturityDate is present, Tag 542 +func (m NoUnderlyings) HasUnderlyingMaturityDate() bool { + return m.Has(tag.UnderlyingMaturityDate) +} + +//HasUnderlyingCouponPaymentDate returns true if UnderlyingCouponPaymentDate is present, Tag 241 +func (m NoUnderlyings) HasUnderlyingCouponPaymentDate() bool { + return m.Has(tag.UnderlyingCouponPaymentDate) +} + +//HasUnderlyingIssueDate returns true if UnderlyingIssueDate is present, Tag 242 +func (m NoUnderlyings) HasUnderlyingIssueDate() bool { + return m.Has(tag.UnderlyingIssueDate) +} + +//HasUnderlyingRepoCollateralSecurityType returns true if UnderlyingRepoCollateralSecurityType is present, Tag 243 +func (m NoUnderlyings) HasUnderlyingRepoCollateralSecurityType() bool { + return m.Has(tag.UnderlyingRepoCollateralSecurityType) +} + +//HasUnderlyingRepurchaseTerm returns true if UnderlyingRepurchaseTerm is present, Tag 244 +func (m NoUnderlyings) HasUnderlyingRepurchaseTerm() bool { + return m.Has(tag.UnderlyingRepurchaseTerm) +} + +//HasUnderlyingRepurchaseRate returns true if UnderlyingRepurchaseRate is present, Tag 245 +func (m NoUnderlyings) HasUnderlyingRepurchaseRate() bool { + return m.Has(tag.UnderlyingRepurchaseRate) +} + +//HasUnderlyingFactor returns true if UnderlyingFactor is present, Tag 246 +func (m NoUnderlyings) HasUnderlyingFactor() bool { + return m.Has(tag.UnderlyingFactor) +} + +//HasUnderlyingCreditRating returns true if UnderlyingCreditRating is present, Tag 256 +func (m NoUnderlyings) HasUnderlyingCreditRating() bool { + return m.Has(tag.UnderlyingCreditRating) +} + +//HasUnderlyingInstrRegistry returns true if UnderlyingInstrRegistry is present, Tag 595 +func (m NoUnderlyings) HasUnderlyingInstrRegistry() bool { + return m.Has(tag.UnderlyingInstrRegistry) +} + +//HasUnderlyingCountryOfIssue returns true if UnderlyingCountryOfIssue is present, Tag 592 +func (m NoUnderlyings) HasUnderlyingCountryOfIssue() bool { + return m.Has(tag.UnderlyingCountryOfIssue) +} + +//HasUnderlyingStateOrProvinceOfIssue returns true if UnderlyingStateOrProvinceOfIssue is present, Tag 593 +func (m NoUnderlyings) HasUnderlyingStateOrProvinceOfIssue() bool { + return m.Has(tag.UnderlyingStateOrProvinceOfIssue) +} + +//HasUnderlyingLocaleOfIssue returns true if UnderlyingLocaleOfIssue is present, Tag 594 +func (m NoUnderlyings) HasUnderlyingLocaleOfIssue() bool { + return m.Has(tag.UnderlyingLocaleOfIssue) +} + +//HasUnderlyingRedemptionDate returns true if UnderlyingRedemptionDate is present, Tag 247 +func (m NoUnderlyings) HasUnderlyingRedemptionDate() bool { + return m.Has(tag.UnderlyingRedemptionDate) +} + +//HasUnderlyingStrikePrice returns true if UnderlyingStrikePrice is present, Tag 316 +func (m NoUnderlyings) HasUnderlyingStrikePrice() bool { + return m.Has(tag.UnderlyingStrikePrice) +} + +//HasUnderlyingStrikeCurrency returns true if UnderlyingStrikeCurrency is present, Tag 941 +func (m NoUnderlyings) HasUnderlyingStrikeCurrency() bool { + return m.Has(tag.UnderlyingStrikeCurrency) +} + +//HasUnderlyingOptAttribute returns true if UnderlyingOptAttribute is present, Tag 317 +func (m NoUnderlyings) HasUnderlyingOptAttribute() bool { + return m.Has(tag.UnderlyingOptAttribute) +} + +//HasUnderlyingContractMultiplier returns true if UnderlyingContractMultiplier is present, Tag 436 +func (m NoUnderlyings) HasUnderlyingContractMultiplier() bool { + return m.Has(tag.UnderlyingContractMultiplier) +} + +//HasUnderlyingCouponRate returns true if UnderlyingCouponRate is present, Tag 435 +func (m NoUnderlyings) HasUnderlyingCouponRate() bool { + return m.Has(tag.UnderlyingCouponRate) +} + +//HasUnderlyingSecurityExchange returns true if UnderlyingSecurityExchange is present, Tag 308 +func (m NoUnderlyings) HasUnderlyingSecurityExchange() bool { + return m.Has(tag.UnderlyingSecurityExchange) +} + +//HasUnderlyingIssuer returns true if UnderlyingIssuer is present, Tag 306 +func (m NoUnderlyings) HasUnderlyingIssuer() bool { + return m.Has(tag.UnderlyingIssuer) +} + +//HasEncodedUnderlyingIssuerLen returns true if EncodedUnderlyingIssuerLen is present, Tag 362 +func (m NoUnderlyings) HasEncodedUnderlyingIssuerLen() bool { + return m.Has(tag.EncodedUnderlyingIssuerLen) +} + +//HasEncodedUnderlyingIssuer returns true if EncodedUnderlyingIssuer is present, Tag 363 +func (m NoUnderlyings) HasEncodedUnderlyingIssuer() bool { + return m.Has(tag.EncodedUnderlyingIssuer) +} + +//HasUnderlyingSecurityDesc returns true if UnderlyingSecurityDesc is present, Tag 307 +func (m NoUnderlyings) HasUnderlyingSecurityDesc() bool { + return m.Has(tag.UnderlyingSecurityDesc) +} + +//HasEncodedUnderlyingSecurityDescLen returns true if EncodedUnderlyingSecurityDescLen is present, Tag 364 +func (m NoUnderlyings) HasEncodedUnderlyingSecurityDescLen() bool { + return m.Has(tag.EncodedUnderlyingSecurityDescLen) +} + +//HasEncodedUnderlyingSecurityDesc returns true if EncodedUnderlyingSecurityDesc is present, Tag 365 +func (m NoUnderlyings) HasEncodedUnderlyingSecurityDesc() bool { + return m.Has(tag.EncodedUnderlyingSecurityDesc) +} + +//HasUnderlyingCPProgram returns true if UnderlyingCPProgram is present, Tag 877 +func (m NoUnderlyings) HasUnderlyingCPProgram() bool { + return m.Has(tag.UnderlyingCPProgram) +} + +//HasUnderlyingCPRegType returns true if UnderlyingCPRegType is present, Tag 878 +func (m NoUnderlyings) HasUnderlyingCPRegType() bool { + return m.Has(tag.UnderlyingCPRegType) +} + +//HasUnderlyingCurrency returns true if UnderlyingCurrency is present, Tag 318 +func (m NoUnderlyings) HasUnderlyingCurrency() bool { + return m.Has(tag.UnderlyingCurrency) +} + +//HasUnderlyingQty returns true if UnderlyingQty is present, Tag 879 +func (m NoUnderlyings) HasUnderlyingQty() bool { + return m.Has(tag.UnderlyingQty) +} + +//HasUnderlyingPx returns true if UnderlyingPx is present, Tag 810 +func (m NoUnderlyings) HasUnderlyingPx() bool { + return m.Has(tag.UnderlyingPx) +} + +//HasUnderlyingDirtyPrice returns true if UnderlyingDirtyPrice is present, Tag 882 +func (m NoUnderlyings) HasUnderlyingDirtyPrice() bool { + return m.Has(tag.UnderlyingDirtyPrice) +} + +//HasUnderlyingEndPrice returns true if UnderlyingEndPrice is present, Tag 883 +func (m NoUnderlyings) HasUnderlyingEndPrice() bool { + return m.Has(tag.UnderlyingEndPrice) +} + +//HasUnderlyingStartValue returns true if UnderlyingStartValue is present, Tag 884 +func (m NoUnderlyings) HasUnderlyingStartValue() bool { + return m.Has(tag.UnderlyingStartValue) +} + +//HasUnderlyingCurrentValue returns true if UnderlyingCurrentValue is present, Tag 885 +func (m NoUnderlyings) HasUnderlyingCurrentValue() bool { + return m.Has(tag.UnderlyingCurrentValue) +} + +//HasUnderlyingEndValue returns true if UnderlyingEndValue is present, Tag 886 +func (m NoUnderlyings) HasUnderlyingEndValue() bool { + return m.Has(tag.UnderlyingEndValue) +} + +//HasNoUnderlyingStips returns true if NoUnderlyingStips is present, Tag 887 +func (m NoUnderlyings) HasNoUnderlyingStips() bool { + return m.Has(tag.NoUnderlyingStips) +} + +//NoUnderlyingSecurityAltID is a repeating group element, Tag 457 +type NoUnderlyingSecurityAltID struct { + quickfix.Group +} + +//SetUnderlyingSecurityAltID sets UnderlyingSecurityAltID, Tag 458 +func (m NoUnderlyingSecurityAltID) SetUnderlyingSecurityAltID(v string) { + m.Set(field.NewUnderlyingSecurityAltID(v)) +} + +//SetUnderlyingSecurityAltIDSource sets UnderlyingSecurityAltIDSource, Tag 459 +func (m NoUnderlyingSecurityAltID) SetUnderlyingSecurityAltIDSource(v string) { + m.Set(field.NewUnderlyingSecurityAltIDSource(v)) +} + +//GetUnderlyingSecurityAltID gets UnderlyingSecurityAltID, Tag 458 +func (m NoUnderlyingSecurityAltID) GetUnderlyingSecurityAltID() (f field.UnderlyingSecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityAltIDSource gets UnderlyingSecurityAltIDSource, Tag 459 +func (m NoUnderlyingSecurityAltID) GetUnderlyingSecurityAltIDSource() (f field.UnderlyingSecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingSecurityAltID returns true if UnderlyingSecurityAltID is present, Tag 458 +func (m NoUnderlyingSecurityAltID) HasUnderlyingSecurityAltID() bool { + return m.Has(tag.UnderlyingSecurityAltID) +} + +//HasUnderlyingSecurityAltIDSource returns true if UnderlyingSecurityAltIDSource is present, Tag 459 +func (m NoUnderlyingSecurityAltID) HasUnderlyingSecurityAltIDSource() bool { + return m.Has(tag.UnderlyingSecurityAltIDSource) +} + +//NoUnderlyingSecurityAltIDRepeatingGroup is a repeating group, Tag 457 +type NoUnderlyingSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingSecurityAltIDRepeatingGroup returns an initialized, NoUnderlyingSecurityAltIDRepeatingGroup +func NewNoUnderlyingSecurityAltIDRepeatingGroup() NoUnderlyingSecurityAltIDRepeatingGroup { + return NoUnderlyingSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyingSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingSecurityAltID), quickfix.GroupElement(tag.UnderlyingSecurityAltIDSource)})} +} + +//Add create and append a new NoUnderlyingSecurityAltID to this group +func (m NoUnderlyingSecurityAltIDRepeatingGroup) Add() NoUnderlyingSecurityAltID { + g := m.RepeatingGroup.Add() + return NoUnderlyingSecurityAltID{g} +} + +//Get returns the ith NoUnderlyingSecurityAltID in the NoUnderlyingSecurityAltIDRepeatinGroup +func (m NoUnderlyingSecurityAltIDRepeatingGroup) Get(i int) NoUnderlyingSecurityAltID { + return NoUnderlyingSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyingStips is a repeating group element, Tag 887 +type NoUnderlyingStips struct { + quickfix.Group +} + +//SetUnderlyingStipType sets UnderlyingStipType, Tag 888 +func (m NoUnderlyingStips) SetUnderlyingStipType(v string) { + m.Set(field.NewUnderlyingStipType(v)) +} + +//SetUnderlyingStipValue sets UnderlyingStipValue, Tag 889 +func (m NoUnderlyingStips) SetUnderlyingStipValue(v string) { + m.Set(field.NewUnderlyingStipValue(v)) +} + +//GetUnderlyingStipType gets UnderlyingStipType, Tag 888 +func (m NoUnderlyingStips) GetUnderlyingStipType() (f field.UnderlyingStipTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStipValue gets UnderlyingStipValue, Tag 889 +func (m NoUnderlyingStips) GetUnderlyingStipValue() (f field.UnderlyingStipValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingStipType returns true if UnderlyingStipType is present, Tag 888 +func (m NoUnderlyingStips) HasUnderlyingStipType() bool { + return m.Has(tag.UnderlyingStipType) +} + +//HasUnderlyingStipValue returns true if UnderlyingStipValue is present, Tag 889 +func (m NoUnderlyingStips) HasUnderlyingStipValue() bool { + return m.Has(tag.UnderlyingStipValue) +} + +//NoUnderlyingStipsRepeatingGroup is a repeating group, Tag 887 +type NoUnderlyingStipsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingStipsRepeatingGroup returns an initialized, NoUnderlyingStipsRepeatingGroup +func NewNoUnderlyingStipsRepeatingGroup() NoUnderlyingStipsRepeatingGroup { + return NoUnderlyingStipsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyingStips, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingStipType), quickfix.GroupElement(tag.UnderlyingStipValue)})} +} + +//Add create and append a new NoUnderlyingStips to this group +func (m NoUnderlyingStipsRepeatingGroup) Add() NoUnderlyingStips { + g := m.RepeatingGroup.Add() + return NoUnderlyingStips{g} +} + +//Get returns the ith NoUnderlyingStips in the NoUnderlyingStipsRepeatinGroup +func (m NoUnderlyingStipsRepeatingGroup) Get(i int) NoUnderlyingStips { + return NoUnderlyingStips{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyingsRepeatingGroup is a repeating group, Tag 711 +type NoUnderlyingsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingsRepeatingGroup returns an initialized, NoUnderlyingsRepeatingGroup +func NewNoUnderlyingsRepeatingGroup() NoUnderlyingsRepeatingGroup { + return NoUnderlyingsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyings, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingSymbol), quickfix.GroupElement(tag.UnderlyingSymbolSfx), quickfix.GroupElement(tag.UnderlyingSecurityID), quickfix.GroupElement(tag.UnderlyingSecurityIDSource), NewNoUnderlyingSecurityAltIDRepeatingGroup(), quickfix.GroupElement(tag.UnderlyingProduct), quickfix.GroupElement(tag.UnderlyingCFICode), quickfix.GroupElement(tag.UnderlyingSecurityType), quickfix.GroupElement(tag.UnderlyingSecuritySubType), quickfix.GroupElement(tag.UnderlyingMaturityMonthYear), quickfix.GroupElement(tag.UnderlyingMaturityDate), quickfix.GroupElement(tag.UnderlyingCouponPaymentDate), quickfix.GroupElement(tag.UnderlyingIssueDate), quickfix.GroupElement(tag.UnderlyingRepoCollateralSecurityType), quickfix.GroupElement(tag.UnderlyingRepurchaseTerm), quickfix.GroupElement(tag.UnderlyingRepurchaseRate), quickfix.GroupElement(tag.UnderlyingFactor), quickfix.GroupElement(tag.UnderlyingCreditRating), quickfix.GroupElement(tag.UnderlyingInstrRegistry), quickfix.GroupElement(tag.UnderlyingCountryOfIssue), quickfix.GroupElement(tag.UnderlyingStateOrProvinceOfIssue), quickfix.GroupElement(tag.UnderlyingLocaleOfIssue), quickfix.GroupElement(tag.UnderlyingRedemptionDate), quickfix.GroupElement(tag.UnderlyingStrikePrice), quickfix.GroupElement(tag.UnderlyingStrikeCurrency), quickfix.GroupElement(tag.UnderlyingOptAttribute), quickfix.GroupElement(tag.UnderlyingContractMultiplier), quickfix.GroupElement(tag.UnderlyingCouponRate), quickfix.GroupElement(tag.UnderlyingSecurityExchange), quickfix.GroupElement(tag.UnderlyingIssuer), quickfix.GroupElement(tag.EncodedUnderlyingIssuerLen), quickfix.GroupElement(tag.EncodedUnderlyingIssuer), quickfix.GroupElement(tag.UnderlyingSecurityDesc), quickfix.GroupElement(tag.EncodedUnderlyingSecurityDescLen), quickfix.GroupElement(tag.EncodedUnderlyingSecurityDesc), quickfix.GroupElement(tag.UnderlyingCPProgram), quickfix.GroupElement(tag.UnderlyingCPRegType), quickfix.GroupElement(tag.UnderlyingCurrency), quickfix.GroupElement(tag.UnderlyingQty), quickfix.GroupElement(tag.UnderlyingPx), quickfix.GroupElement(tag.UnderlyingDirtyPrice), quickfix.GroupElement(tag.UnderlyingEndPrice), quickfix.GroupElement(tag.UnderlyingStartValue), quickfix.GroupElement(tag.UnderlyingCurrentValue), quickfix.GroupElement(tag.UnderlyingEndValue), NewNoUnderlyingStipsRepeatingGroup()})} +} + +//Add create and append a new NoUnderlyings to this group +func (m NoUnderlyingsRepeatingGroup) Add() NoUnderlyings { + g := m.RepeatingGroup.Add() + return NoUnderlyings{g} +} + +//Get returns the ith NoUnderlyings in the NoUnderlyingsRepeatinGroup +func (m NoUnderlyingsRepeatingGroup) Get(i int) NoUnderlyings { + return NoUnderlyings{m.RepeatingGroup.Get(i)} +} + +//NoEvents is a repeating group element, Tag 864 +type NoEvents struct { + quickfix.Group +} + +//SetEventType sets EventType, Tag 865 +func (m NoEvents) SetEventType(v int) { + m.Set(field.NewEventType(v)) +} + +//SetEventDate sets EventDate, Tag 866 +func (m NoEvents) SetEventDate(v string) { + m.Set(field.NewEventDate(v)) +} + +//SetEventPx sets EventPx, Tag 867 +func (m NoEvents) SetEventPx(v float64) { + m.Set(field.NewEventPx(v)) +} + +//SetEventText sets EventText, Tag 868 +func (m NoEvents) SetEventText(v string) { + m.Set(field.NewEventText(v)) +} + +//GetEventType gets EventType, Tag 865 +func (m NoEvents) GetEventType() (f field.EventTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventDate gets EventDate, Tag 866 +func (m NoEvents) GetEventDate() (f field.EventDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventPx gets EventPx, Tag 867 +func (m NoEvents) GetEventPx() (f field.EventPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventText gets EventText, Tag 868 +func (m NoEvents) GetEventText() (f field.EventTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasEventType returns true if EventType is present, Tag 865 +func (m NoEvents) HasEventType() bool { + return m.Has(tag.EventType) +} + +//HasEventDate returns true if EventDate is present, Tag 866 +func (m NoEvents) HasEventDate() bool { + return m.Has(tag.EventDate) +} + +//HasEventPx returns true if EventPx is present, Tag 867 +func (m NoEvents) HasEventPx() bool { + return m.Has(tag.EventPx) +} + +//HasEventText returns true if EventText is present, Tag 868 +func (m NoEvents) HasEventText() bool { + return m.Has(tag.EventText) +} + +//NoEventsRepeatingGroup is a repeating group, Tag 864 +type NoEventsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoEventsRepeatingGroup returns an initialized, NoEventsRepeatingGroup +func NewNoEventsRepeatingGroup() NoEventsRepeatingGroup { + return NoEventsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoEvents, + quickfix.GroupTemplate{quickfix.GroupElement(tag.EventType), quickfix.GroupElement(tag.EventDate), quickfix.GroupElement(tag.EventPx), quickfix.GroupElement(tag.EventText)})} +} + +//Add create and append a new NoEvents to this group +func (m NoEventsRepeatingGroup) Add() NoEvents { + g := m.RepeatingGroup.Add() + return NoEvents{g} +} + +//Get returns the ith NoEvents in the NoEventsRepeatinGroup +func (m NoEventsRepeatingGroup) Get(i int) NoEvents { + return NoEvents{m.RepeatingGroup.Get(i)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix44/header.generated.go b/vendor/github.com/quickfixgo/quickfix/fix44/header.generated.go new file mode 100644 index 0000000..aa7d16d --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix44/header.generated.go @@ -0,0 +1,530 @@ +package fix44 + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/tag" +) + +//Header is the fix44 Header type +type Header struct { + quickfix.Header +} + +//NewHeader returns a new, initialized Header instance +func NewHeader() (h Header) { + h.Init() + h.SetBeginString("FIX.4.4") + return +} + +//SetBeginString sets BeginString, Tag 8 +func (h Header) SetBeginString(v string) { + h.Set(field.NewBeginString(v)) +} + +//SetBodyLength sets BodyLength, Tag 9 +func (h Header) SetBodyLength(v int) { + h.Set(field.NewBodyLength(v)) +} + +//SetMsgSeqNum sets MsgSeqNum, Tag 34 +func (h Header) SetMsgSeqNum(v int) { + h.Set(field.NewMsgSeqNum(v)) +} + +//SetMsgType sets MsgType, Tag 35 +func (h Header) SetMsgType(v string) { + h.Set(field.NewMsgType(v)) +} + +//SetPossDupFlag sets PossDupFlag, Tag 43 +func (h Header) SetPossDupFlag(v bool) { + h.Set(field.NewPossDupFlag(v)) +} + +//SetSenderCompID sets SenderCompID, Tag 49 +func (h Header) SetSenderCompID(v string) { + h.Set(field.NewSenderCompID(v)) +} + +//SetSenderSubID sets SenderSubID, Tag 50 +func (h Header) SetSenderSubID(v string) { + h.Set(field.NewSenderSubID(v)) +} + +//SetSendingTime sets SendingTime, Tag 52 +func (h Header) SetSendingTime(v time.Time) { + h.Set(field.NewSendingTime(v)) +} + +//SetTargetCompID sets TargetCompID, Tag 56 +func (h Header) SetTargetCompID(v string) { + h.Set(field.NewTargetCompID(v)) +} + +//SetTargetSubID sets TargetSubID, Tag 57 +func (h Header) SetTargetSubID(v string) { + h.Set(field.NewTargetSubID(v)) +} + +//SetSecureDataLen sets SecureDataLen, Tag 90 +func (h Header) SetSecureDataLen(v int) { + h.Set(field.NewSecureDataLen(v)) +} + +//SetSecureData sets SecureData, Tag 91 +func (h Header) SetSecureData(v string) { + h.Set(field.NewSecureData(v)) +} + +//SetPossResend sets PossResend, Tag 97 +func (h Header) SetPossResend(v bool) { + h.Set(field.NewPossResend(v)) +} + +//SetOnBehalfOfCompID sets OnBehalfOfCompID, Tag 115 +func (h Header) SetOnBehalfOfCompID(v string) { + h.Set(field.NewOnBehalfOfCompID(v)) +} + +//SetOnBehalfOfSubID sets OnBehalfOfSubID, Tag 116 +func (h Header) SetOnBehalfOfSubID(v string) { + h.Set(field.NewOnBehalfOfSubID(v)) +} + +//SetOrigSendingTime sets OrigSendingTime, Tag 122 +func (h Header) SetOrigSendingTime(v time.Time) { + h.Set(field.NewOrigSendingTime(v)) +} + +//SetDeliverToCompID sets DeliverToCompID, Tag 128 +func (h Header) SetDeliverToCompID(v string) { + h.Set(field.NewDeliverToCompID(v)) +} + +//SetDeliverToSubID sets DeliverToSubID, Tag 129 +func (h Header) SetDeliverToSubID(v string) { + h.Set(field.NewDeliverToSubID(v)) +} + +//SetSenderLocationID sets SenderLocationID, Tag 142 +func (h Header) SetSenderLocationID(v string) { + h.Set(field.NewSenderLocationID(v)) +} + +//SetTargetLocationID sets TargetLocationID, Tag 143 +func (h Header) SetTargetLocationID(v string) { + h.Set(field.NewTargetLocationID(v)) +} + +//SetOnBehalfOfLocationID sets OnBehalfOfLocationID, Tag 144 +func (h Header) SetOnBehalfOfLocationID(v string) { + h.Set(field.NewOnBehalfOfLocationID(v)) +} + +//SetDeliverToLocationID sets DeliverToLocationID, Tag 145 +func (h Header) SetDeliverToLocationID(v string) { + h.Set(field.NewDeliverToLocationID(v)) +} + +//SetXmlDataLen sets XmlDataLen, Tag 212 +func (h Header) SetXmlDataLen(v int) { + h.Set(field.NewXmlDataLen(v)) +} + +//SetXmlData sets XmlData, Tag 213 +func (h Header) SetXmlData(v string) { + h.Set(field.NewXmlData(v)) +} + +//SetMessageEncoding sets MessageEncoding, Tag 347 +func (h Header) SetMessageEncoding(v string) { + h.Set(field.NewMessageEncoding(v)) +} + +//SetLastMsgSeqNumProcessed sets LastMsgSeqNumProcessed, Tag 369 +func (h Header) SetLastMsgSeqNumProcessed(v int) { + h.Set(field.NewLastMsgSeqNumProcessed(v)) +} + +//SetNoHops sets NoHops, Tag 627 +func (h Header) SetNoHops(f NoHopsRepeatingGroup) { + h.SetGroup(f) +} + +//GetBeginString gets BeginString, Tag 8 +func (h Header) GetBeginString() (f field.BeginStringField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetBodyLength gets BodyLength, Tag 9 +func (h Header) GetBodyLength() (f field.BodyLengthField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetMsgSeqNum gets MsgSeqNum, Tag 34 +func (h Header) GetMsgSeqNum() (f field.MsgSeqNumField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetMsgType gets MsgType, Tag 35 +func (h Header) GetMsgType() (f field.MsgTypeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetPossDupFlag gets PossDupFlag, Tag 43 +func (h Header) GetPossDupFlag() (f field.PossDupFlagField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSenderCompID gets SenderCompID, Tag 49 +func (h Header) GetSenderCompID() (f field.SenderCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSenderSubID gets SenderSubID, Tag 50 +func (h Header) GetSenderSubID() (f field.SenderSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSendingTime gets SendingTime, Tag 52 +func (h Header) GetSendingTime() (f field.SendingTimeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetTargetCompID gets TargetCompID, Tag 56 +func (h Header) GetTargetCompID() (f field.TargetCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetTargetSubID gets TargetSubID, Tag 57 +func (h Header) GetTargetSubID() (f field.TargetSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSecureDataLen gets SecureDataLen, Tag 90 +func (h Header) GetSecureDataLen() (f field.SecureDataLenField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSecureData gets SecureData, Tag 91 +func (h Header) GetSecureData() (f field.SecureDataField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetPossResend gets PossResend, Tag 97 +func (h Header) GetPossResend() (f field.PossResendField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOnBehalfOfCompID gets OnBehalfOfCompID, Tag 115 +func (h Header) GetOnBehalfOfCompID() (f field.OnBehalfOfCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOnBehalfOfSubID gets OnBehalfOfSubID, Tag 116 +func (h Header) GetOnBehalfOfSubID() (f field.OnBehalfOfSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOrigSendingTime gets OrigSendingTime, Tag 122 +func (h Header) GetOrigSendingTime() (f field.OrigSendingTimeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetDeliverToCompID gets DeliverToCompID, Tag 128 +func (h Header) GetDeliverToCompID() (f field.DeliverToCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetDeliverToSubID gets DeliverToSubID, Tag 129 +func (h Header) GetDeliverToSubID() (f field.DeliverToSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSenderLocationID gets SenderLocationID, Tag 142 +func (h Header) GetSenderLocationID() (f field.SenderLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetTargetLocationID gets TargetLocationID, Tag 143 +func (h Header) GetTargetLocationID() (f field.TargetLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOnBehalfOfLocationID gets OnBehalfOfLocationID, Tag 144 +func (h Header) GetOnBehalfOfLocationID() (f field.OnBehalfOfLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetDeliverToLocationID gets DeliverToLocationID, Tag 145 +func (h Header) GetDeliverToLocationID() (f field.DeliverToLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetXmlDataLen gets XmlDataLen, Tag 212 +func (h Header) GetXmlDataLen() (f field.XmlDataLenField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetXmlData gets XmlData, Tag 213 +func (h Header) GetXmlData() (f field.XmlDataField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetMessageEncoding gets MessageEncoding, Tag 347 +func (h Header) GetMessageEncoding() (f field.MessageEncodingField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetLastMsgSeqNumProcessed gets LastMsgSeqNumProcessed, Tag 369 +func (h Header) GetLastMsgSeqNumProcessed() (f field.LastMsgSeqNumProcessedField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetNoHops gets NoHops, Tag 627 +func (h Header) GetNoHops() (NoHopsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoHopsRepeatingGroup() + err := h.GetGroup(f) + return f, err +} + +//HasBeginString returns true if BeginString is present, Tag 8 +func (h Header) HasBeginString() bool { + return h.Has(tag.BeginString) +} + +//HasBodyLength returns true if BodyLength is present, Tag 9 +func (h Header) HasBodyLength() bool { + return h.Has(tag.BodyLength) +} + +//HasMsgSeqNum returns true if MsgSeqNum is present, Tag 34 +func (h Header) HasMsgSeqNum() bool { + return h.Has(tag.MsgSeqNum) +} + +//HasMsgType returns true if MsgType is present, Tag 35 +func (h Header) HasMsgType() bool { + return h.Has(tag.MsgType) +} + +//HasPossDupFlag returns true if PossDupFlag is present, Tag 43 +func (h Header) HasPossDupFlag() bool { + return h.Has(tag.PossDupFlag) +} + +//HasSenderCompID returns true if SenderCompID is present, Tag 49 +func (h Header) HasSenderCompID() bool { + return h.Has(tag.SenderCompID) +} + +//HasSenderSubID returns true if SenderSubID is present, Tag 50 +func (h Header) HasSenderSubID() bool { + return h.Has(tag.SenderSubID) +} + +//HasSendingTime returns true if SendingTime is present, Tag 52 +func (h Header) HasSendingTime() bool { + return h.Has(tag.SendingTime) +} + +//HasTargetCompID returns true if TargetCompID is present, Tag 56 +func (h Header) HasTargetCompID() bool { + return h.Has(tag.TargetCompID) +} + +//HasTargetSubID returns true if TargetSubID is present, Tag 57 +func (h Header) HasTargetSubID() bool { + return h.Has(tag.TargetSubID) +} + +//HasSecureDataLen returns true if SecureDataLen is present, Tag 90 +func (h Header) HasSecureDataLen() bool { + return h.Has(tag.SecureDataLen) +} + +//HasSecureData returns true if SecureData is present, Tag 91 +func (h Header) HasSecureData() bool { + return h.Has(tag.SecureData) +} + +//HasPossResend returns true if PossResend is present, Tag 97 +func (h Header) HasPossResend() bool { + return h.Has(tag.PossResend) +} + +//HasOnBehalfOfCompID returns true if OnBehalfOfCompID is present, Tag 115 +func (h Header) HasOnBehalfOfCompID() bool { + return h.Has(tag.OnBehalfOfCompID) +} + +//HasOnBehalfOfSubID returns true if OnBehalfOfSubID is present, Tag 116 +func (h Header) HasOnBehalfOfSubID() bool { + return h.Has(tag.OnBehalfOfSubID) +} + +//HasOrigSendingTime returns true if OrigSendingTime is present, Tag 122 +func (h Header) HasOrigSendingTime() bool { + return h.Has(tag.OrigSendingTime) +} + +//HasDeliverToCompID returns true if DeliverToCompID is present, Tag 128 +func (h Header) HasDeliverToCompID() bool { + return h.Has(tag.DeliverToCompID) +} + +//HasDeliverToSubID returns true if DeliverToSubID is present, Tag 129 +func (h Header) HasDeliverToSubID() bool { + return h.Has(tag.DeliverToSubID) +} + +//HasSenderLocationID returns true if SenderLocationID is present, Tag 142 +func (h Header) HasSenderLocationID() bool { + return h.Has(tag.SenderLocationID) +} + +//HasTargetLocationID returns true if TargetLocationID is present, Tag 143 +func (h Header) HasTargetLocationID() bool { + return h.Has(tag.TargetLocationID) +} + +//HasOnBehalfOfLocationID returns true if OnBehalfOfLocationID is present, Tag 144 +func (h Header) HasOnBehalfOfLocationID() bool { + return h.Has(tag.OnBehalfOfLocationID) +} + +//HasDeliverToLocationID returns true if DeliverToLocationID is present, Tag 145 +func (h Header) HasDeliverToLocationID() bool { + return h.Has(tag.DeliverToLocationID) +} + +//HasXmlDataLen returns true if XmlDataLen is present, Tag 212 +func (h Header) HasXmlDataLen() bool { + return h.Has(tag.XmlDataLen) +} + +//HasXmlData returns true if XmlData is present, Tag 213 +func (h Header) HasXmlData() bool { + return h.Has(tag.XmlData) +} + +//HasMessageEncoding returns true if MessageEncoding is present, Tag 347 +func (h Header) HasMessageEncoding() bool { + return h.Has(tag.MessageEncoding) +} + +//HasLastMsgSeqNumProcessed returns true if LastMsgSeqNumProcessed is present, Tag 369 +func (h Header) HasLastMsgSeqNumProcessed() bool { + return h.Has(tag.LastMsgSeqNumProcessed) +} + +//HasNoHops returns true if NoHops is present, Tag 627 +func (h Header) HasNoHops() bool { + return h.Has(tag.NoHops) +} + +//NoHops is a repeating group element, Tag 627 +type NoHops struct { + quickfix.Group +} + +//SetHopCompID sets HopCompID, Tag 628 +func (h NoHops) SetHopCompID(v string) { + h.Set(field.NewHopCompID(v)) +} + +//SetHopSendingTime sets HopSendingTime, Tag 629 +func (h NoHops) SetHopSendingTime(v time.Time) { + h.Set(field.NewHopSendingTime(v)) +} + +//SetHopRefID sets HopRefID, Tag 630 +func (h NoHops) SetHopRefID(v int) { + h.Set(field.NewHopRefID(v)) +} + +//GetHopCompID gets HopCompID, Tag 628 +func (h NoHops) GetHopCompID() (f field.HopCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetHopSendingTime gets HopSendingTime, Tag 629 +func (h NoHops) GetHopSendingTime() (f field.HopSendingTimeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetHopRefID gets HopRefID, Tag 630 +func (h NoHops) GetHopRefID() (f field.HopRefIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//HasHopCompID returns true if HopCompID is present, Tag 628 +func (h NoHops) HasHopCompID() bool { + return h.Has(tag.HopCompID) +} + +//HasHopSendingTime returns true if HopSendingTime is present, Tag 629 +func (h NoHops) HasHopSendingTime() bool { + return h.Has(tag.HopSendingTime) +} + +//HasHopRefID returns true if HopRefID is present, Tag 630 +func (h NoHops) HasHopRefID() bool { + return h.Has(tag.HopRefID) +} + +//NoHopsRepeatingGroup is a repeating group, Tag 627 +type NoHopsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoHopsRepeatingGroup returns an initialized, NoHopsRepeatingGroup +func NewNoHopsRepeatingGroup() NoHopsRepeatingGroup { + return NoHopsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoHops, + quickfix.GroupTemplate{quickfix.GroupElement(tag.HopCompID), quickfix.GroupElement(tag.HopSendingTime), quickfix.GroupElement(tag.HopRefID)})} +} + +//Add create and append a new NoHops to this group +func (h NoHopsRepeatingGroup) Add() NoHops { + g := h.RepeatingGroup.Add() + return NoHops{g} +} + +//Get returns the ith NoHops in the NoHopsRepeatinGroup +func (h NoHopsRepeatingGroup) Get(i int) NoHops { + return NoHops{h.RepeatingGroup.Get(i)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix44/marketdatarequest/MarketDataRequest.generated.go b/vendor/github.com/quickfixgo/quickfix/fix44/marketdatarequest/MarketDataRequest.generated.go new file mode 100644 index 0000000..cadc930 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix44/marketdatarequest/MarketDataRequest.generated.go @@ -0,0 +1,2914 @@ +package marketdatarequest + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fix44" + "github.com/quickfixgo/quickfix/tag" +) + +//MarketDataRequest is the fix44 MarketDataRequest type, MsgType = V +type MarketDataRequest struct { + fix44.Header + quickfix.Body + fix44.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a MarketDataRequest from a quickfix.Message instance +func FromMessage(m quickfix.Message) MarketDataRequest { + return MarketDataRequest{ + Header: fix44.Header{Header: m.Header}, + Body: m.Body, + Trailer: fix44.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m MarketDataRequest) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a MarketDataRequest initialized with the required fields for MarketDataRequest +func New(mdreqid field.MDReqIDField, subscriptionrequesttype field.SubscriptionRequestTypeField, marketdepth field.MarketDepthField) (m MarketDataRequest) { + m.Header = fix44.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("V")) + m.Set(mdreqid) + m.Set(subscriptionrequesttype) + m.Set(marketdepth) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg MarketDataRequest, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "FIX.4.4", "V", r +} + +//SetNoRelatedSym sets NoRelatedSym, Tag 146 +func (m MarketDataRequest) SetNoRelatedSym(f NoRelatedSymRepeatingGroup) { + m.SetGroup(f) +} + +//SetMDReqID sets MDReqID, Tag 262 +func (m MarketDataRequest) SetMDReqID(v string) { + m.Set(field.NewMDReqID(v)) +} + +//SetSubscriptionRequestType sets SubscriptionRequestType, Tag 263 +func (m MarketDataRequest) SetSubscriptionRequestType(v string) { + m.Set(field.NewSubscriptionRequestType(v)) +} + +//SetMarketDepth sets MarketDepth, Tag 264 +func (m MarketDataRequest) SetMarketDepth(v int) { + m.Set(field.NewMarketDepth(v)) +} + +//SetMDUpdateType sets MDUpdateType, Tag 265 +func (m MarketDataRequest) SetMDUpdateType(v int) { + m.Set(field.NewMDUpdateType(v)) +} + +//SetAggregatedBook sets AggregatedBook, Tag 266 +func (m MarketDataRequest) SetAggregatedBook(v bool) { + m.Set(field.NewAggregatedBook(v)) +} + +//SetNoMDEntryTypes sets NoMDEntryTypes, Tag 267 +func (m MarketDataRequest) SetNoMDEntryTypes(f NoMDEntryTypesRepeatingGroup) { + m.SetGroup(f) +} + +//SetOpenCloseSettlFlag sets OpenCloseSettlFlag, Tag 286 +func (m MarketDataRequest) SetOpenCloseSettlFlag(v string) { + m.Set(field.NewOpenCloseSettlFlag(v)) +} + +//SetScope sets Scope, Tag 546 +func (m MarketDataRequest) SetScope(v string) { + m.Set(field.NewScope(v)) +} + +//SetMDImplicitDelete sets MDImplicitDelete, Tag 547 +func (m MarketDataRequest) SetMDImplicitDelete(v bool) { + m.Set(field.NewMDImplicitDelete(v)) +} + +//GetNoRelatedSym gets NoRelatedSym, Tag 146 +func (m MarketDataRequest) GetNoRelatedSym() (NoRelatedSymRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoRelatedSymRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetMDReqID gets MDReqID, Tag 262 +func (m MarketDataRequest) GetMDReqID() (f field.MDReqIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSubscriptionRequestType gets SubscriptionRequestType, Tag 263 +func (m MarketDataRequest) GetSubscriptionRequestType() (f field.SubscriptionRequestTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMarketDepth gets MarketDepth, Tag 264 +func (m MarketDataRequest) GetMarketDepth() (f field.MarketDepthField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMDUpdateType gets MDUpdateType, Tag 265 +func (m MarketDataRequest) GetMDUpdateType() (f field.MDUpdateTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAggregatedBook gets AggregatedBook, Tag 266 +func (m MarketDataRequest) GetAggregatedBook() (f field.AggregatedBookField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoMDEntryTypes gets NoMDEntryTypes, Tag 267 +func (m MarketDataRequest) GetNoMDEntryTypes() (NoMDEntryTypesRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoMDEntryTypesRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetOpenCloseSettlFlag gets OpenCloseSettlFlag, Tag 286 +func (m MarketDataRequest) GetOpenCloseSettlFlag() (f field.OpenCloseSettlFlagField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetScope gets Scope, Tag 546 +func (m MarketDataRequest) GetScope() (f field.ScopeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMDImplicitDelete gets MDImplicitDelete, Tag 547 +func (m MarketDataRequest) GetMDImplicitDelete() (f field.MDImplicitDeleteField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasNoRelatedSym returns true if NoRelatedSym is present, Tag 146 +func (m MarketDataRequest) HasNoRelatedSym() bool { + return m.Has(tag.NoRelatedSym) +} + +//HasMDReqID returns true if MDReqID is present, Tag 262 +func (m MarketDataRequest) HasMDReqID() bool { + return m.Has(tag.MDReqID) +} + +//HasSubscriptionRequestType returns true if SubscriptionRequestType is present, Tag 263 +func (m MarketDataRequest) HasSubscriptionRequestType() bool { + return m.Has(tag.SubscriptionRequestType) +} + +//HasMarketDepth returns true if MarketDepth is present, Tag 264 +func (m MarketDataRequest) HasMarketDepth() bool { + return m.Has(tag.MarketDepth) +} + +//HasMDUpdateType returns true if MDUpdateType is present, Tag 265 +func (m MarketDataRequest) HasMDUpdateType() bool { + return m.Has(tag.MDUpdateType) +} + +//HasAggregatedBook returns true if AggregatedBook is present, Tag 266 +func (m MarketDataRequest) HasAggregatedBook() bool { + return m.Has(tag.AggregatedBook) +} + +//HasNoMDEntryTypes returns true if NoMDEntryTypes is present, Tag 267 +func (m MarketDataRequest) HasNoMDEntryTypes() bool { + return m.Has(tag.NoMDEntryTypes) +} + +//HasOpenCloseSettlFlag returns true if OpenCloseSettlFlag is present, Tag 286 +func (m MarketDataRequest) HasOpenCloseSettlFlag() bool { + return m.Has(tag.OpenCloseSettlFlag) +} + +//HasScope returns true if Scope is present, Tag 546 +func (m MarketDataRequest) HasScope() bool { + return m.Has(tag.Scope) +} + +//HasMDImplicitDelete returns true if MDImplicitDelete is present, Tag 547 +func (m MarketDataRequest) HasMDImplicitDelete() bool { + return m.Has(tag.MDImplicitDelete) +} + +//NoRelatedSym is a repeating group element, Tag 146 +type NoRelatedSym struct { + quickfix.Group +} + +//SetSymbol sets Symbol, Tag 55 +func (m NoRelatedSym) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m NoRelatedSym) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m NoRelatedSym) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSecurityIDSource sets SecurityIDSource, Tag 22 +func (m NoRelatedSym) SetSecurityIDSource(v string) { + m.Set(field.NewSecurityIDSource(v)) +} + +//SetNoSecurityAltID sets NoSecurityAltID, Tag 454 +func (m NoRelatedSym) SetNoSecurityAltID(f NoSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetProduct sets Product, Tag 460 +func (m NoRelatedSym) SetProduct(v int) { + m.Set(field.NewProduct(v)) +} + +//SetCFICode sets CFICode, Tag 461 +func (m NoRelatedSym) SetCFICode(v string) { + m.Set(field.NewCFICode(v)) +} + +//SetSecurityType sets SecurityType, Tag 167 +func (m NoRelatedSym) SetSecurityType(v string) { + m.Set(field.NewSecurityType(v)) +} + +//SetSecuritySubType sets SecuritySubType, Tag 762 +func (m NoRelatedSym) SetSecuritySubType(v string) { + m.Set(field.NewSecuritySubType(v)) +} + +//SetMaturityMonthYear sets MaturityMonthYear, Tag 200 +func (m NoRelatedSym) SetMaturityMonthYear(v string) { + m.Set(field.NewMaturityMonthYear(v)) +} + +//SetMaturityDate sets MaturityDate, Tag 541 +func (m NoRelatedSym) SetMaturityDate(v string) { + m.Set(field.NewMaturityDate(v)) +} + +//SetCouponPaymentDate sets CouponPaymentDate, Tag 224 +func (m NoRelatedSym) SetCouponPaymentDate(v string) { + m.Set(field.NewCouponPaymentDate(v)) +} + +//SetIssueDate sets IssueDate, Tag 225 +func (m NoRelatedSym) SetIssueDate(v string) { + m.Set(field.NewIssueDate(v)) +} + +//SetRepoCollateralSecurityType sets RepoCollateralSecurityType, Tag 239 +func (m NoRelatedSym) SetRepoCollateralSecurityType(v int) { + m.Set(field.NewRepoCollateralSecurityType(v)) +} + +//SetRepurchaseTerm sets RepurchaseTerm, Tag 226 +func (m NoRelatedSym) SetRepurchaseTerm(v int) { + m.Set(field.NewRepurchaseTerm(v)) +} + +//SetRepurchaseRate sets RepurchaseRate, Tag 227 +func (m NoRelatedSym) SetRepurchaseRate(v float64) { + m.Set(field.NewRepurchaseRate(v)) +} + +//SetFactor sets Factor, Tag 228 +func (m NoRelatedSym) SetFactor(v float64) { + m.Set(field.NewFactor(v)) +} + +//SetCreditRating sets CreditRating, Tag 255 +func (m NoRelatedSym) SetCreditRating(v string) { + m.Set(field.NewCreditRating(v)) +} + +//SetInstrRegistry sets InstrRegistry, Tag 543 +func (m NoRelatedSym) SetInstrRegistry(v string) { + m.Set(field.NewInstrRegistry(v)) +} + +//SetCountryOfIssue sets CountryOfIssue, Tag 470 +func (m NoRelatedSym) SetCountryOfIssue(v string) { + m.Set(field.NewCountryOfIssue(v)) +} + +//SetStateOrProvinceOfIssue sets StateOrProvinceOfIssue, Tag 471 +func (m NoRelatedSym) SetStateOrProvinceOfIssue(v string) { + m.Set(field.NewStateOrProvinceOfIssue(v)) +} + +//SetLocaleOfIssue sets LocaleOfIssue, Tag 472 +func (m NoRelatedSym) SetLocaleOfIssue(v string) { + m.Set(field.NewLocaleOfIssue(v)) +} + +//SetRedemptionDate sets RedemptionDate, Tag 240 +func (m NoRelatedSym) SetRedemptionDate(v string) { + m.Set(field.NewRedemptionDate(v)) +} + +//SetStrikePrice sets StrikePrice, Tag 202 +func (m NoRelatedSym) SetStrikePrice(v float64) { + m.Set(field.NewStrikePrice(v)) +} + +//SetStrikeCurrency sets StrikeCurrency, Tag 947 +func (m NoRelatedSym) SetStrikeCurrency(v string) { + m.Set(field.NewStrikeCurrency(v)) +} + +//SetOptAttribute sets OptAttribute, Tag 206 +func (m NoRelatedSym) SetOptAttribute(v string) { + m.Set(field.NewOptAttribute(v)) +} + +//SetContractMultiplier sets ContractMultiplier, Tag 231 +func (m NoRelatedSym) SetContractMultiplier(v float64) { + m.Set(field.NewContractMultiplier(v)) +} + +//SetCouponRate sets CouponRate, Tag 223 +func (m NoRelatedSym) SetCouponRate(v float64) { + m.Set(field.NewCouponRate(v)) +} + +//SetSecurityExchange sets SecurityExchange, Tag 207 +func (m NoRelatedSym) SetSecurityExchange(v string) { + m.Set(field.NewSecurityExchange(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m NoRelatedSym) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetEncodedIssuerLen sets EncodedIssuerLen, Tag 348 +func (m NoRelatedSym) SetEncodedIssuerLen(v int) { + m.Set(field.NewEncodedIssuerLen(v)) +} + +//SetEncodedIssuer sets EncodedIssuer, Tag 349 +func (m NoRelatedSym) SetEncodedIssuer(v string) { + m.Set(field.NewEncodedIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m NoRelatedSym) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetEncodedSecurityDescLen sets EncodedSecurityDescLen, Tag 350 +func (m NoRelatedSym) SetEncodedSecurityDescLen(v int) { + m.Set(field.NewEncodedSecurityDescLen(v)) +} + +//SetEncodedSecurityDesc sets EncodedSecurityDesc, Tag 351 +func (m NoRelatedSym) SetEncodedSecurityDesc(v string) { + m.Set(field.NewEncodedSecurityDesc(v)) +} + +//SetPool sets Pool, Tag 691 +func (m NoRelatedSym) SetPool(v string) { + m.Set(field.NewPool(v)) +} + +//SetContractSettlMonth sets ContractSettlMonth, Tag 667 +func (m NoRelatedSym) SetContractSettlMonth(v string) { + m.Set(field.NewContractSettlMonth(v)) +} + +//SetCPProgram sets CPProgram, Tag 875 +func (m NoRelatedSym) SetCPProgram(v int) { + m.Set(field.NewCPProgram(v)) +} + +//SetCPRegType sets CPRegType, Tag 876 +func (m NoRelatedSym) SetCPRegType(v string) { + m.Set(field.NewCPRegType(v)) +} + +//SetNoEvents sets NoEvents, Tag 864 +func (m NoRelatedSym) SetNoEvents(f NoEventsRepeatingGroup) { + m.SetGroup(f) +} + +//SetDatedDate sets DatedDate, Tag 873 +func (m NoRelatedSym) SetDatedDate(v string) { + m.Set(field.NewDatedDate(v)) +} + +//SetInterestAccrualDate sets InterestAccrualDate, Tag 874 +func (m NoRelatedSym) SetInterestAccrualDate(v string) { + m.Set(field.NewInterestAccrualDate(v)) +} + +//SetNoUnderlyings sets NoUnderlyings, Tag 711 +func (m NoRelatedSym) SetNoUnderlyings(f NoUnderlyingsRepeatingGroup) { + m.SetGroup(f) +} + +//SetNoLegs sets NoLegs, Tag 555 +func (m NoRelatedSym) SetNoLegs(f NoLegsRepeatingGroup) { + m.SetGroup(f) +} + +//SetNoTradingSessions sets NoTradingSessions, Tag 386 +func (m NoRelatedSym) SetNoTradingSessions(f NoTradingSessionsRepeatingGroup) { + m.SetGroup(f) +} + +//SetApplQueueAction sets ApplQueueAction, Tag 815 +func (m NoRelatedSym) SetApplQueueAction(v int) { + m.Set(field.NewApplQueueAction(v)) +} + +//SetApplQueueMax sets ApplQueueMax, Tag 812 +func (m NoRelatedSym) SetApplQueueMax(v int) { + m.Set(field.NewApplQueueMax(v)) +} + +//GetSymbol gets Symbol, Tag 55 +func (m NoRelatedSym) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m NoRelatedSym) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m NoRelatedSym) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityIDSource gets SecurityIDSource, Tag 22 +func (m NoRelatedSym) GetSecurityIDSource() (f field.SecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoSecurityAltID gets NoSecurityAltID, Tag 454 +func (m NoRelatedSym) GetNoSecurityAltID() (NoSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetProduct gets Product, Tag 460 +func (m NoRelatedSym) GetProduct() (f field.ProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCFICode gets CFICode, Tag 461 +func (m NoRelatedSym) GetCFICode() (f field.CFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityType gets SecurityType, Tag 167 +func (m NoRelatedSym) GetSecurityType() (f field.SecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecuritySubType gets SecuritySubType, Tag 762 +func (m NoRelatedSym) GetSecuritySubType() (f field.SecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityMonthYear gets MaturityMonthYear, Tag 200 +func (m NoRelatedSym) GetMaturityMonthYear() (f field.MaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityDate gets MaturityDate, Tag 541 +func (m NoRelatedSym) GetMaturityDate() (f field.MaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponPaymentDate gets CouponPaymentDate, Tag 224 +func (m NoRelatedSym) GetCouponPaymentDate() (f field.CouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssueDate gets IssueDate, Tag 225 +func (m NoRelatedSym) GetIssueDate() (f field.IssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepoCollateralSecurityType gets RepoCollateralSecurityType, Tag 239 +func (m NoRelatedSym) GetRepoCollateralSecurityType() (f field.RepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseTerm gets RepurchaseTerm, Tag 226 +func (m NoRelatedSym) GetRepurchaseTerm() (f field.RepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseRate gets RepurchaseRate, Tag 227 +func (m NoRelatedSym) GetRepurchaseRate() (f field.RepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFactor gets Factor, Tag 228 +func (m NoRelatedSym) GetFactor() (f field.FactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCreditRating gets CreditRating, Tag 255 +func (m NoRelatedSym) GetCreditRating() (f field.CreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrRegistry gets InstrRegistry, Tag 543 +func (m NoRelatedSym) GetInstrRegistry() (f field.InstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCountryOfIssue gets CountryOfIssue, Tag 470 +func (m NoRelatedSym) GetCountryOfIssue() (f field.CountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStateOrProvinceOfIssue gets StateOrProvinceOfIssue, Tag 471 +func (m NoRelatedSym) GetStateOrProvinceOfIssue() (f field.StateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLocaleOfIssue gets LocaleOfIssue, Tag 472 +func (m NoRelatedSym) GetLocaleOfIssue() (f field.LocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRedemptionDate gets RedemptionDate, Tag 240 +func (m NoRelatedSym) GetRedemptionDate() (f field.RedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikePrice gets StrikePrice, Tag 202 +func (m NoRelatedSym) GetStrikePrice() (f field.StrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikeCurrency gets StrikeCurrency, Tag 947 +func (m NoRelatedSym) GetStrikeCurrency() (f field.StrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOptAttribute gets OptAttribute, Tag 206 +func (m NoRelatedSym) GetOptAttribute() (f field.OptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractMultiplier gets ContractMultiplier, Tag 231 +func (m NoRelatedSym) GetContractMultiplier() (f field.ContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponRate gets CouponRate, Tag 223 +func (m NoRelatedSym) GetCouponRate() (f field.CouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityExchange gets SecurityExchange, Tag 207 +func (m NoRelatedSym) GetSecurityExchange() (f field.SecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m NoRelatedSym) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuerLen gets EncodedIssuerLen, Tag 348 +func (m NoRelatedSym) GetEncodedIssuerLen() (f field.EncodedIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuer gets EncodedIssuer, Tag 349 +func (m NoRelatedSym) GetEncodedIssuer() (f field.EncodedIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m NoRelatedSym) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDescLen gets EncodedSecurityDescLen, Tag 350 +func (m NoRelatedSym) GetEncodedSecurityDescLen() (f field.EncodedSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDesc gets EncodedSecurityDesc, Tag 351 +func (m NoRelatedSym) GetEncodedSecurityDesc() (f field.EncodedSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPool gets Pool, Tag 691 +func (m NoRelatedSym) GetPool() (f field.PoolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractSettlMonth gets ContractSettlMonth, Tag 667 +func (m NoRelatedSym) GetContractSettlMonth() (f field.ContractSettlMonthField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCPProgram gets CPProgram, Tag 875 +func (m NoRelatedSym) GetCPProgram() (f field.CPProgramField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCPRegType gets CPRegType, Tag 876 +func (m NoRelatedSym) GetCPRegType() (f field.CPRegTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoEvents gets NoEvents, Tag 864 +func (m NoRelatedSym) GetNoEvents() (NoEventsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoEventsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetDatedDate gets DatedDate, Tag 873 +func (m NoRelatedSym) GetDatedDate() (f field.DatedDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInterestAccrualDate gets InterestAccrualDate, Tag 874 +func (m NoRelatedSym) GetInterestAccrualDate() (f field.InterestAccrualDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyings gets NoUnderlyings, Tag 711 +func (m NoRelatedSym) GetNoUnderlyings() (NoUnderlyingsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetNoLegs gets NoLegs, Tag 555 +func (m NoRelatedSym) GetNoLegs() (NoLegsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoLegsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetNoTradingSessions gets NoTradingSessions, Tag 386 +func (m NoRelatedSym) GetNoTradingSessions() (NoTradingSessionsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoTradingSessionsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetApplQueueAction gets ApplQueueAction, Tag 815 +func (m NoRelatedSym) GetApplQueueAction() (f field.ApplQueueActionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetApplQueueMax gets ApplQueueMax, Tag 812 +func (m NoRelatedSym) GetApplQueueMax() (f field.ApplQueueMaxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m NoRelatedSym) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m NoRelatedSym) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m NoRelatedSym) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSecurityIDSource returns true if SecurityIDSource is present, Tag 22 +func (m NoRelatedSym) HasSecurityIDSource() bool { + return m.Has(tag.SecurityIDSource) +} + +//HasNoSecurityAltID returns true if NoSecurityAltID is present, Tag 454 +func (m NoRelatedSym) HasNoSecurityAltID() bool { + return m.Has(tag.NoSecurityAltID) +} + +//HasProduct returns true if Product is present, Tag 460 +func (m NoRelatedSym) HasProduct() bool { + return m.Has(tag.Product) +} + +//HasCFICode returns true if CFICode is present, Tag 461 +func (m NoRelatedSym) HasCFICode() bool { + return m.Has(tag.CFICode) +} + +//HasSecurityType returns true if SecurityType is present, Tag 167 +func (m NoRelatedSym) HasSecurityType() bool { + return m.Has(tag.SecurityType) +} + +//HasSecuritySubType returns true if SecuritySubType is present, Tag 762 +func (m NoRelatedSym) HasSecuritySubType() bool { + return m.Has(tag.SecuritySubType) +} + +//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200 +func (m NoRelatedSym) HasMaturityMonthYear() bool { + return m.Has(tag.MaturityMonthYear) +} + +//HasMaturityDate returns true if MaturityDate is present, Tag 541 +func (m NoRelatedSym) HasMaturityDate() bool { + return m.Has(tag.MaturityDate) +} + +//HasCouponPaymentDate returns true if CouponPaymentDate is present, Tag 224 +func (m NoRelatedSym) HasCouponPaymentDate() bool { + return m.Has(tag.CouponPaymentDate) +} + +//HasIssueDate returns true if IssueDate is present, Tag 225 +func (m NoRelatedSym) HasIssueDate() bool { + return m.Has(tag.IssueDate) +} + +//HasRepoCollateralSecurityType returns true if RepoCollateralSecurityType is present, Tag 239 +func (m NoRelatedSym) HasRepoCollateralSecurityType() bool { + return m.Has(tag.RepoCollateralSecurityType) +} + +//HasRepurchaseTerm returns true if RepurchaseTerm is present, Tag 226 +func (m NoRelatedSym) HasRepurchaseTerm() bool { + return m.Has(tag.RepurchaseTerm) +} + +//HasRepurchaseRate returns true if RepurchaseRate is present, Tag 227 +func (m NoRelatedSym) HasRepurchaseRate() bool { + return m.Has(tag.RepurchaseRate) +} + +//HasFactor returns true if Factor is present, Tag 228 +func (m NoRelatedSym) HasFactor() bool { + return m.Has(tag.Factor) +} + +//HasCreditRating returns true if CreditRating is present, Tag 255 +func (m NoRelatedSym) HasCreditRating() bool { + return m.Has(tag.CreditRating) +} + +//HasInstrRegistry returns true if InstrRegistry is present, Tag 543 +func (m NoRelatedSym) HasInstrRegistry() bool { + return m.Has(tag.InstrRegistry) +} + +//HasCountryOfIssue returns true if CountryOfIssue is present, Tag 470 +func (m NoRelatedSym) HasCountryOfIssue() bool { + return m.Has(tag.CountryOfIssue) +} + +//HasStateOrProvinceOfIssue returns true if StateOrProvinceOfIssue is present, Tag 471 +func (m NoRelatedSym) HasStateOrProvinceOfIssue() bool { + return m.Has(tag.StateOrProvinceOfIssue) +} + +//HasLocaleOfIssue returns true if LocaleOfIssue is present, Tag 472 +func (m NoRelatedSym) HasLocaleOfIssue() bool { + return m.Has(tag.LocaleOfIssue) +} + +//HasRedemptionDate returns true if RedemptionDate is present, Tag 240 +func (m NoRelatedSym) HasRedemptionDate() bool { + return m.Has(tag.RedemptionDate) +} + +//HasStrikePrice returns true if StrikePrice is present, Tag 202 +func (m NoRelatedSym) HasStrikePrice() bool { + return m.Has(tag.StrikePrice) +} + +//HasStrikeCurrency returns true if StrikeCurrency is present, Tag 947 +func (m NoRelatedSym) HasStrikeCurrency() bool { + return m.Has(tag.StrikeCurrency) +} + +//HasOptAttribute returns true if OptAttribute is present, Tag 206 +func (m NoRelatedSym) HasOptAttribute() bool { + return m.Has(tag.OptAttribute) +} + +//HasContractMultiplier returns true if ContractMultiplier is present, Tag 231 +func (m NoRelatedSym) HasContractMultiplier() bool { + return m.Has(tag.ContractMultiplier) +} + +//HasCouponRate returns true if CouponRate is present, Tag 223 +func (m NoRelatedSym) HasCouponRate() bool { + return m.Has(tag.CouponRate) +} + +//HasSecurityExchange returns true if SecurityExchange is present, Tag 207 +func (m NoRelatedSym) HasSecurityExchange() bool { + return m.Has(tag.SecurityExchange) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m NoRelatedSym) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasEncodedIssuerLen returns true if EncodedIssuerLen is present, Tag 348 +func (m NoRelatedSym) HasEncodedIssuerLen() bool { + return m.Has(tag.EncodedIssuerLen) +} + +//HasEncodedIssuer returns true if EncodedIssuer is present, Tag 349 +func (m NoRelatedSym) HasEncodedIssuer() bool { + return m.Has(tag.EncodedIssuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m NoRelatedSym) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasEncodedSecurityDescLen returns true if EncodedSecurityDescLen is present, Tag 350 +func (m NoRelatedSym) HasEncodedSecurityDescLen() bool { + return m.Has(tag.EncodedSecurityDescLen) +} + +//HasEncodedSecurityDesc returns true if EncodedSecurityDesc is present, Tag 351 +func (m NoRelatedSym) HasEncodedSecurityDesc() bool { + return m.Has(tag.EncodedSecurityDesc) +} + +//HasPool returns true if Pool is present, Tag 691 +func (m NoRelatedSym) HasPool() bool { + return m.Has(tag.Pool) +} + +//HasContractSettlMonth returns true if ContractSettlMonth is present, Tag 667 +func (m NoRelatedSym) HasContractSettlMonth() bool { + return m.Has(tag.ContractSettlMonth) +} + +//HasCPProgram returns true if CPProgram is present, Tag 875 +func (m NoRelatedSym) HasCPProgram() bool { + return m.Has(tag.CPProgram) +} + +//HasCPRegType returns true if CPRegType is present, Tag 876 +func (m NoRelatedSym) HasCPRegType() bool { + return m.Has(tag.CPRegType) +} + +//HasNoEvents returns true if NoEvents is present, Tag 864 +func (m NoRelatedSym) HasNoEvents() bool { + return m.Has(tag.NoEvents) +} + +//HasDatedDate returns true if DatedDate is present, Tag 873 +func (m NoRelatedSym) HasDatedDate() bool { + return m.Has(tag.DatedDate) +} + +//HasInterestAccrualDate returns true if InterestAccrualDate is present, Tag 874 +func (m NoRelatedSym) HasInterestAccrualDate() bool { + return m.Has(tag.InterestAccrualDate) +} + +//HasNoUnderlyings returns true if NoUnderlyings is present, Tag 711 +func (m NoRelatedSym) HasNoUnderlyings() bool { + return m.Has(tag.NoUnderlyings) +} + +//HasNoLegs returns true if NoLegs is present, Tag 555 +func (m NoRelatedSym) HasNoLegs() bool { + return m.Has(tag.NoLegs) +} + +//HasNoTradingSessions returns true if NoTradingSessions is present, Tag 386 +func (m NoRelatedSym) HasNoTradingSessions() bool { + return m.Has(tag.NoTradingSessions) +} + +//HasApplQueueAction returns true if ApplQueueAction is present, Tag 815 +func (m NoRelatedSym) HasApplQueueAction() bool { + return m.Has(tag.ApplQueueAction) +} + +//HasApplQueueMax returns true if ApplQueueMax is present, Tag 812 +func (m NoRelatedSym) HasApplQueueMax() bool { + return m.Has(tag.ApplQueueMax) +} + +//NoSecurityAltID is a repeating group element, Tag 454 +type NoSecurityAltID struct { + quickfix.Group +} + +//SetSecurityAltID sets SecurityAltID, Tag 455 +func (m NoSecurityAltID) SetSecurityAltID(v string) { + m.Set(field.NewSecurityAltID(v)) +} + +//SetSecurityAltIDSource sets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) SetSecurityAltIDSource(v string) { + m.Set(field.NewSecurityAltIDSource(v)) +} + +//GetSecurityAltID gets SecurityAltID, Tag 455 +func (m NoSecurityAltID) GetSecurityAltID() (f field.SecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityAltIDSource gets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) GetSecurityAltIDSource() (f field.SecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasSecurityAltID returns true if SecurityAltID is present, Tag 455 +func (m NoSecurityAltID) HasSecurityAltID() bool { + return m.Has(tag.SecurityAltID) +} + +//HasSecurityAltIDSource returns true if SecurityAltIDSource is present, Tag 456 +func (m NoSecurityAltID) HasSecurityAltIDSource() bool { + return m.Has(tag.SecurityAltIDSource) +} + +//NoSecurityAltIDRepeatingGroup is a repeating group, Tag 454 +type NoSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoSecurityAltIDRepeatingGroup returns an initialized, NoSecurityAltIDRepeatingGroup +func NewNoSecurityAltIDRepeatingGroup() NoSecurityAltIDRepeatingGroup { + return NoSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.SecurityAltID), quickfix.GroupElement(tag.SecurityAltIDSource)})} +} + +//Add create and append a new NoSecurityAltID to this group +func (m NoSecurityAltIDRepeatingGroup) Add() NoSecurityAltID { + g := m.RepeatingGroup.Add() + return NoSecurityAltID{g} +} + +//Get returns the ith NoSecurityAltID in the NoSecurityAltIDRepeatinGroup +func (m NoSecurityAltIDRepeatingGroup) Get(i int) NoSecurityAltID { + return NoSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoEvents is a repeating group element, Tag 864 +type NoEvents struct { + quickfix.Group +} + +//SetEventType sets EventType, Tag 865 +func (m NoEvents) SetEventType(v int) { + m.Set(field.NewEventType(v)) +} + +//SetEventDate sets EventDate, Tag 866 +func (m NoEvents) SetEventDate(v string) { + m.Set(field.NewEventDate(v)) +} + +//SetEventPx sets EventPx, Tag 867 +func (m NoEvents) SetEventPx(v float64) { + m.Set(field.NewEventPx(v)) +} + +//SetEventText sets EventText, Tag 868 +func (m NoEvents) SetEventText(v string) { + m.Set(field.NewEventText(v)) +} + +//GetEventType gets EventType, Tag 865 +func (m NoEvents) GetEventType() (f field.EventTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventDate gets EventDate, Tag 866 +func (m NoEvents) GetEventDate() (f field.EventDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventPx gets EventPx, Tag 867 +func (m NoEvents) GetEventPx() (f field.EventPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventText gets EventText, Tag 868 +func (m NoEvents) GetEventText() (f field.EventTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasEventType returns true if EventType is present, Tag 865 +func (m NoEvents) HasEventType() bool { + return m.Has(tag.EventType) +} + +//HasEventDate returns true if EventDate is present, Tag 866 +func (m NoEvents) HasEventDate() bool { + return m.Has(tag.EventDate) +} + +//HasEventPx returns true if EventPx is present, Tag 867 +func (m NoEvents) HasEventPx() bool { + return m.Has(tag.EventPx) +} + +//HasEventText returns true if EventText is present, Tag 868 +func (m NoEvents) HasEventText() bool { + return m.Has(tag.EventText) +} + +//NoEventsRepeatingGroup is a repeating group, Tag 864 +type NoEventsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoEventsRepeatingGroup returns an initialized, NoEventsRepeatingGroup +func NewNoEventsRepeatingGroup() NoEventsRepeatingGroup { + return NoEventsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoEvents, + quickfix.GroupTemplate{quickfix.GroupElement(tag.EventType), quickfix.GroupElement(tag.EventDate), quickfix.GroupElement(tag.EventPx), quickfix.GroupElement(tag.EventText)})} +} + +//Add create and append a new NoEvents to this group +func (m NoEventsRepeatingGroup) Add() NoEvents { + g := m.RepeatingGroup.Add() + return NoEvents{g} +} + +//Get returns the ith NoEvents in the NoEventsRepeatinGroup +func (m NoEventsRepeatingGroup) Get(i int) NoEvents { + return NoEvents{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyings is a repeating group element, Tag 711 +type NoUnderlyings struct { + quickfix.Group +} + +//SetUnderlyingSymbol sets UnderlyingSymbol, Tag 311 +func (m NoUnderlyings) SetUnderlyingSymbol(v string) { + m.Set(field.NewUnderlyingSymbol(v)) +} + +//SetUnderlyingSymbolSfx sets UnderlyingSymbolSfx, Tag 312 +func (m NoUnderlyings) SetUnderlyingSymbolSfx(v string) { + m.Set(field.NewUnderlyingSymbolSfx(v)) +} + +//SetUnderlyingSecurityID sets UnderlyingSecurityID, Tag 309 +func (m NoUnderlyings) SetUnderlyingSecurityID(v string) { + m.Set(field.NewUnderlyingSecurityID(v)) +} + +//SetUnderlyingSecurityIDSource sets UnderlyingSecurityIDSource, Tag 305 +func (m NoUnderlyings) SetUnderlyingSecurityIDSource(v string) { + m.Set(field.NewUnderlyingSecurityIDSource(v)) +} + +//SetNoUnderlyingSecurityAltID sets NoUnderlyingSecurityAltID, Tag 457 +func (m NoUnderlyings) SetNoUnderlyingSecurityAltID(f NoUnderlyingSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetUnderlyingProduct sets UnderlyingProduct, Tag 462 +func (m NoUnderlyings) SetUnderlyingProduct(v int) { + m.Set(field.NewUnderlyingProduct(v)) +} + +//SetUnderlyingCFICode sets UnderlyingCFICode, Tag 463 +func (m NoUnderlyings) SetUnderlyingCFICode(v string) { + m.Set(field.NewUnderlyingCFICode(v)) +} + +//SetUnderlyingSecurityType sets UnderlyingSecurityType, Tag 310 +func (m NoUnderlyings) SetUnderlyingSecurityType(v string) { + m.Set(field.NewUnderlyingSecurityType(v)) +} + +//SetUnderlyingSecuritySubType sets UnderlyingSecuritySubType, Tag 763 +func (m NoUnderlyings) SetUnderlyingSecuritySubType(v string) { + m.Set(field.NewUnderlyingSecuritySubType(v)) +} + +//SetUnderlyingMaturityMonthYear sets UnderlyingMaturityMonthYear, Tag 313 +func (m NoUnderlyings) SetUnderlyingMaturityMonthYear(v string) { + m.Set(field.NewUnderlyingMaturityMonthYear(v)) +} + +//SetUnderlyingMaturityDate sets UnderlyingMaturityDate, Tag 542 +func (m NoUnderlyings) SetUnderlyingMaturityDate(v string) { + m.Set(field.NewUnderlyingMaturityDate(v)) +} + +//SetUnderlyingCouponPaymentDate sets UnderlyingCouponPaymentDate, Tag 241 +func (m NoUnderlyings) SetUnderlyingCouponPaymentDate(v string) { + m.Set(field.NewUnderlyingCouponPaymentDate(v)) +} + +//SetUnderlyingIssueDate sets UnderlyingIssueDate, Tag 242 +func (m NoUnderlyings) SetUnderlyingIssueDate(v string) { + m.Set(field.NewUnderlyingIssueDate(v)) +} + +//SetUnderlyingRepoCollateralSecurityType sets UnderlyingRepoCollateralSecurityType, Tag 243 +func (m NoUnderlyings) SetUnderlyingRepoCollateralSecurityType(v int) { + m.Set(field.NewUnderlyingRepoCollateralSecurityType(v)) +} + +//SetUnderlyingRepurchaseTerm sets UnderlyingRepurchaseTerm, Tag 244 +func (m NoUnderlyings) SetUnderlyingRepurchaseTerm(v int) { + m.Set(field.NewUnderlyingRepurchaseTerm(v)) +} + +//SetUnderlyingRepurchaseRate sets UnderlyingRepurchaseRate, Tag 245 +func (m NoUnderlyings) SetUnderlyingRepurchaseRate(v float64) { + m.Set(field.NewUnderlyingRepurchaseRate(v)) +} + +//SetUnderlyingFactor sets UnderlyingFactor, Tag 246 +func (m NoUnderlyings) SetUnderlyingFactor(v float64) { + m.Set(field.NewUnderlyingFactor(v)) +} + +//SetUnderlyingCreditRating sets UnderlyingCreditRating, Tag 256 +func (m NoUnderlyings) SetUnderlyingCreditRating(v string) { + m.Set(field.NewUnderlyingCreditRating(v)) +} + +//SetUnderlyingInstrRegistry sets UnderlyingInstrRegistry, Tag 595 +func (m NoUnderlyings) SetUnderlyingInstrRegistry(v string) { + m.Set(field.NewUnderlyingInstrRegistry(v)) +} + +//SetUnderlyingCountryOfIssue sets UnderlyingCountryOfIssue, Tag 592 +func (m NoUnderlyings) SetUnderlyingCountryOfIssue(v string) { + m.Set(field.NewUnderlyingCountryOfIssue(v)) +} + +//SetUnderlyingStateOrProvinceOfIssue sets UnderlyingStateOrProvinceOfIssue, Tag 593 +func (m NoUnderlyings) SetUnderlyingStateOrProvinceOfIssue(v string) { + m.Set(field.NewUnderlyingStateOrProvinceOfIssue(v)) +} + +//SetUnderlyingLocaleOfIssue sets UnderlyingLocaleOfIssue, Tag 594 +func (m NoUnderlyings) SetUnderlyingLocaleOfIssue(v string) { + m.Set(field.NewUnderlyingLocaleOfIssue(v)) +} + +//SetUnderlyingRedemptionDate sets UnderlyingRedemptionDate, Tag 247 +func (m NoUnderlyings) SetUnderlyingRedemptionDate(v string) { + m.Set(field.NewUnderlyingRedemptionDate(v)) +} + +//SetUnderlyingStrikePrice sets UnderlyingStrikePrice, Tag 316 +func (m NoUnderlyings) SetUnderlyingStrikePrice(v float64) { + m.Set(field.NewUnderlyingStrikePrice(v)) +} + +//SetUnderlyingStrikeCurrency sets UnderlyingStrikeCurrency, Tag 941 +func (m NoUnderlyings) SetUnderlyingStrikeCurrency(v string) { + m.Set(field.NewUnderlyingStrikeCurrency(v)) +} + +//SetUnderlyingOptAttribute sets UnderlyingOptAttribute, Tag 317 +func (m NoUnderlyings) SetUnderlyingOptAttribute(v string) { + m.Set(field.NewUnderlyingOptAttribute(v)) +} + +//SetUnderlyingContractMultiplier sets UnderlyingContractMultiplier, Tag 436 +func (m NoUnderlyings) SetUnderlyingContractMultiplier(v float64) { + m.Set(field.NewUnderlyingContractMultiplier(v)) +} + +//SetUnderlyingCouponRate sets UnderlyingCouponRate, Tag 435 +func (m NoUnderlyings) SetUnderlyingCouponRate(v float64) { + m.Set(field.NewUnderlyingCouponRate(v)) +} + +//SetUnderlyingSecurityExchange sets UnderlyingSecurityExchange, Tag 308 +func (m NoUnderlyings) SetUnderlyingSecurityExchange(v string) { + m.Set(field.NewUnderlyingSecurityExchange(v)) +} + +//SetUnderlyingIssuer sets UnderlyingIssuer, Tag 306 +func (m NoUnderlyings) SetUnderlyingIssuer(v string) { + m.Set(field.NewUnderlyingIssuer(v)) +} + +//SetEncodedUnderlyingIssuerLen sets EncodedUnderlyingIssuerLen, Tag 362 +func (m NoUnderlyings) SetEncodedUnderlyingIssuerLen(v int) { + m.Set(field.NewEncodedUnderlyingIssuerLen(v)) +} + +//SetEncodedUnderlyingIssuer sets EncodedUnderlyingIssuer, Tag 363 +func (m NoUnderlyings) SetEncodedUnderlyingIssuer(v string) { + m.Set(field.NewEncodedUnderlyingIssuer(v)) +} + +//SetUnderlyingSecurityDesc sets UnderlyingSecurityDesc, Tag 307 +func (m NoUnderlyings) SetUnderlyingSecurityDesc(v string) { + m.Set(field.NewUnderlyingSecurityDesc(v)) +} + +//SetEncodedUnderlyingSecurityDescLen sets EncodedUnderlyingSecurityDescLen, Tag 364 +func (m NoUnderlyings) SetEncodedUnderlyingSecurityDescLen(v int) { + m.Set(field.NewEncodedUnderlyingSecurityDescLen(v)) +} + +//SetEncodedUnderlyingSecurityDesc sets EncodedUnderlyingSecurityDesc, Tag 365 +func (m NoUnderlyings) SetEncodedUnderlyingSecurityDesc(v string) { + m.Set(field.NewEncodedUnderlyingSecurityDesc(v)) +} + +//SetUnderlyingCPProgram sets UnderlyingCPProgram, Tag 877 +func (m NoUnderlyings) SetUnderlyingCPProgram(v string) { + m.Set(field.NewUnderlyingCPProgram(v)) +} + +//SetUnderlyingCPRegType sets UnderlyingCPRegType, Tag 878 +func (m NoUnderlyings) SetUnderlyingCPRegType(v string) { + m.Set(field.NewUnderlyingCPRegType(v)) +} + +//SetUnderlyingCurrency sets UnderlyingCurrency, Tag 318 +func (m NoUnderlyings) SetUnderlyingCurrency(v string) { + m.Set(field.NewUnderlyingCurrency(v)) +} + +//SetUnderlyingQty sets UnderlyingQty, Tag 879 +func (m NoUnderlyings) SetUnderlyingQty(v float64) { + m.Set(field.NewUnderlyingQty(v)) +} + +//SetUnderlyingPx sets UnderlyingPx, Tag 810 +func (m NoUnderlyings) SetUnderlyingPx(v float64) { + m.Set(field.NewUnderlyingPx(v)) +} + +//SetUnderlyingDirtyPrice sets UnderlyingDirtyPrice, Tag 882 +func (m NoUnderlyings) SetUnderlyingDirtyPrice(v float64) { + m.Set(field.NewUnderlyingDirtyPrice(v)) +} + +//SetUnderlyingEndPrice sets UnderlyingEndPrice, Tag 883 +func (m NoUnderlyings) SetUnderlyingEndPrice(v float64) { + m.Set(field.NewUnderlyingEndPrice(v)) +} + +//SetUnderlyingStartValue sets UnderlyingStartValue, Tag 884 +func (m NoUnderlyings) SetUnderlyingStartValue(v float64) { + m.Set(field.NewUnderlyingStartValue(v)) +} + +//SetUnderlyingCurrentValue sets UnderlyingCurrentValue, Tag 885 +func (m NoUnderlyings) SetUnderlyingCurrentValue(v float64) { + m.Set(field.NewUnderlyingCurrentValue(v)) +} + +//SetUnderlyingEndValue sets UnderlyingEndValue, Tag 886 +func (m NoUnderlyings) SetUnderlyingEndValue(v float64) { + m.Set(field.NewUnderlyingEndValue(v)) +} + +//SetNoUnderlyingStips sets NoUnderlyingStips, Tag 887 +func (m NoUnderlyings) SetNoUnderlyingStips(f NoUnderlyingStipsRepeatingGroup) { + m.SetGroup(f) +} + +//GetUnderlyingSymbol gets UnderlyingSymbol, Tag 311 +func (m NoUnderlyings) GetUnderlyingSymbol() (f field.UnderlyingSymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSymbolSfx gets UnderlyingSymbolSfx, Tag 312 +func (m NoUnderlyings) GetUnderlyingSymbolSfx() (f field.UnderlyingSymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityID gets UnderlyingSecurityID, Tag 309 +func (m NoUnderlyings) GetUnderlyingSecurityID() (f field.UnderlyingSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityIDSource gets UnderlyingSecurityIDSource, Tag 305 +func (m NoUnderlyings) GetUnderlyingSecurityIDSource() (f field.UnderlyingSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyingSecurityAltID gets NoUnderlyingSecurityAltID, Tag 457 +func (m NoUnderlyings) GetNoUnderlyingSecurityAltID() (NoUnderlyingSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetUnderlyingProduct gets UnderlyingProduct, Tag 462 +func (m NoUnderlyings) GetUnderlyingProduct() (f field.UnderlyingProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCFICode gets UnderlyingCFICode, Tag 463 +func (m NoUnderlyings) GetUnderlyingCFICode() (f field.UnderlyingCFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityType gets UnderlyingSecurityType, Tag 310 +func (m NoUnderlyings) GetUnderlyingSecurityType() (f field.UnderlyingSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecuritySubType gets UnderlyingSecuritySubType, Tag 763 +func (m NoUnderlyings) GetUnderlyingSecuritySubType() (f field.UnderlyingSecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingMaturityMonthYear gets UnderlyingMaturityMonthYear, Tag 313 +func (m NoUnderlyings) GetUnderlyingMaturityMonthYear() (f field.UnderlyingMaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingMaturityDate gets UnderlyingMaturityDate, Tag 542 +func (m NoUnderlyings) GetUnderlyingMaturityDate() (f field.UnderlyingMaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCouponPaymentDate gets UnderlyingCouponPaymentDate, Tag 241 +func (m NoUnderlyings) GetUnderlyingCouponPaymentDate() (f field.UnderlyingCouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingIssueDate gets UnderlyingIssueDate, Tag 242 +func (m NoUnderlyings) GetUnderlyingIssueDate() (f field.UnderlyingIssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepoCollateralSecurityType gets UnderlyingRepoCollateralSecurityType, Tag 243 +func (m NoUnderlyings) GetUnderlyingRepoCollateralSecurityType() (f field.UnderlyingRepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepurchaseTerm gets UnderlyingRepurchaseTerm, Tag 244 +func (m NoUnderlyings) GetUnderlyingRepurchaseTerm() (f field.UnderlyingRepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepurchaseRate gets UnderlyingRepurchaseRate, Tag 245 +func (m NoUnderlyings) GetUnderlyingRepurchaseRate() (f field.UnderlyingRepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingFactor gets UnderlyingFactor, Tag 246 +func (m NoUnderlyings) GetUnderlyingFactor() (f field.UnderlyingFactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCreditRating gets UnderlyingCreditRating, Tag 256 +func (m NoUnderlyings) GetUnderlyingCreditRating() (f field.UnderlyingCreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingInstrRegistry gets UnderlyingInstrRegistry, Tag 595 +func (m NoUnderlyings) GetUnderlyingInstrRegistry() (f field.UnderlyingInstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCountryOfIssue gets UnderlyingCountryOfIssue, Tag 592 +func (m NoUnderlyings) GetUnderlyingCountryOfIssue() (f field.UnderlyingCountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStateOrProvinceOfIssue gets UnderlyingStateOrProvinceOfIssue, Tag 593 +func (m NoUnderlyings) GetUnderlyingStateOrProvinceOfIssue() (f field.UnderlyingStateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingLocaleOfIssue gets UnderlyingLocaleOfIssue, Tag 594 +func (m NoUnderlyings) GetUnderlyingLocaleOfIssue() (f field.UnderlyingLocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRedemptionDate gets UnderlyingRedemptionDate, Tag 247 +func (m NoUnderlyings) GetUnderlyingRedemptionDate() (f field.UnderlyingRedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStrikePrice gets UnderlyingStrikePrice, Tag 316 +func (m NoUnderlyings) GetUnderlyingStrikePrice() (f field.UnderlyingStrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStrikeCurrency gets UnderlyingStrikeCurrency, Tag 941 +func (m NoUnderlyings) GetUnderlyingStrikeCurrency() (f field.UnderlyingStrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingOptAttribute gets UnderlyingOptAttribute, Tag 317 +func (m NoUnderlyings) GetUnderlyingOptAttribute() (f field.UnderlyingOptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingContractMultiplier gets UnderlyingContractMultiplier, Tag 436 +func (m NoUnderlyings) GetUnderlyingContractMultiplier() (f field.UnderlyingContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCouponRate gets UnderlyingCouponRate, Tag 435 +func (m NoUnderlyings) GetUnderlyingCouponRate() (f field.UnderlyingCouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityExchange gets UnderlyingSecurityExchange, Tag 308 +func (m NoUnderlyings) GetUnderlyingSecurityExchange() (f field.UnderlyingSecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingIssuer gets UnderlyingIssuer, Tag 306 +func (m NoUnderlyings) GetUnderlyingIssuer() (f field.UnderlyingIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingIssuerLen gets EncodedUnderlyingIssuerLen, Tag 362 +func (m NoUnderlyings) GetEncodedUnderlyingIssuerLen() (f field.EncodedUnderlyingIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingIssuer gets EncodedUnderlyingIssuer, Tag 363 +func (m NoUnderlyings) GetEncodedUnderlyingIssuer() (f field.EncodedUnderlyingIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityDesc gets UnderlyingSecurityDesc, Tag 307 +func (m NoUnderlyings) GetUnderlyingSecurityDesc() (f field.UnderlyingSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingSecurityDescLen gets EncodedUnderlyingSecurityDescLen, Tag 364 +func (m NoUnderlyings) GetEncodedUnderlyingSecurityDescLen() (f field.EncodedUnderlyingSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingSecurityDesc gets EncodedUnderlyingSecurityDesc, Tag 365 +func (m NoUnderlyings) GetEncodedUnderlyingSecurityDesc() (f field.EncodedUnderlyingSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCPProgram gets UnderlyingCPProgram, Tag 877 +func (m NoUnderlyings) GetUnderlyingCPProgram() (f field.UnderlyingCPProgramField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCPRegType gets UnderlyingCPRegType, Tag 878 +func (m NoUnderlyings) GetUnderlyingCPRegType() (f field.UnderlyingCPRegTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCurrency gets UnderlyingCurrency, Tag 318 +func (m NoUnderlyings) GetUnderlyingCurrency() (f field.UnderlyingCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingQty gets UnderlyingQty, Tag 879 +func (m NoUnderlyings) GetUnderlyingQty() (f field.UnderlyingQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingPx gets UnderlyingPx, Tag 810 +func (m NoUnderlyings) GetUnderlyingPx() (f field.UnderlyingPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingDirtyPrice gets UnderlyingDirtyPrice, Tag 882 +func (m NoUnderlyings) GetUnderlyingDirtyPrice() (f field.UnderlyingDirtyPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingEndPrice gets UnderlyingEndPrice, Tag 883 +func (m NoUnderlyings) GetUnderlyingEndPrice() (f field.UnderlyingEndPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStartValue gets UnderlyingStartValue, Tag 884 +func (m NoUnderlyings) GetUnderlyingStartValue() (f field.UnderlyingStartValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCurrentValue gets UnderlyingCurrentValue, Tag 885 +func (m NoUnderlyings) GetUnderlyingCurrentValue() (f field.UnderlyingCurrentValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingEndValue gets UnderlyingEndValue, Tag 886 +func (m NoUnderlyings) GetUnderlyingEndValue() (f field.UnderlyingEndValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyingStips gets NoUnderlyingStips, Tag 887 +func (m NoUnderlyings) GetNoUnderlyingStips() (NoUnderlyingStipsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingStipsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasUnderlyingSymbol returns true if UnderlyingSymbol is present, Tag 311 +func (m NoUnderlyings) HasUnderlyingSymbol() bool { + return m.Has(tag.UnderlyingSymbol) +} + +//HasUnderlyingSymbolSfx returns true if UnderlyingSymbolSfx is present, Tag 312 +func (m NoUnderlyings) HasUnderlyingSymbolSfx() bool { + return m.Has(tag.UnderlyingSymbolSfx) +} + +//HasUnderlyingSecurityID returns true if UnderlyingSecurityID is present, Tag 309 +func (m NoUnderlyings) HasUnderlyingSecurityID() bool { + return m.Has(tag.UnderlyingSecurityID) +} + +//HasUnderlyingSecurityIDSource returns true if UnderlyingSecurityIDSource is present, Tag 305 +func (m NoUnderlyings) HasUnderlyingSecurityIDSource() bool { + return m.Has(tag.UnderlyingSecurityIDSource) +} + +//HasNoUnderlyingSecurityAltID returns true if NoUnderlyingSecurityAltID is present, Tag 457 +func (m NoUnderlyings) HasNoUnderlyingSecurityAltID() bool { + return m.Has(tag.NoUnderlyingSecurityAltID) +} + +//HasUnderlyingProduct returns true if UnderlyingProduct is present, Tag 462 +func (m NoUnderlyings) HasUnderlyingProduct() bool { + return m.Has(tag.UnderlyingProduct) +} + +//HasUnderlyingCFICode returns true if UnderlyingCFICode is present, Tag 463 +func (m NoUnderlyings) HasUnderlyingCFICode() bool { + return m.Has(tag.UnderlyingCFICode) +} + +//HasUnderlyingSecurityType returns true if UnderlyingSecurityType is present, Tag 310 +func (m NoUnderlyings) HasUnderlyingSecurityType() bool { + return m.Has(tag.UnderlyingSecurityType) +} + +//HasUnderlyingSecuritySubType returns true if UnderlyingSecuritySubType is present, Tag 763 +func (m NoUnderlyings) HasUnderlyingSecuritySubType() bool { + return m.Has(tag.UnderlyingSecuritySubType) +} + +//HasUnderlyingMaturityMonthYear returns true if UnderlyingMaturityMonthYear is present, Tag 313 +func (m NoUnderlyings) HasUnderlyingMaturityMonthYear() bool { + return m.Has(tag.UnderlyingMaturityMonthYear) +} + +//HasUnderlyingMaturityDate returns true if UnderlyingMaturityDate is present, Tag 542 +func (m NoUnderlyings) HasUnderlyingMaturityDate() bool { + return m.Has(tag.UnderlyingMaturityDate) +} + +//HasUnderlyingCouponPaymentDate returns true if UnderlyingCouponPaymentDate is present, Tag 241 +func (m NoUnderlyings) HasUnderlyingCouponPaymentDate() bool { + return m.Has(tag.UnderlyingCouponPaymentDate) +} + +//HasUnderlyingIssueDate returns true if UnderlyingIssueDate is present, Tag 242 +func (m NoUnderlyings) HasUnderlyingIssueDate() bool { + return m.Has(tag.UnderlyingIssueDate) +} + +//HasUnderlyingRepoCollateralSecurityType returns true if UnderlyingRepoCollateralSecurityType is present, Tag 243 +func (m NoUnderlyings) HasUnderlyingRepoCollateralSecurityType() bool { + return m.Has(tag.UnderlyingRepoCollateralSecurityType) +} + +//HasUnderlyingRepurchaseTerm returns true if UnderlyingRepurchaseTerm is present, Tag 244 +func (m NoUnderlyings) HasUnderlyingRepurchaseTerm() bool { + return m.Has(tag.UnderlyingRepurchaseTerm) +} + +//HasUnderlyingRepurchaseRate returns true if UnderlyingRepurchaseRate is present, Tag 245 +func (m NoUnderlyings) HasUnderlyingRepurchaseRate() bool { + return m.Has(tag.UnderlyingRepurchaseRate) +} + +//HasUnderlyingFactor returns true if UnderlyingFactor is present, Tag 246 +func (m NoUnderlyings) HasUnderlyingFactor() bool { + return m.Has(tag.UnderlyingFactor) +} + +//HasUnderlyingCreditRating returns true if UnderlyingCreditRating is present, Tag 256 +func (m NoUnderlyings) HasUnderlyingCreditRating() bool { + return m.Has(tag.UnderlyingCreditRating) +} + +//HasUnderlyingInstrRegistry returns true if UnderlyingInstrRegistry is present, Tag 595 +func (m NoUnderlyings) HasUnderlyingInstrRegistry() bool { + return m.Has(tag.UnderlyingInstrRegistry) +} + +//HasUnderlyingCountryOfIssue returns true if UnderlyingCountryOfIssue is present, Tag 592 +func (m NoUnderlyings) HasUnderlyingCountryOfIssue() bool { + return m.Has(tag.UnderlyingCountryOfIssue) +} + +//HasUnderlyingStateOrProvinceOfIssue returns true if UnderlyingStateOrProvinceOfIssue is present, Tag 593 +func (m NoUnderlyings) HasUnderlyingStateOrProvinceOfIssue() bool { + return m.Has(tag.UnderlyingStateOrProvinceOfIssue) +} + +//HasUnderlyingLocaleOfIssue returns true if UnderlyingLocaleOfIssue is present, Tag 594 +func (m NoUnderlyings) HasUnderlyingLocaleOfIssue() bool { + return m.Has(tag.UnderlyingLocaleOfIssue) +} + +//HasUnderlyingRedemptionDate returns true if UnderlyingRedemptionDate is present, Tag 247 +func (m NoUnderlyings) HasUnderlyingRedemptionDate() bool { + return m.Has(tag.UnderlyingRedemptionDate) +} + +//HasUnderlyingStrikePrice returns true if UnderlyingStrikePrice is present, Tag 316 +func (m NoUnderlyings) HasUnderlyingStrikePrice() bool { + return m.Has(tag.UnderlyingStrikePrice) +} + +//HasUnderlyingStrikeCurrency returns true if UnderlyingStrikeCurrency is present, Tag 941 +func (m NoUnderlyings) HasUnderlyingStrikeCurrency() bool { + return m.Has(tag.UnderlyingStrikeCurrency) +} + +//HasUnderlyingOptAttribute returns true if UnderlyingOptAttribute is present, Tag 317 +func (m NoUnderlyings) HasUnderlyingOptAttribute() bool { + return m.Has(tag.UnderlyingOptAttribute) +} + +//HasUnderlyingContractMultiplier returns true if UnderlyingContractMultiplier is present, Tag 436 +func (m NoUnderlyings) HasUnderlyingContractMultiplier() bool { + return m.Has(tag.UnderlyingContractMultiplier) +} + +//HasUnderlyingCouponRate returns true if UnderlyingCouponRate is present, Tag 435 +func (m NoUnderlyings) HasUnderlyingCouponRate() bool { + return m.Has(tag.UnderlyingCouponRate) +} + +//HasUnderlyingSecurityExchange returns true if UnderlyingSecurityExchange is present, Tag 308 +func (m NoUnderlyings) HasUnderlyingSecurityExchange() bool { + return m.Has(tag.UnderlyingSecurityExchange) +} + +//HasUnderlyingIssuer returns true if UnderlyingIssuer is present, Tag 306 +func (m NoUnderlyings) HasUnderlyingIssuer() bool { + return m.Has(tag.UnderlyingIssuer) +} + +//HasEncodedUnderlyingIssuerLen returns true if EncodedUnderlyingIssuerLen is present, Tag 362 +func (m NoUnderlyings) HasEncodedUnderlyingIssuerLen() bool { + return m.Has(tag.EncodedUnderlyingIssuerLen) +} + +//HasEncodedUnderlyingIssuer returns true if EncodedUnderlyingIssuer is present, Tag 363 +func (m NoUnderlyings) HasEncodedUnderlyingIssuer() bool { + return m.Has(tag.EncodedUnderlyingIssuer) +} + +//HasUnderlyingSecurityDesc returns true if UnderlyingSecurityDesc is present, Tag 307 +func (m NoUnderlyings) HasUnderlyingSecurityDesc() bool { + return m.Has(tag.UnderlyingSecurityDesc) +} + +//HasEncodedUnderlyingSecurityDescLen returns true if EncodedUnderlyingSecurityDescLen is present, Tag 364 +func (m NoUnderlyings) HasEncodedUnderlyingSecurityDescLen() bool { + return m.Has(tag.EncodedUnderlyingSecurityDescLen) +} + +//HasEncodedUnderlyingSecurityDesc returns true if EncodedUnderlyingSecurityDesc is present, Tag 365 +func (m NoUnderlyings) HasEncodedUnderlyingSecurityDesc() bool { + return m.Has(tag.EncodedUnderlyingSecurityDesc) +} + +//HasUnderlyingCPProgram returns true if UnderlyingCPProgram is present, Tag 877 +func (m NoUnderlyings) HasUnderlyingCPProgram() bool { + return m.Has(tag.UnderlyingCPProgram) +} + +//HasUnderlyingCPRegType returns true if UnderlyingCPRegType is present, Tag 878 +func (m NoUnderlyings) HasUnderlyingCPRegType() bool { + return m.Has(tag.UnderlyingCPRegType) +} + +//HasUnderlyingCurrency returns true if UnderlyingCurrency is present, Tag 318 +func (m NoUnderlyings) HasUnderlyingCurrency() bool { + return m.Has(tag.UnderlyingCurrency) +} + +//HasUnderlyingQty returns true if UnderlyingQty is present, Tag 879 +func (m NoUnderlyings) HasUnderlyingQty() bool { + return m.Has(tag.UnderlyingQty) +} + +//HasUnderlyingPx returns true if UnderlyingPx is present, Tag 810 +func (m NoUnderlyings) HasUnderlyingPx() bool { + return m.Has(tag.UnderlyingPx) +} + +//HasUnderlyingDirtyPrice returns true if UnderlyingDirtyPrice is present, Tag 882 +func (m NoUnderlyings) HasUnderlyingDirtyPrice() bool { + return m.Has(tag.UnderlyingDirtyPrice) +} + +//HasUnderlyingEndPrice returns true if UnderlyingEndPrice is present, Tag 883 +func (m NoUnderlyings) HasUnderlyingEndPrice() bool { + return m.Has(tag.UnderlyingEndPrice) +} + +//HasUnderlyingStartValue returns true if UnderlyingStartValue is present, Tag 884 +func (m NoUnderlyings) HasUnderlyingStartValue() bool { + return m.Has(tag.UnderlyingStartValue) +} + +//HasUnderlyingCurrentValue returns true if UnderlyingCurrentValue is present, Tag 885 +func (m NoUnderlyings) HasUnderlyingCurrentValue() bool { + return m.Has(tag.UnderlyingCurrentValue) +} + +//HasUnderlyingEndValue returns true if UnderlyingEndValue is present, Tag 886 +func (m NoUnderlyings) HasUnderlyingEndValue() bool { + return m.Has(tag.UnderlyingEndValue) +} + +//HasNoUnderlyingStips returns true if NoUnderlyingStips is present, Tag 887 +func (m NoUnderlyings) HasNoUnderlyingStips() bool { + return m.Has(tag.NoUnderlyingStips) +} + +//NoUnderlyingSecurityAltID is a repeating group element, Tag 457 +type NoUnderlyingSecurityAltID struct { + quickfix.Group +} + +//SetUnderlyingSecurityAltID sets UnderlyingSecurityAltID, Tag 458 +func (m NoUnderlyingSecurityAltID) SetUnderlyingSecurityAltID(v string) { + m.Set(field.NewUnderlyingSecurityAltID(v)) +} + +//SetUnderlyingSecurityAltIDSource sets UnderlyingSecurityAltIDSource, Tag 459 +func (m NoUnderlyingSecurityAltID) SetUnderlyingSecurityAltIDSource(v string) { + m.Set(field.NewUnderlyingSecurityAltIDSource(v)) +} + +//GetUnderlyingSecurityAltID gets UnderlyingSecurityAltID, Tag 458 +func (m NoUnderlyingSecurityAltID) GetUnderlyingSecurityAltID() (f field.UnderlyingSecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityAltIDSource gets UnderlyingSecurityAltIDSource, Tag 459 +func (m NoUnderlyingSecurityAltID) GetUnderlyingSecurityAltIDSource() (f field.UnderlyingSecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingSecurityAltID returns true if UnderlyingSecurityAltID is present, Tag 458 +func (m NoUnderlyingSecurityAltID) HasUnderlyingSecurityAltID() bool { + return m.Has(tag.UnderlyingSecurityAltID) +} + +//HasUnderlyingSecurityAltIDSource returns true if UnderlyingSecurityAltIDSource is present, Tag 459 +func (m NoUnderlyingSecurityAltID) HasUnderlyingSecurityAltIDSource() bool { + return m.Has(tag.UnderlyingSecurityAltIDSource) +} + +//NoUnderlyingSecurityAltIDRepeatingGroup is a repeating group, Tag 457 +type NoUnderlyingSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingSecurityAltIDRepeatingGroup returns an initialized, NoUnderlyingSecurityAltIDRepeatingGroup +func NewNoUnderlyingSecurityAltIDRepeatingGroup() NoUnderlyingSecurityAltIDRepeatingGroup { + return NoUnderlyingSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyingSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingSecurityAltID), quickfix.GroupElement(tag.UnderlyingSecurityAltIDSource)})} +} + +//Add create and append a new NoUnderlyingSecurityAltID to this group +func (m NoUnderlyingSecurityAltIDRepeatingGroup) Add() NoUnderlyingSecurityAltID { + g := m.RepeatingGroup.Add() + return NoUnderlyingSecurityAltID{g} +} + +//Get returns the ith NoUnderlyingSecurityAltID in the NoUnderlyingSecurityAltIDRepeatinGroup +func (m NoUnderlyingSecurityAltIDRepeatingGroup) Get(i int) NoUnderlyingSecurityAltID { + return NoUnderlyingSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyingStips is a repeating group element, Tag 887 +type NoUnderlyingStips struct { + quickfix.Group +} + +//SetUnderlyingStipType sets UnderlyingStipType, Tag 888 +func (m NoUnderlyingStips) SetUnderlyingStipType(v string) { + m.Set(field.NewUnderlyingStipType(v)) +} + +//SetUnderlyingStipValue sets UnderlyingStipValue, Tag 889 +func (m NoUnderlyingStips) SetUnderlyingStipValue(v string) { + m.Set(field.NewUnderlyingStipValue(v)) +} + +//GetUnderlyingStipType gets UnderlyingStipType, Tag 888 +func (m NoUnderlyingStips) GetUnderlyingStipType() (f field.UnderlyingStipTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStipValue gets UnderlyingStipValue, Tag 889 +func (m NoUnderlyingStips) GetUnderlyingStipValue() (f field.UnderlyingStipValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingStipType returns true if UnderlyingStipType is present, Tag 888 +func (m NoUnderlyingStips) HasUnderlyingStipType() bool { + return m.Has(tag.UnderlyingStipType) +} + +//HasUnderlyingStipValue returns true if UnderlyingStipValue is present, Tag 889 +func (m NoUnderlyingStips) HasUnderlyingStipValue() bool { + return m.Has(tag.UnderlyingStipValue) +} + +//NoUnderlyingStipsRepeatingGroup is a repeating group, Tag 887 +type NoUnderlyingStipsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingStipsRepeatingGroup returns an initialized, NoUnderlyingStipsRepeatingGroup +func NewNoUnderlyingStipsRepeatingGroup() NoUnderlyingStipsRepeatingGroup { + return NoUnderlyingStipsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyingStips, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingStipType), quickfix.GroupElement(tag.UnderlyingStipValue)})} +} + +//Add create and append a new NoUnderlyingStips to this group +func (m NoUnderlyingStipsRepeatingGroup) Add() NoUnderlyingStips { + g := m.RepeatingGroup.Add() + return NoUnderlyingStips{g} +} + +//Get returns the ith NoUnderlyingStips in the NoUnderlyingStipsRepeatinGroup +func (m NoUnderlyingStipsRepeatingGroup) Get(i int) NoUnderlyingStips { + return NoUnderlyingStips{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyingsRepeatingGroup is a repeating group, Tag 711 +type NoUnderlyingsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingsRepeatingGroup returns an initialized, NoUnderlyingsRepeatingGroup +func NewNoUnderlyingsRepeatingGroup() NoUnderlyingsRepeatingGroup { + return NoUnderlyingsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyings, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingSymbol), quickfix.GroupElement(tag.UnderlyingSymbolSfx), quickfix.GroupElement(tag.UnderlyingSecurityID), quickfix.GroupElement(tag.UnderlyingSecurityIDSource), NewNoUnderlyingSecurityAltIDRepeatingGroup(), quickfix.GroupElement(tag.UnderlyingProduct), quickfix.GroupElement(tag.UnderlyingCFICode), quickfix.GroupElement(tag.UnderlyingSecurityType), quickfix.GroupElement(tag.UnderlyingSecuritySubType), quickfix.GroupElement(tag.UnderlyingMaturityMonthYear), quickfix.GroupElement(tag.UnderlyingMaturityDate), quickfix.GroupElement(tag.UnderlyingCouponPaymentDate), quickfix.GroupElement(tag.UnderlyingIssueDate), quickfix.GroupElement(tag.UnderlyingRepoCollateralSecurityType), quickfix.GroupElement(tag.UnderlyingRepurchaseTerm), quickfix.GroupElement(tag.UnderlyingRepurchaseRate), quickfix.GroupElement(tag.UnderlyingFactor), quickfix.GroupElement(tag.UnderlyingCreditRating), quickfix.GroupElement(tag.UnderlyingInstrRegistry), quickfix.GroupElement(tag.UnderlyingCountryOfIssue), quickfix.GroupElement(tag.UnderlyingStateOrProvinceOfIssue), quickfix.GroupElement(tag.UnderlyingLocaleOfIssue), quickfix.GroupElement(tag.UnderlyingRedemptionDate), quickfix.GroupElement(tag.UnderlyingStrikePrice), quickfix.GroupElement(tag.UnderlyingStrikeCurrency), quickfix.GroupElement(tag.UnderlyingOptAttribute), quickfix.GroupElement(tag.UnderlyingContractMultiplier), quickfix.GroupElement(tag.UnderlyingCouponRate), quickfix.GroupElement(tag.UnderlyingSecurityExchange), quickfix.GroupElement(tag.UnderlyingIssuer), quickfix.GroupElement(tag.EncodedUnderlyingIssuerLen), quickfix.GroupElement(tag.EncodedUnderlyingIssuer), quickfix.GroupElement(tag.UnderlyingSecurityDesc), quickfix.GroupElement(tag.EncodedUnderlyingSecurityDescLen), quickfix.GroupElement(tag.EncodedUnderlyingSecurityDesc), quickfix.GroupElement(tag.UnderlyingCPProgram), quickfix.GroupElement(tag.UnderlyingCPRegType), quickfix.GroupElement(tag.UnderlyingCurrency), quickfix.GroupElement(tag.UnderlyingQty), quickfix.GroupElement(tag.UnderlyingPx), quickfix.GroupElement(tag.UnderlyingDirtyPrice), quickfix.GroupElement(tag.UnderlyingEndPrice), quickfix.GroupElement(tag.UnderlyingStartValue), quickfix.GroupElement(tag.UnderlyingCurrentValue), quickfix.GroupElement(tag.UnderlyingEndValue), NewNoUnderlyingStipsRepeatingGroup()})} +} + +//Add create and append a new NoUnderlyings to this group +func (m NoUnderlyingsRepeatingGroup) Add() NoUnderlyings { + g := m.RepeatingGroup.Add() + return NoUnderlyings{g} +} + +//Get returns the ith NoUnderlyings in the NoUnderlyingsRepeatinGroup +func (m NoUnderlyingsRepeatingGroup) Get(i int) NoUnderlyings { + return NoUnderlyings{m.RepeatingGroup.Get(i)} +} + +//NoLegs is a repeating group element, Tag 555 +type NoLegs struct { + quickfix.Group +} + +//SetLegSymbol sets LegSymbol, Tag 600 +func (m NoLegs) SetLegSymbol(v string) { + m.Set(field.NewLegSymbol(v)) +} + +//SetLegSymbolSfx sets LegSymbolSfx, Tag 601 +func (m NoLegs) SetLegSymbolSfx(v string) { + m.Set(field.NewLegSymbolSfx(v)) +} + +//SetLegSecurityID sets LegSecurityID, Tag 602 +func (m NoLegs) SetLegSecurityID(v string) { + m.Set(field.NewLegSecurityID(v)) +} + +//SetLegSecurityIDSource sets LegSecurityIDSource, Tag 603 +func (m NoLegs) SetLegSecurityIDSource(v string) { + m.Set(field.NewLegSecurityIDSource(v)) +} + +//SetNoLegSecurityAltID sets NoLegSecurityAltID, Tag 604 +func (m NoLegs) SetNoLegSecurityAltID(f NoLegSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetLegProduct sets LegProduct, Tag 607 +func (m NoLegs) SetLegProduct(v int) { + m.Set(field.NewLegProduct(v)) +} + +//SetLegCFICode sets LegCFICode, Tag 608 +func (m NoLegs) SetLegCFICode(v string) { + m.Set(field.NewLegCFICode(v)) +} + +//SetLegSecurityType sets LegSecurityType, Tag 609 +func (m NoLegs) SetLegSecurityType(v string) { + m.Set(field.NewLegSecurityType(v)) +} + +//SetLegSecuritySubType sets LegSecuritySubType, Tag 764 +func (m NoLegs) SetLegSecuritySubType(v string) { + m.Set(field.NewLegSecuritySubType(v)) +} + +//SetLegMaturityMonthYear sets LegMaturityMonthYear, Tag 610 +func (m NoLegs) SetLegMaturityMonthYear(v string) { + m.Set(field.NewLegMaturityMonthYear(v)) +} + +//SetLegMaturityDate sets LegMaturityDate, Tag 611 +func (m NoLegs) SetLegMaturityDate(v string) { + m.Set(field.NewLegMaturityDate(v)) +} + +//SetLegCouponPaymentDate sets LegCouponPaymentDate, Tag 248 +func (m NoLegs) SetLegCouponPaymentDate(v string) { + m.Set(field.NewLegCouponPaymentDate(v)) +} + +//SetLegIssueDate sets LegIssueDate, Tag 249 +func (m NoLegs) SetLegIssueDate(v string) { + m.Set(field.NewLegIssueDate(v)) +} + +//SetLegRepoCollateralSecurityType sets LegRepoCollateralSecurityType, Tag 250 +func (m NoLegs) SetLegRepoCollateralSecurityType(v int) { + m.Set(field.NewLegRepoCollateralSecurityType(v)) +} + +//SetLegRepurchaseTerm sets LegRepurchaseTerm, Tag 251 +func (m NoLegs) SetLegRepurchaseTerm(v int) { + m.Set(field.NewLegRepurchaseTerm(v)) +} + +//SetLegRepurchaseRate sets LegRepurchaseRate, Tag 252 +func (m NoLegs) SetLegRepurchaseRate(v float64) { + m.Set(field.NewLegRepurchaseRate(v)) +} + +//SetLegFactor sets LegFactor, Tag 253 +func (m NoLegs) SetLegFactor(v float64) { + m.Set(field.NewLegFactor(v)) +} + +//SetLegCreditRating sets LegCreditRating, Tag 257 +func (m NoLegs) SetLegCreditRating(v string) { + m.Set(field.NewLegCreditRating(v)) +} + +//SetLegInstrRegistry sets LegInstrRegistry, Tag 599 +func (m NoLegs) SetLegInstrRegistry(v string) { + m.Set(field.NewLegInstrRegistry(v)) +} + +//SetLegCountryOfIssue sets LegCountryOfIssue, Tag 596 +func (m NoLegs) SetLegCountryOfIssue(v string) { + m.Set(field.NewLegCountryOfIssue(v)) +} + +//SetLegStateOrProvinceOfIssue sets LegStateOrProvinceOfIssue, Tag 597 +func (m NoLegs) SetLegStateOrProvinceOfIssue(v string) { + m.Set(field.NewLegStateOrProvinceOfIssue(v)) +} + +//SetLegLocaleOfIssue sets LegLocaleOfIssue, Tag 598 +func (m NoLegs) SetLegLocaleOfIssue(v string) { + m.Set(field.NewLegLocaleOfIssue(v)) +} + +//SetLegRedemptionDate sets LegRedemptionDate, Tag 254 +func (m NoLegs) SetLegRedemptionDate(v string) { + m.Set(field.NewLegRedemptionDate(v)) +} + +//SetLegStrikePrice sets LegStrikePrice, Tag 612 +func (m NoLegs) SetLegStrikePrice(v float64) { + m.Set(field.NewLegStrikePrice(v)) +} + +//SetLegStrikeCurrency sets LegStrikeCurrency, Tag 942 +func (m NoLegs) SetLegStrikeCurrency(v string) { + m.Set(field.NewLegStrikeCurrency(v)) +} + +//SetLegOptAttribute sets LegOptAttribute, Tag 613 +func (m NoLegs) SetLegOptAttribute(v string) { + m.Set(field.NewLegOptAttribute(v)) +} + +//SetLegContractMultiplier sets LegContractMultiplier, Tag 614 +func (m NoLegs) SetLegContractMultiplier(v float64) { + m.Set(field.NewLegContractMultiplier(v)) +} + +//SetLegCouponRate sets LegCouponRate, Tag 615 +func (m NoLegs) SetLegCouponRate(v float64) { + m.Set(field.NewLegCouponRate(v)) +} + +//SetLegSecurityExchange sets LegSecurityExchange, Tag 616 +func (m NoLegs) SetLegSecurityExchange(v string) { + m.Set(field.NewLegSecurityExchange(v)) +} + +//SetLegIssuer sets LegIssuer, Tag 617 +func (m NoLegs) SetLegIssuer(v string) { + m.Set(field.NewLegIssuer(v)) +} + +//SetEncodedLegIssuerLen sets EncodedLegIssuerLen, Tag 618 +func (m NoLegs) SetEncodedLegIssuerLen(v int) { + m.Set(field.NewEncodedLegIssuerLen(v)) +} + +//SetEncodedLegIssuer sets EncodedLegIssuer, Tag 619 +func (m NoLegs) SetEncodedLegIssuer(v string) { + m.Set(field.NewEncodedLegIssuer(v)) +} + +//SetLegSecurityDesc sets LegSecurityDesc, Tag 620 +func (m NoLegs) SetLegSecurityDesc(v string) { + m.Set(field.NewLegSecurityDesc(v)) +} + +//SetEncodedLegSecurityDescLen sets EncodedLegSecurityDescLen, Tag 621 +func (m NoLegs) SetEncodedLegSecurityDescLen(v int) { + m.Set(field.NewEncodedLegSecurityDescLen(v)) +} + +//SetEncodedLegSecurityDesc sets EncodedLegSecurityDesc, Tag 622 +func (m NoLegs) SetEncodedLegSecurityDesc(v string) { + m.Set(field.NewEncodedLegSecurityDesc(v)) +} + +//SetLegRatioQty sets LegRatioQty, Tag 623 +func (m NoLegs) SetLegRatioQty(v float64) { + m.Set(field.NewLegRatioQty(v)) +} + +//SetLegSide sets LegSide, Tag 624 +func (m NoLegs) SetLegSide(v string) { + m.Set(field.NewLegSide(v)) +} + +//SetLegCurrency sets LegCurrency, Tag 556 +func (m NoLegs) SetLegCurrency(v string) { + m.Set(field.NewLegCurrency(v)) +} + +//SetLegPool sets LegPool, Tag 740 +func (m NoLegs) SetLegPool(v string) { + m.Set(field.NewLegPool(v)) +} + +//SetLegDatedDate sets LegDatedDate, Tag 739 +func (m NoLegs) SetLegDatedDate(v string) { + m.Set(field.NewLegDatedDate(v)) +} + +//SetLegContractSettlMonth sets LegContractSettlMonth, Tag 955 +func (m NoLegs) SetLegContractSettlMonth(v string) { + m.Set(field.NewLegContractSettlMonth(v)) +} + +//SetLegInterestAccrualDate sets LegInterestAccrualDate, Tag 956 +func (m NoLegs) SetLegInterestAccrualDate(v string) { + m.Set(field.NewLegInterestAccrualDate(v)) +} + +//GetLegSymbol gets LegSymbol, Tag 600 +func (m NoLegs) GetLegSymbol() (f field.LegSymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSymbolSfx gets LegSymbolSfx, Tag 601 +func (m NoLegs) GetLegSymbolSfx() (f field.LegSymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityID gets LegSecurityID, Tag 602 +func (m NoLegs) GetLegSecurityID() (f field.LegSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityIDSource gets LegSecurityIDSource, Tag 603 +func (m NoLegs) GetLegSecurityIDSource() (f field.LegSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoLegSecurityAltID gets NoLegSecurityAltID, Tag 604 +func (m NoLegs) GetNoLegSecurityAltID() (NoLegSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoLegSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetLegProduct gets LegProduct, Tag 607 +func (m NoLegs) GetLegProduct() (f field.LegProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCFICode gets LegCFICode, Tag 608 +func (m NoLegs) GetLegCFICode() (f field.LegCFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityType gets LegSecurityType, Tag 609 +func (m NoLegs) GetLegSecurityType() (f field.LegSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecuritySubType gets LegSecuritySubType, Tag 764 +func (m NoLegs) GetLegSecuritySubType() (f field.LegSecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegMaturityMonthYear gets LegMaturityMonthYear, Tag 610 +func (m NoLegs) GetLegMaturityMonthYear() (f field.LegMaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegMaturityDate gets LegMaturityDate, Tag 611 +func (m NoLegs) GetLegMaturityDate() (f field.LegMaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCouponPaymentDate gets LegCouponPaymentDate, Tag 248 +func (m NoLegs) GetLegCouponPaymentDate() (f field.LegCouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegIssueDate gets LegIssueDate, Tag 249 +func (m NoLegs) GetLegIssueDate() (f field.LegIssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRepoCollateralSecurityType gets LegRepoCollateralSecurityType, Tag 250 +func (m NoLegs) GetLegRepoCollateralSecurityType() (f field.LegRepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRepurchaseTerm gets LegRepurchaseTerm, Tag 251 +func (m NoLegs) GetLegRepurchaseTerm() (f field.LegRepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRepurchaseRate gets LegRepurchaseRate, Tag 252 +func (m NoLegs) GetLegRepurchaseRate() (f field.LegRepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegFactor gets LegFactor, Tag 253 +func (m NoLegs) GetLegFactor() (f field.LegFactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCreditRating gets LegCreditRating, Tag 257 +func (m NoLegs) GetLegCreditRating() (f field.LegCreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegInstrRegistry gets LegInstrRegistry, Tag 599 +func (m NoLegs) GetLegInstrRegistry() (f field.LegInstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCountryOfIssue gets LegCountryOfIssue, Tag 596 +func (m NoLegs) GetLegCountryOfIssue() (f field.LegCountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegStateOrProvinceOfIssue gets LegStateOrProvinceOfIssue, Tag 597 +func (m NoLegs) GetLegStateOrProvinceOfIssue() (f field.LegStateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegLocaleOfIssue gets LegLocaleOfIssue, Tag 598 +func (m NoLegs) GetLegLocaleOfIssue() (f field.LegLocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRedemptionDate gets LegRedemptionDate, Tag 254 +func (m NoLegs) GetLegRedemptionDate() (f field.LegRedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegStrikePrice gets LegStrikePrice, Tag 612 +func (m NoLegs) GetLegStrikePrice() (f field.LegStrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegStrikeCurrency gets LegStrikeCurrency, Tag 942 +func (m NoLegs) GetLegStrikeCurrency() (f field.LegStrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegOptAttribute gets LegOptAttribute, Tag 613 +func (m NoLegs) GetLegOptAttribute() (f field.LegOptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegContractMultiplier gets LegContractMultiplier, Tag 614 +func (m NoLegs) GetLegContractMultiplier() (f field.LegContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCouponRate gets LegCouponRate, Tag 615 +func (m NoLegs) GetLegCouponRate() (f field.LegCouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityExchange gets LegSecurityExchange, Tag 616 +func (m NoLegs) GetLegSecurityExchange() (f field.LegSecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegIssuer gets LegIssuer, Tag 617 +func (m NoLegs) GetLegIssuer() (f field.LegIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegIssuerLen gets EncodedLegIssuerLen, Tag 618 +func (m NoLegs) GetEncodedLegIssuerLen() (f field.EncodedLegIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegIssuer gets EncodedLegIssuer, Tag 619 +func (m NoLegs) GetEncodedLegIssuer() (f field.EncodedLegIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityDesc gets LegSecurityDesc, Tag 620 +func (m NoLegs) GetLegSecurityDesc() (f field.LegSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegSecurityDescLen gets EncodedLegSecurityDescLen, Tag 621 +func (m NoLegs) GetEncodedLegSecurityDescLen() (f field.EncodedLegSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegSecurityDesc gets EncodedLegSecurityDesc, Tag 622 +func (m NoLegs) GetEncodedLegSecurityDesc() (f field.EncodedLegSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRatioQty gets LegRatioQty, Tag 623 +func (m NoLegs) GetLegRatioQty() (f field.LegRatioQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSide gets LegSide, Tag 624 +func (m NoLegs) GetLegSide() (f field.LegSideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCurrency gets LegCurrency, Tag 556 +func (m NoLegs) GetLegCurrency() (f field.LegCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegPool gets LegPool, Tag 740 +func (m NoLegs) GetLegPool() (f field.LegPoolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegDatedDate gets LegDatedDate, Tag 739 +func (m NoLegs) GetLegDatedDate() (f field.LegDatedDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegContractSettlMonth gets LegContractSettlMonth, Tag 955 +func (m NoLegs) GetLegContractSettlMonth() (f field.LegContractSettlMonthField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegInterestAccrualDate gets LegInterestAccrualDate, Tag 956 +func (m NoLegs) GetLegInterestAccrualDate() (f field.LegInterestAccrualDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasLegSymbol returns true if LegSymbol is present, Tag 600 +func (m NoLegs) HasLegSymbol() bool { + return m.Has(tag.LegSymbol) +} + +//HasLegSymbolSfx returns true if LegSymbolSfx is present, Tag 601 +func (m NoLegs) HasLegSymbolSfx() bool { + return m.Has(tag.LegSymbolSfx) +} + +//HasLegSecurityID returns true if LegSecurityID is present, Tag 602 +func (m NoLegs) HasLegSecurityID() bool { + return m.Has(tag.LegSecurityID) +} + +//HasLegSecurityIDSource returns true if LegSecurityIDSource is present, Tag 603 +func (m NoLegs) HasLegSecurityIDSource() bool { + return m.Has(tag.LegSecurityIDSource) +} + +//HasNoLegSecurityAltID returns true if NoLegSecurityAltID is present, Tag 604 +func (m NoLegs) HasNoLegSecurityAltID() bool { + return m.Has(tag.NoLegSecurityAltID) +} + +//HasLegProduct returns true if LegProduct is present, Tag 607 +func (m NoLegs) HasLegProduct() bool { + return m.Has(tag.LegProduct) +} + +//HasLegCFICode returns true if LegCFICode is present, Tag 608 +func (m NoLegs) HasLegCFICode() bool { + return m.Has(tag.LegCFICode) +} + +//HasLegSecurityType returns true if LegSecurityType is present, Tag 609 +func (m NoLegs) HasLegSecurityType() bool { + return m.Has(tag.LegSecurityType) +} + +//HasLegSecuritySubType returns true if LegSecuritySubType is present, Tag 764 +func (m NoLegs) HasLegSecuritySubType() bool { + return m.Has(tag.LegSecuritySubType) +} + +//HasLegMaturityMonthYear returns true if LegMaturityMonthYear is present, Tag 610 +func (m NoLegs) HasLegMaturityMonthYear() bool { + return m.Has(tag.LegMaturityMonthYear) +} + +//HasLegMaturityDate returns true if LegMaturityDate is present, Tag 611 +func (m NoLegs) HasLegMaturityDate() bool { + return m.Has(tag.LegMaturityDate) +} + +//HasLegCouponPaymentDate returns true if LegCouponPaymentDate is present, Tag 248 +func (m NoLegs) HasLegCouponPaymentDate() bool { + return m.Has(tag.LegCouponPaymentDate) +} + +//HasLegIssueDate returns true if LegIssueDate is present, Tag 249 +func (m NoLegs) HasLegIssueDate() bool { + return m.Has(tag.LegIssueDate) +} + +//HasLegRepoCollateralSecurityType returns true if LegRepoCollateralSecurityType is present, Tag 250 +func (m NoLegs) HasLegRepoCollateralSecurityType() bool { + return m.Has(tag.LegRepoCollateralSecurityType) +} + +//HasLegRepurchaseTerm returns true if LegRepurchaseTerm is present, Tag 251 +func (m NoLegs) HasLegRepurchaseTerm() bool { + return m.Has(tag.LegRepurchaseTerm) +} + +//HasLegRepurchaseRate returns true if LegRepurchaseRate is present, Tag 252 +func (m NoLegs) HasLegRepurchaseRate() bool { + return m.Has(tag.LegRepurchaseRate) +} + +//HasLegFactor returns true if LegFactor is present, Tag 253 +func (m NoLegs) HasLegFactor() bool { + return m.Has(tag.LegFactor) +} + +//HasLegCreditRating returns true if LegCreditRating is present, Tag 257 +func (m NoLegs) HasLegCreditRating() bool { + return m.Has(tag.LegCreditRating) +} + +//HasLegInstrRegistry returns true if LegInstrRegistry is present, Tag 599 +func (m NoLegs) HasLegInstrRegistry() bool { + return m.Has(tag.LegInstrRegistry) +} + +//HasLegCountryOfIssue returns true if LegCountryOfIssue is present, Tag 596 +func (m NoLegs) HasLegCountryOfIssue() bool { + return m.Has(tag.LegCountryOfIssue) +} + +//HasLegStateOrProvinceOfIssue returns true if LegStateOrProvinceOfIssue is present, Tag 597 +func (m NoLegs) HasLegStateOrProvinceOfIssue() bool { + return m.Has(tag.LegStateOrProvinceOfIssue) +} + +//HasLegLocaleOfIssue returns true if LegLocaleOfIssue is present, Tag 598 +func (m NoLegs) HasLegLocaleOfIssue() bool { + return m.Has(tag.LegLocaleOfIssue) +} + +//HasLegRedemptionDate returns true if LegRedemptionDate is present, Tag 254 +func (m NoLegs) HasLegRedemptionDate() bool { + return m.Has(tag.LegRedemptionDate) +} + +//HasLegStrikePrice returns true if LegStrikePrice is present, Tag 612 +func (m NoLegs) HasLegStrikePrice() bool { + return m.Has(tag.LegStrikePrice) +} + +//HasLegStrikeCurrency returns true if LegStrikeCurrency is present, Tag 942 +func (m NoLegs) HasLegStrikeCurrency() bool { + return m.Has(tag.LegStrikeCurrency) +} + +//HasLegOptAttribute returns true if LegOptAttribute is present, Tag 613 +func (m NoLegs) HasLegOptAttribute() bool { + return m.Has(tag.LegOptAttribute) +} + +//HasLegContractMultiplier returns true if LegContractMultiplier is present, Tag 614 +func (m NoLegs) HasLegContractMultiplier() bool { + return m.Has(tag.LegContractMultiplier) +} + +//HasLegCouponRate returns true if LegCouponRate is present, Tag 615 +func (m NoLegs) HasLegCouponRate() bool { + return m.Has(tag.LegCouponRate) +} + +//HasLegSecurityExchange returns true if LegSecurityExchange is present, Tag 616 +func (m NoLegs) HasLegSecurityExchange() bool { + return m.Has(tag.LegSecurityExchange) +} + +//HasLegIssuer returns true if LegIssuer is present, Tag 617 +func (m NoLegs) HasLegIssuer() bool { + return m.Has(tag.LegIssuer) +} + +//HasEncodedLegIssuerLen returns true if EncodedLegIssuerLen is present, Tag 618 +func (m NoLegs) HasEncodedLegIssuerLen() bool { + return m.Has(tag.EncodedLegIssuerLen) +} + +//HasEncodedLegIssuer returns true if EncodedLegIssuer is present, Tag 619 +func (m NoLegs) HasEncodedLegIssuer() bool { + return m.Has(tag.EncodedLegIssuer) +} + +//HasLegSecurityDesc returns true if LegSecurityDesc is present, Tag 620 +func (m NoLegs) HasLegSecurityDesc() bool { + return m.Has(tag.LegSecurityDesc) +} + +//HasEncodedLegSecurityDescLen returns true if EncodedLegSecurityDescLen is present, Tag 621 +func (m NoLegs) HasEncodedLegSecurityDescLen() bool { + return m.Has(tag.EncodedLegSecurityDescLen) +} + +//HasEncodedLegSecurityDesc returns true if EncodedLegSecurityDesc is present, Tag 622 +func (m NoLegs) HasEncodedLegSecurityDesc() bool { + return m.Has(tag.EncodedLegSecurityDesc) +} + +//HasLegRatioQty returns true if LegRatioQty is present, Tag 623 +func (m NoLegs) HasLegRatioQty() bool { + return m.Has(tag.LegRatioQty) +} + +//HasLegSide returns true if LegSide is present, Tag 624 +func (m NoLegs) HasLegSide() bool { + return m.Has(tag.LegSide) +} + +//HasLegCurrency returns true if LegCurrency is present, Tag 556 +func (m NoLegs) HasLegCurrency() bool { + return m.Has(tag.LegCurrency) +} + +//HasLegPool returns true if LegPool is present, Tag 740 +func (m NoLegs) HasLegPool() bool { + return m.Has(tag.LegPool) +} + +//HasLegDatedDate returns true if LegDatedDate is present, Tag 739 +func (m NoLegs) HasLegDatedDate() bool { + return m.Has(tag.LegDatedDate) +} + +//HasLegContractSettlMonth returns true if LegContractSettlMonth is present, Tag 955 +func (m NoLegs) HasLegContractSettlMonth() bool { + return m.Has(tag.LegContractSettlMonth) +} + +//HasLegInterestAccrualDate returns true if LegInterestAccrualDate is present, Tag 956 +func (m NoLegs) HasLegInterestAccrualDate() bool { + return m.Has(tag.LegInterestAccrualDate) +} + +//NoLegSecurityAltID is a repeating group element, Tag 604 +type NoLegSecurityAltID struct { + quickfix.Group +} + +//SetLegSecurityAltID sets LegSecurityAltID, Tag 605 +func (m NoLegSecurityAltID) SetLegSecurityAltID(v string) { + m.Set(field.NewLegSecurityAltID(v)) +} + +//SetLegSecurityAltIDSource sets LegSecurityAltIDSource, Tag 606 +func (m NoLegSecurityAltID) SetLegSecurityAltIDSource(v string) { + m.Set(field.NewLegSecurityAltIDSource(v)) +} + +//GetLegSecurityAltID gets LegSecurityAltID, Tag 605 +func (m NoLegSecurityAltID) GetLegSecurityAltID() (f field.LegSecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityAltIDSource gets LegSecurityAltIDSource, Tag 606 +func (m NoLegSecurityAltID) GetLegSecurityAltIDSource() (f field.LegSecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasLegSecurityAltID returns true if LegSecurityAltID is present, Tag 605 +func (m NoLegSecurityAltID) HasLegSecurityAltID() bool { + return m.Has(tag.LegSecurityAltID) +} + +//HasLegSecurityAltIDSource returns true if LegSecurityAltIDSource is present, Tag 606 +func (m NoLegSecurityAltID) HasLegSecurityAltIDSource() bool { + return m.Has(tag.LegSecurityAltIDSource) +} + +//NoLegSecurityAltIDRepeatingGroup is a repeating group, Tag 604 +type NoLegSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoLegSecurityAltIDRepeatingGroup returns an initialized, NoLegSecurityAltIDRepeatingGroup +func NewNoLegSecurityAltIDRepeatingGroup() NoLegSecurityAltIDRepeatingGroup { + return NoLegSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoLegSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.LegSecurityAltID), quickfix.GroupElement(tag.LegSecurityAltIDSource)})} +} + +//Add create and append a new NoLegSecurityAltID to this group +func (m NoLegSecurityAltIDRepeatingGroup) Add() NoLegSecurityAltID { + g := m.RepeatingGroup.Add() + return NoLegSecurityAltID{g} +} + +//Get returns the ith NoLegSecurityAltID in the NoLegSecurityAltIDRepeatinGroup +func (m NoLegSecurityAltIDRepeatingGroup) Get(i int) NoLegSecurityAltID { + return NoLegSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoLegsRepeatingGroup is a repeating group, Tag 555 +type NoLegsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoLegsRepeatingGroup returns an initialized, NoLegsRepeatingGroup +func NewNoLegsRepeatingGroup() NoLegsRepeatingGroup { + return NoLegsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoLegs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.LegSymbol), quickfix.GroupElement(tag.LegSymbolSfx), quickfix.GroupElement(tag.LegSecurityID), quickfix.GroupElement(tag.LegSecurityIDSource), NewNoLegSecurityAltIDRepeatingGroup(), quickfix.GroupElement(tag.LegProduct), quickfix.GroupElement(tag.LegCFICode), quickfix.GroupElement(tag.LegSecurityType), quickfix.GroupElement(tag.LegSecuritySubType), quickfix.GroupElement(tag.LegMaturityMonthYear), quickfix.GroupElement(tag.LegMaturityDate), quickfix.GroupElement(tag.LegCouponPaymentDate), quickfix.GroupElement(tag.LegIssueDate), quickfix.GroupElement(tag.LegRepoCollateralSecurityType), quickfix.GroupElement(tag.LegRepurchaseTerm), quickfix.GroupElement(tag.LegRepurchaseRate), quickfix.GroupElement(tag.LegFactor), quickfix.GroupElement(tag.LegCreditRating), quickfix.GroupElement(tag.LegInstrRegistry), quickfix.GroupElement(tag.LegCountryOfIssue), quickfix.GroupElement(tag.LegStateOrProvinceOfIssue), quickfix.GroupElement(tag.LegLocaleOfIssue), quickfix.GroupElement(tag.LegRedemptionDate), quickfix.GroupElement(tag.LegStrikePrice), quickfix.GroupElement(tag.LegStrikeCurrency), quickfix.GroupElement(tag.LegOptAttribute), quickfix.GroupElement(tag.LegContractMultiplier), quickfix.GroupElement(tag.LegCouponRate), quickfix.GroupElement(tag.LegSecurityExchange), quickfix.GroupElement(tag.LegIssuer), quickfix.GroupElement(tag.EncodedLegIssuerLen), quickfix.GroupElement(tag.EncodedLegIssuer), quickfix.GroupElement(tag.LegSecurityDesc), quickfix.GroupElement(tag.EncodedLegSecurityDescLen), quickfix.GroupElement(tag.EncodedLegSecurityDesc), quickfix.GroupElement(tag.LegRatioQty), quickfix.GroupElement(tag.LegSide), quickfix.GroupElement(tag.LegCurrency), quickfix.GroupElement(tag.LegPool), quickfix.GroupElement(tag.LegDatedDate), quickfix.GroupElement(tag.LegContractSettlMonth), quickfix.GroupElement(tag.LegInterestAccrualDate)})} +} + +//Add create and append a new NoLegs to this group +func (m NoLegsRepeatingGroup) Add() NoLegs { + g := m.RepeatingGroup.Add() + return NoLegs{g} +} + +//Get returns the ith NoLegs in the NoLegsRepeatinGroup +func (m NoLegsRepeatingGroup) Get(i int) NoLegs { + return NoLegs{m.RepeatingGroup.Get(i)} +} + +//NoTradingSessions is a repeating group element, Tag 386 +type NoTradingSessions struct { + quickfix.Group +} + +//SetTradingSessionID sets TradingSessionID, Tag 336 +func (m NoTradingSessions) SetTradingSessionID(v string) { + m.Set(field.NewTradingSessionID(v)) +} + +//SetTradingSessionSubID sets TradingSessionSubID, Tag 625 +func (m NoTradingSessions) SetTradingSessionSubID(v string) { + m.Set(field.NewTradingSessionSubID(v)) +} + +//GetTradingSessionID gets TradingSessionID, Tag 336 +func (m NoTradingSessions) GetTradingSessionID() (f field.TradingSessionIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradingSessionSubID gets TradingSessionSubID, Tag 625 +func (m NoTradingSessions) GetTradingSessionSubID() (f field.TradingSessionSubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasTradingSessionID returns true if TradingSessionID is present, Tag 336 +func (m NoTradingSessions) HasTradingSessionID() bool { + return m.Has(tag.TradingSessionID) +} + +//HasTradingSessionSubID returns true if TradingSessionSubID is present, Tag 625 +func (m NoTradingSessions) HasTradingSessionSubID() bool { + return m.Has(tag.TradingSessionSubID) +} + +//NoTradingSessionsRepeatingGroup is a repeating group, Tag 386 +type NoTradingSessionsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoTradingSessionsRepeatingGroup returns an initialized, NoTradingSessionsRepeatingGroup +func NewNoTradingSessionsRepeatingGroup() NoTradingSessionsRepeatingGroup { + return NoTradingSessionsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoTradingSessions, + quickfix.GroupTemplate{quickfix.GroupElement(tag.TradingSessionID), quickfix.GroupElement(tag.TradingSessionSubID)})} +} + +//Add create and append a new NoTradingSessions to this group +func (m NoTradingSessionsRepeatingGroup) Add() NoTradingSessions { + g := m.RepeatingGroup.Add() + return NoTradingSessions{g} +} + +//Get returns the ith NoTradingSessions in the NoTradingSessionsRepeatinGroup +func (m NoTradingSessionsRepeatingGroup) Get(i int) NoTradingSessions { + return NoTradingSessions{m.RepeatingGroup.Get(i)} +} + +//NoRelatedSymRepeatingGroup is a repeating group, Tag 146 +type NoRelatedSymRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoRelatedSymRepeatingGroup returns an initialized, NoRelatedSymRepeatingGroup +func NewNoRelatedSymRepeatingGroup() NoRelatedSymRepeatingGroup { + return NoRelatedSymRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoRelatedSym, + quickfix.GroupTemplate{quickfix.GroupElement(tag.Symbol), quickfix.GroupElement(tag.SymbolSfx), quickfix.GroupElement(tag.SecurityID), quickfix.GroupElement(tag.SecurityIDSource), NewNoSecurityAltIDRepeatingGroup(), quickfix.GroupElement(tag.Product), quickfix.GroupElement(tag.CFICode), quickfix.GroupElement(tag.SecurityType), quickfix.GroupElement(tag.SecuritySubType), quickfix.GroupElement(tag.MaturityMonthYear), quickfix.GroupElement(tag.MaturityDate), quickfix.GroupElement(tag.CouponPaymentDate), quickfix.GroupElement(tag.IssueDate), quickfix.GroupElement(tag.RepoCollateralSecurityType), quickfix.GroupElement(tag.RepurchaseTerm), quickfix.GroupElement(tag.RepurchaseRate), quickfix.GroupElement(tag.Factor), quickfix.GroupElement(tag.CreditRating), quickfix.GroupElement(tag.InstrRegistry), quickfix.GroupElement(tag.CountryOfIssue), quickfix.GroupElement(tag.StateOrProvinceOfIssue), quickfix.GroupElement(tag.LocaleOfIssue), quickfix.GroupElement(tag.RedemptionDate), quickfix.GroupElement(tag.StrikePrice), quickfix.GroupElement(tag.StrikeCurrency), quickfix.GroupElement(tag.OptAttribute), quickfix.GroupElement(tag.ContractMultiplier), quickfix.GroupElement(tag.CouponRate), quickfix.GroupElement(tag.SecurityExchange), quickfix.GroupElement(tag.Issuer), quickfix.GroupElement(tag.EncodedIssuerLen), quickfix.GroupElement(tag.EncodedIssuer), quickfix.GroupElement(tag.SecurityDesc), quickfix.GroupElement(tag.EncodedSecurityDescLen), quickfix.GroupElement(tag.EncodedSecurityDesc), quickfix.GroupElement(tag.Pool), quickfix.GroupElement(tag.ContractSettlMonth), quickfix.GroupElement(tag.CPProgram), quickfix.GroupElement(tag.CPRegType), NewNoEventsRepeatingGroup(), quickfix.GroupElement(tag.DatedDate), quickfix.GroupElement(tag.InterestAccrualDate), NewNoUnderlyingsRepeatingGroup(), NewNoLegsRepeatingGroup(), NewNoTradingSessionsRepeatingGroup(), quickfix.GroupElement(tag.ApplQueueAction), quickfix.GroupElement(tag.ApplQueueMax)})} +} + +//Add create and append a new NoRelatedSym to this group +func (m NoRelatedSymRepeatingGroup) Add() NoRelatedSym { + g := m.RepeatingGroup.Add() + return NoRelatedSym{g} +} + +//Get returns the ith NoRelatedSym in the NoRelatedSymRepeatinGroup +func (m NoRelatedSymRepeatingGroup) Get(i int) NoRelatedSym { + return NoRelatedSym{m.RepeatingGroup.Get(i)} +} + +//NoMDEntryTypes is a repeating group element, Tag 267 +type NoMDEntryTypes struct { + quickfix.Group +} + +//SetMDEntryType sets MDEntryType, Tag 269 +func (m NoMDEntryTypes) SetMDEntryType(v string) { + m.Set(field.NewMDEntryType(v)) +} + +//GetMDEntryType gets MDEntryType, Tag 269 +func (m NoMDEntryTypes) GetMDEntryType() (f field.MDEntryTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasMDEntryType returns true if MDEntryType is present, Tag 269 +func (m NoMDEntryTypes) HasMDEntryType() bool { + return m.Has(tag.MDEntryType) +} + +//NoMDEntryTypesRepeatingGroup is a repeating group, Tag 267 +type NoMDEntryTypesRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoMDEntryTypesRepeatingGroup returns an initialized, NoMDEntryTypesRepeatingGroup +func NewNoMDEntryTypesRepeatingGroup() NoMDEntryTypesRepeatingGroup { + return NoMDEntryTypesRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoMDEntryTypes, + quickfix.GroupTemplate{quickfix.GroupElement(tag.MDEntryType)})} +} + +//Add create and append a new NoMDEntryTypes to this group +func (m NoMDEntryTypesRepeatingGroup) Add() NoMDEntryTypes { + g := m.RepeatingGroup.Add() + return NoMDEntryTypes{g} +} + +//Get returns the ith NoMDEntryTypes in the NoMDEntryTypesRepeatinGroup +func (m NoMDEntryTypesRepeatingGroup) Get(i int) NoMDEntryTypes { + return NoMDEntryTypes{m.RepeatingGroup.Get(i)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix44/newordersingle/NewOrderSingle.generated.go b/vendor/github.com/quickfixgo/quickfix/fix44/newordersingle/NewOrderSingle.generated.go new file mode 100644 index 0000000..761ed8c --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix44/newordersingle/NewOrderSingle.generated.go @@ -0,0 +1,4141 @@ +package newordersingle + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fix44" + "github.com/quickfixgo/quickfix/tag" +) + +//NewOrderSingle is the fix44 NewOrderSingle type, MsgType = D +type NewOrderSingle struct { + fix44.Header + quickfix.Body + fix44.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a NewOrderSingle from a quickfix.Message instance +func FromMessage(m quickfix.Message) NewOrderSingle { + return NewOrderSingle{ + Header: fix44.Header{Header: m.Header}, + Body: m.Body, + Trailer: fix44.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m NewOrderSingle) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a NewOrderSingle initialized with the required fields for NewOrderSingle +func New(clordid field.ClOrdIDField, side field.SideField, transacttime field.TransactTimeField, ordtype field.OrdTypeField) (m NewOrderSingle) { + m.Header = fix44.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("D")) + m.Set(clordid) + m.Set(side) + m.Set(transacttime) + m.Set(ordtype) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg NewOrderSingle, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "FIX.4.4", "D", r +} + +//SetAccount sets Account, Tag 1 +func (m NewOrderSingle) SetAccount(v string) { + m.Set(field.NewAccount(v)) +} + +//SetClOrdID sets ClOrdID, Tag 11 +func (m NewOrderSingle) SetClOrdID(v string) { + m.Set(field.NewClOrdID(v)) +} + +//SetCommission sets Commission, Tag 12 +func (m NewOrderSingle) SetCommission(v float64) { + m.Set(field.NewCommission(v)) +} + +//SetCommType sets CommType, Tag 13 +func (m NewOrderSingle) SetCommType(v string) { + m.Set(field.NewCommType(v)) +} + +//SetCurrency sets Currency, Tag 15 +func (m NewOrderSingle) SetCurrency(v string) { + m.Set(field.NewCurrency(v)) +} + +//SetExecInst sets ExecInst, Tag 18 +func (m NewOrderSingle) SetExecInst(v string) { + m.Set(field.NewExecInst(v)) +} + +//SetHandlInst sets HandlInst, Tag 21 +func (m NewOrderSingle) SetHandlInst(v string) { + m.Set(field.NewHandlInst(v)) +} + +//SetSecurityIDSource sets SecurityIDSource, Tag 22 +func (m NewOrderSingle) SetSecurityIDSource(v string) { + m.Set(field.NewSecurityIDSource(v)) +} + +//SetIOIID sets IOIID, Tag 23 +func (m NewOrderSingle) SetIOIID(v string) { + m.Set(field.NewIOIID(v)) +} + +//SetOrderQty sets OrderQty, Tag 38 +func (m NewOrderSingle) SetOrderQty(v float64) { + m.Set(field.NewOrderQty(v)) +} + +//SetOrdType sets OrdType, Tag 40 +func (m NewOrderSingle) SetOrdType(v string) { + m.Set(field.NewOrdType(v)) +} + +//SetPrice sets Price, Tag 44 +func (m NewOrderSingle) SetPrice(v float64) { + m.Set(field.NewPrice(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m NewOrderSingle) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSide sets Side, Tag 54 +func (m NewOrderSingle) SetSide(v string) { + m.Set(field.NewSide(v)) +} + +//SetSymbol sets Symbol, Tag 55 +func (m NewOrderSingle) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetText sets Text, Tag 58 +func (m NewOrderSingle) SetText(v string) { + m.Set(field.NewText(v)) +} + +//SetTimeInForce sets TimeInForce, Tag 59 +func (m NewOrderSingle) SetTimeInForce(v string) { + m.Set(field.NewTimeInForce(v)) +} + +//SetTransactTime sets TransactTime, Tag 60 +func (m NewOrderSingle) SetTransactTime(v time.Time) { + m.Set(field.NewTransactTime(v)) +} + +//SetSettlType sets SettlType, Tag 63 +func (m NewOrderSingle) SetSettlType(v string) { + m.Set(field.NewSettlType(v)) +} + +//SetSettlDate sets SettlDate, Tag 64 +func (m NewOrderSingle) SetSettlDate(v string) { + m.Set(field.NewSettlDate(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m NewOrderSingle) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetAllocID sets AllocID, Tag 70 +func (m NewOrderSingle) SetAllocID(v string) { + m.Set(field.NewAllocID(v)) +} + +//SetTradeDate sets TradeDate, Tag 75 +func (m NewOrderSingle) SetTradeDate(v string) { + m.Set(field.NewTradeDate(v)) +} + +//SetPositionEffect sets PositionEffect, Tag 77 +func (m NewOrderSingle) SetPositionEffect(v string) { + m.Set(field.NewPositionEffect(v)) +} + +//SetNoAllocs sets NoAllocs, Tag 78 +func (m NewOrderSingle) SetNoAllocs(f NoAllocsRepeatingGroup) { + m.SetGroup(f) +} + +//SetProcessCode sets ProcessCode, Tag 81 +func (m NewOrderSingle) SetProcessCode(v string) { + m.Set(field.NewProcessCode(v)) +} + +//SetStopPx sets StopPx, Tag 99 +func (m NewOrderSingle) SetStopPx(v float64) { + m.Set(field.NewStopPx(v)) +} + +//SetExDestination sets ExDestination, Tag 100 +func (m NewOrderSingle) SetExDestination(v string) { + m.Set(field.NewExDestination(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m NewOrderSingle) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m NewOrderSingle) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetMinQty sets MinQty, Tag 110 +func (m NewOrderSingle) SetMinQty(v float64) { + m.Set(field.NewMinQty(v)) +} + +//SetMaxFloor sets MaxFloor, Tag 111 +func (m NewOrderSingle) SetMaxFloor(v float64) { + m.Set(field.NewMaxFloor(v)) +} + +//SetLocateReqd sets LocateReqd, Tag 114 +func (m NewOrderSingle) SetLocateReqd(v bool) { + m.Set(field.NewLocateReqd(v)) +} + +//SetQuoteID sets QuoteID, Tag 117 +func (m NewOrderSingle) SetQuoteID(v string) { + m.Set(field.NewQuoteID(v)) +} + +//SetSettlCurrency sets SettlCurrency, Tag 120 +func (m NewOrderSingle) SetSettlCurrency(v string) { + m.Set(field.NewSettlCurrency(v)) +} + +//SetForexReq sets ForexReq, Tag 121 +func (m NewOrderSingle) SetForexReq(v bool) { + m.Set(field.NewForexReq(v)) +} + +//SetExpireTime sets ExpireTime, Tag 126 +func (m NewOrderSingle) SetExpireTime(v time.Time) { + m.Set(field.NewExpireTime(v)) +} + +//SetPrevClosePx sets PrevClosePx, Tag 140 +func (m NewOrderSingle) SetPrevClosePx(v float64) { + m.Set(field.NewPrevClosePx(v)) +} + +//SetCashOrderQty sets CashOrderQty, Tag 152 +func (m NewOrderSingle) SetCashOrderQty(v float64) { + m.Set(field.NewCashOrderQty(v)) +} + +//SetSecurityType sets SecurityType, Tag 167 +func (m NewOrderSingle) SetSecurityType(v string) { + m.Set(field.NewSecurityType(v)) +} + +//SetEffectiveTime sets EffectiveTime, Tag 168 +func (m NewOrderSingle) SetEffectiveTime(v time.Time) { + m.Set(field.NewEffectiveTime(v)) +} + +//SetOrderQty2 sets OrderQty2, Tag 192 +func (m NewOrderSingle) SetOrderQty2(v float64) { + m.Set(field.NewOrderQty2(v)) +} + +//SetSettlDate2 sets SettlDate2, Tag 193 +func (m NewOrderSingle) SetSettlDate2(v string) { + m.Set(field.NewSettlDate2(v)) +} + +//SetMaturityMonthYear sets MaturityMonthYear, Tag 200 +func (m NewOrderSingle) SetMaturityMonthYear(v string) { + m.Set(field.NewMaturityMonthYear(v)) +} + +//SetStrikePrice sets StrikePrice, Tag 202 +func (m NewOrderSingle) SetStrikePrice(v float64) { + m.Set(field.NewStrikePrice(v)) +} + +//SetCoveredOrUncovered sets CoveredOrUncovered, Tag 203 +func (m NewOrderSingle) SetCoveredOrUncovered(v int) { + m.Set(field.NewCoveredOrUncovered(v)) +} + +//SetOptAttribute sets OptAttribute, Tag 206 +func (m NewOrderSingle) SetOptAttribute(v string) { + m.Set(field.NewOptAttribute(v)) +} + +//SetSecurityExchange sets SecurityExchange, Tag 207 +func (m NewOrderSingle) SetSecurityExchange(v string) { + m.Set(field.NewSecurityExchange(v)) +} + +//SetMaxShow sets MaxShow, Tag 210 +func (m NewOrderSingle) SetMaxShow(v float64) { + m.Set(field.NewMaxShow(v)) +} + +//SetPegOffsetValue sets PegOffsetValue, Tag 211 +func (m NewOrderSingle) SetPegOffsetValue(v float64) { + m.Set(field.NewPegOffsetValue(v)) +} + +//SetSpread sets Spread, Tag 218 +func (m NewOrderSingle) SetSpread(v float64) { + m.Set(field.NewSpread(v)) +} + +//SetBenchmarkCurveCurrency sets BenchmarkCurveCurrency, Tag 220 +func (m NewOrderSingle) SetBenchmarkCurveCurrency(v string) { + m.Set(field.NewBenchmarkCurveCurrency(v)) +} + +//SetBenchmarkCurveName sets BenchmarkCurveName, Tag 221 +func (m NewOrderSingle) SetBenchmarkCurveName(v string) { + m.Set(field.NewBenchmarkCurveName(v)) +} + +//SetBenchmarkCurvePoint sets BenchmarkCurvePoint, Tag 222 +func (m NewOrderSingle) SetBenchmarkCurvePoint(v string) { + m.Set(field.NewBenchmarkCurvePoint(v)) +} + +//SetCouponRate sets CouponRate, Tag 223 +func (m NewOrderSingle) SetCouponRate(v float64) { + m.Set(field.NewCouponRate(v)) +} + +//SetCouponPaymentDate sets CouponPaymentDate, Tag 224 +func (m NewOrderSingle) SetCouponPaymentDate(v string) { + m.Set(field.NewCouponPaymentDate(v)) +} + +//SetIssueDate sets IssueDate, Tag 225 +func (m NewOrderSingle) SetIssueDate(v string) { + m.Set(field.NewIssueDate(v)) +} + +//SetRepurchaseTerm sets RepurchaseTerm, Tag 226 +func (m NewOrderSingle) SetRepurchaseTerm(v int) { + m.Set(field.NewRepurchaseTerm(v)) +} + +//SetRepurchaseRate sets RepurchaseRate, Tag 227 +func (m NewOrderSingle) SetRepurchaseRate(v float64) { + m.Set(field.NewRepurchaseRate(v)) +} + +//SetFactor sets Factor, Tag 228 +func (m NewOrderSingle) SetFactor(v float64) { + m.Set(field.NewFactor(v)) +} + +//SetTradeOriginationDate sets TradeOriginationDate, Tag 229 +func (m NewOrderSingle) SetTradeOriginationDate(v string) { + m.Set(field.NewTradeOriginationDate(v)) +} + +//SetContractMultiplier sets ContractMultiplier, Tag 231 +func (m NewOrderSingle) SetContractMultiplier(v float64) { + m.Set(field.NewContractMultiplier(v)) +} + +//SetNoStipulations sets NoStipulations, Tag 232 +func (m NewOrderSingle) SetNoStipulations(f NoStipulationsRepeatingGroup) { + m.SetGroup(f) +} + +//SetYieldType sets YieldType, Tag 235 +func (m NewOrderSingle) SetYieldType(v string) { + m.Set(field.NewYieldType(v)) +} + +//SetYield sets Yield, Tag 236 +func (m NewOrderSingle) SetYield(v float64) { + m.Set(field.NewYield(v)) +} + +//SetRepoCollateralSecurityType sets RepoCollateralSecurityType, Tag 239 +func (m NewOrderSingle) SetRepoCollateralSecurityType(v int) { + m.Set(field.NewRepoCollateralSecurityType(v)) +} + +//SetRedemptionDate sets RedemptionDate, Tag 240 +func (m NewOrderSingle) SetRedemptionDate(v string) { + m.Set(field.NewRedemptionDate(v)) +} + +//SetCreditRating sets CreditRating, Tag 255 +func (m NewOrderSingle) SetCreditRating(v string) { + m.Set(field.NewCreditRating(v)) +} + +//SetEncodedIssuerLen sets EncodedIssuerLen, Tag 348 +func (m NewOrderSingle) SetEncodedIssuerLen(v int) { + m.Set(field.NewEncodedIssuerLen(v)) +} + +//SetEncodedIssuer sets EncodedIssuer, Tag 349 +func (m NewOrderSingle) SetEncodedIssuer(v string) { + m.Set(field.NewEncodedIssuer(v)) +} + +//SetEncodedSecurityDescLen sets EncodedSecurityDescLen, Tag 350 +func (m NewOrderSingle) SetEncodedSecurityDescLen(v int) { + m.Set(field.NewEncodedSecurityDescLen(v)) +} + +//SetEncodedSecurityDesc sets EncodedSecurityDesc, Tag 351 +func (m NewOrderSingle) SetEncodedSecurityDesc(v string) { + m.Set(field.NewEncodedSecurityDesc(v)) +} + +//SetEncodedTextLen sets EncodedTextLen, Tag 354 +func (m NewOrderSingle) SetEncodedTextLen(v int) { + m.Set(field.NewEncodedTextLen(v)) +} + +//SetEncodedText sets EncodedText, Tag 355 +func (m NewOrderSingle) SetEncodedText(v string) { + m.Set(field.NewEncodedText(v)) +} + +//SetComplianceID sets ComplianceID, Tag 376 +func (m NewOrderSingle) SetComplianceID(v string) { + m.Set(field.NewComplianceID(v)) +} + +//SetSolicitedFlag sets SolicitedFlag, Tag 377 +func (m NewOrderSingle) SetSolicitedFlag(v bool) { + m.Set(field.NewSolicitedFlag(v)) +} + +//SetNoTradingSessions sets NoTradingSessions, Tag 386 +func (m NewOrderSingle) SetNoTradingSessions(f NoTradingSessionsRepeatingGroup) { + m.SetGroup(f) +} + +//SetDiscretionInst sets DiscretionInst, Tag 388 +func (m NewOrderSingle) SetDiscretionInst(v string) { + m.Set(field.NewDiscretionInst(v)) +} + +//SetDiscretionOffsetValue sets DiscretionOffsetValue, Tag 389 +func (m NewOrderSingle) SetDiscretionOffsetValue(v float64) { + m.Set(field.NewDiscretionOffsetValue(v)) +} + +//SetPriceType sets PriceType, Tag 423 +func (m NewOrderSingle) SetPriceType(v int) { + m.Set(field.NewPriceType(v)) +} + +//SetGTBookingInst sets GTBookingInst, Tag 427 +func (m NewOrderSingle) SetGTBookingInst(v int) { + m.Set(field.NewGTBookingInst(v)) +} + +//SetExpireDate sets ExpireDate, Tag 432 +func (m NewOrderSingle) SetExpireDate(v string) { + m.Set(field.NewExpireDate(v)) +} + +//SetNoPartyIDs sets NoPartyIDs, Tag 453 +func (m NewOrderSingle) SetNoPartyIDs(f NoPartyIDsRepeatingGroup) { + m.SetGroup(f) +} + +//SetNoSecurityAltID sets NoSecurityAltID, Tag 454 +func (m NewOrderSingle) SetNoSecurityAltID(f NoSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetProduct sets Product, Tag 460 +func (m NewOrderSingle) SetProduct(v int) { + m.Set(field.NewProduct(v)) +} + +//SetCFICode sets CFICode, Tag 461 +func (m NewOrderSingle) SetCFICode(v string) { + m.Set(field.NewCFICode(v)) +} + +//SetRoundingDirection sets RoundingDirection, Tag 468 +func (m NewOrderSingle) SetRoundingDirection(v string) { + m.Set(field.NewRoundingDirection(v)) +} + +//SetRoundingModulus sets RoundingModulus, Tag 469 +func (m NewOrderSingle) SetRoundingModulus(v float64) { + m.Set(field.NewRoundingModulus(v)) +} + +//SetCountryOfIssue sets CountryOfIssue, Tag 470 +func (m NewOrderSingle) SetCountryOfIssue(v string) { + m.Set(field.NewCountryOfIssue(v)) +} + +//SetStateOrProvinceOfIssue sets StateOrProvinceOfIssue, Tag 471 +func (m NewOrderSingle) SetStateOrProvinceOfIssue(v string) { + m.Set(field.NewStateOrProvinceOfIssue(v)) +} + +//SetLocaleOfIssue sets LocaleOfIssue, Tag 472 +func (m NewOrderSingle) SetLocaleOfIssue(v string) { + m.Set(field.NewLocaleOfIssue(v)) +} + +//SetCommCurrency sets CommCurrency, Tag 479 +func (m NewOrderSingle) SetCommCurrency(v string) { + m.Set(field.NewCommCurrency(v)) +} + +//SetCancellationRights sets CancellationRights, Tag 480 +func (m NewOrderSingle) SetCancellationRights(v string) { + m.Set(field.NewCancellationRights(v)) +} + +//SetMoneyLaunderingStatus sets MoneyLaunderingStatus, Tag 481 +func (m NewOrderSingle) SetMoneyLaunderingStatus(v string) { + m.Set(field.NewMoneyLaunderingStatus(v)) +} + +//SetDesignation sets Designation, Tag 494 +func (m NewOrderSingle) SetDesignation(v string) { + m.Set(field.NewDesignation(v)) +} + +//SetFundRenewWaiv sets FundRenewWaiv, Tag 497 +func (m NewOrderSingle) SetFundRenewWaiv(v string) { + m.Set(field.NewFundRenewWaiv(v)) +} + +//SetRegistID sets RegistID, Tag 513 +func (m NewOrderSingle) SetRegistID(v string) { + m.Set(field.NewRegistID(v)) +} + +//SetOrderPercent sets OrderPercent, Tag 516 +func (m NewOrderSingle) SetOrderPercent(v float64) { + m.Set(field.NewOrderPercent(v)) +} + +//SetSecondaryClOrdID sets SecondaryClOrdID, Tag 526 +func (m NewOrderSingle) SetSecondaryClOrdID(v string) { + m.Set(field.NewSecondaryClOrdID(v)) +} + +//SetOrderCapacity sets OrderCapacity, Tag 528 +func (m NewOrderSingle) SetOrderCapacity(v string) { + m.Set(field.NewOrderCapacity(v)) +} + +//SetOrderRestrictions sets OrderRestrictions, Tag 529 +func (m NewOrderSingle) SetOrderRestrictions(v string) { + m.Set(field.NewOrderRestrictions(v)) +} + +//SetMaturityDate sets MaturityDate, Tag 541 +func (m NewOrderSingle) SetMaturityDate(v string) { + m.Set(field.NewMaturityDate(v)) +} + +//SetInstrRegistry sets InstrRegistry, Tag 543 +func (m NewOrderSingle) SetInstrRegistry(v string) { + m.Set(field.NewInstrRegistry(v)) +} + +//SetCashMargin sets CashMargin, Tag 544 +func (m NewOrderSingle) SetCashMargin(v string) { + m.Set(field.NewCashMargin(v)) +} + +//SetAccountType sets AccountType, Tag 581 +func (m NewOrderSingle) SetAccountType(v int) { + m.Set(field.NewAccountType(v)) +} + +//SetCustOrderCapacity sets CustOrderCapacity, Tag 582 +func (m NewOrderSingle) SetCustOrderCapacity(v int) { + m.Set(field.NewCustOrderCapacity(v)) +} + +//SetClOrdLinkID sets ClOrdLinkID, Tag 583 +func (m NewOrderSingle) SetClOrdLinkID(v string) { + m.Set(field.NewClOrdLinkID(v)) +} + +//SetDayBookingInst sets DayBookingInst, Tag 589 +func (m NewOrderSingle) SetDayBookingInst(v string) { + m.Set(field.NewDayBookingInst(v)) +} + +//SetBookingUnit sets BookingUnit, Tag 590 +func (m NewOrderSingle) SetBookingUnit(v string) { + m.Set(field.NewBookingUnit(v)) +} + +//SetPreallocMethod sets PreallocMethod, Tag 591 +func (m NewOrderSingle) SetPreallocMethod(v string) { + m.Set(field.NewPreallocMethod(v)) +} + +//SetClearingFeeIndicator sets ClearingFeeIndicator, Tag 635 +func (m NewOrderSingle) SetClearingFeeIndicator(v string) { + m.Set(field.NewClearingFeeIndicator(v)) +} + +//SetPrice2 sets Price2, Tag 640 +func (m NewOrderSingle) SetPrice2(v float64) { + m.Set(field.NewPrice2(v)) +} + +//SetAcctIDSource sets AcctIDSource, Tag 660 +func (m NewOrderSingle) SetAcctIDSource(v int) { + m.Set(field.NewAcctIDSource(v)) +} + +//SetBenchmarkPrice sets BenchmarkPrice, Tag 662 +func (m NewOrderSingle) SetBenchmarkPrice(v float64) { + m.Set(field.NewBenchmarkPrice(v)) +} + +//SetBenchmarkPriceType sets BenchmarkPriceType, Tag 663 +func (m NewOrderSingle) SetBenchmarkPriceType(v int) { + m.Set(field.NewBenchmarkPriceType(v)) +} + +//SetContractSettlMonth sets ContractSettlMonth, Tag 667 +func (m NewOrderSingle) SetContractSettlMonth(v string) { + m.Set(field.NewContractSettlMonth(v)) +} + +//SetPool sets Pool, Tag 691 +func (m NewOrderSingle) SetPool(v string) { + m.Set(field.NewPool(v)) +} + +//SetYieldRedemptionDate sets YieldRedemptionDate, Tag 696 +func (m NewOrderSingle) SetYieldRedemptionDate(v string) { + m.Set(field.NewYieldRedemptionDate(v)) +} + +//SetYieldRedemptionPrice sets YieldRedemptionPrice, Tag 697 +func (m NewOrderSingle) SetYieldRedemptionPrice(v float64) { + m.Set(field.NewYieldRedemptionPrice(v)) +} + +//SetYieldRedemptionPriceType sets YieldRedemptionPriceType, Tag 698 +func (m NewOrderSingle) SetYieldRedemptionPriceType(v int) { + m.Set(field.NewYieldRedemptionPriceType(v)) +} + +//SetBenchmarkSecurityID sets BenchmarkSecurityID, Tag 699 +func (m NewOrderSingle) SetBenchmarkSecurityID(v string) { + m.Set(field.NewBenchmarkSecurityID(v)) +} + +//SetYieldCalcDate sets YieldCalcDate, Tag 701 +func (m NewOrderSingle) SetYieldCalcDate(v string) { + m.Set(field.NewYieldCalcDate(v)) +} + +//SetNoUnderlyings sets NoUnderlyings, Tag 711 +func (m NewOrderSingle) SetNoUnderlyings(f NoUnderlyingsRepeatingGroup) { + m.SetGroup(f) +} + +//SetBenchmarkSecurityIDSource sets BenchmarkSecurityIDSource, Tag 761 +func (m NewOrderSingle) SetBenchmarkSecurityIDSource(v string) { + m.Set(field.NewBenchmarkSecurityIDSource(v)) +} + +//SetSecuritySubType sets SecuritySubType, Tag 762 +func (m NewOrderSingle) SetSecuritySubType(v string) { + m.Set(field.NewSecuritySubType(v)) +} + +//SetBookingType sets BookingType, Tag 775 +func (m NewOrderSingle) SetBookingType(v int) { + m.Set(field.NewBookingType(v)) +} + +//SetTerminationType sets TerminationType, Tag 788 +func (m NewOrderSingle) SetTerminationType(v int) { + m.Set(field.NewTerminationType(v)) +} + +//SetPegMoveType sets PegMoveType, Tag 835 +func (m NewOrderSingle) SetPegMoveType(v int) { + m.Set(field.NewPegMoveType(v)) +} + +//SetPegOffsetType sets PegOffsetType, Tag 836 +func (m NewOrderSingle) SetPegOffsetType(v int) { + m.Set(field.NewPegOffsetType(v)) +} + +//SetPegLimitType sets PegLimitType, Tag 837 +func (m NewOrderSingle) SetPegLimitType(v int) { + m.Set(field.NewPegLimitType(v)) +} + +//SetPegRoundDirection sets PegRoundDirection, Tag 838 +func (m NewOrderSingle) SetPegRoundDirection(v int) { + m.Set(field.NewPegRoundDirection(v)) +} + +//SetPegScope sets PegScope, Tag 840 +func (m NewOrderSingle) SetPegScope(v int) { + m.Set(field.NewPegScope(v)) +} + +//SetDiscretionMoveType sets DiscretionMoveType, Tag 841 +func (m NewOrderSingle) SetDiscretionMoveType(v int) { + m.Set(field.NewDiscretionMoveType(v)) +} + +//SetDiscretionOffsetType sets DiscretionOffsetType, Tag 842 +func (m NewOrderSingle) SetDiscretionOffsetType(v int) { + m.Set(field.NewDiscretionOffsetType(v)) +} + +//SetDiscretionLimitType sets DiscretionLimitType, Tag 843 +func (m NewOrderSingle) SetDiscretionLimitType(v int) { + m.Set(field.NewDiscretionLimitType(v)) +} + +//SetDiscretionRoundDirection sets DiscretionRoundDirection, Tag 844 +func (m NewOrderSingle) SetDiscretionRoundDirection(v int) { + m.Set(field.NewDiscretionRoundDirection(v)) +} + +//SetDiscretionScope sets DiscretionScope, Tag 846 +func (m NewOrderSingle) SetDiscretionScope(v int) { + m.Set(field.NewDiscretionScope(v)) +} + +//SetTargetStrategy sets TargetStrategy, Tag 847 +func (m NewOrderSingle) SetTargetStrategy(v int) { + m.Set(field.NewTargetStrategy(v)) +} + +//SetTargetStrategyParameters sets TargetStrategyParameters, Tag 848 +func (m NewOrderSingle) SetTargetStrategyParameters(v string) { + m.Set(field.NewTargetStrategyParameters(v)) +} + +//SetParticipationRate sets ParticipationRate, Tag 849 +func (m NewOrderSingle) SetParticipationRate(v float64) { + m.Set(field.NewParticipationRate(v)) +} + +//SetQtyType sets QtyType, Tag 854 +func (m NewOrderSingle) SetQtyType(v int) { + m.Set(field.NewQtyType(v)) +} + +//SetNoEvents sets NoEvents, Tag 864 +func (m NewOrderSingle) SetNoEvents(f NoEventsRepeatingGroup) { + m.SetGroup(f) +} + +//SetDatedDate sets DatedDate, Tag 873 +func (m NewOrderSingle) SetDatedDate(v string) { + m.Set(field.NewDatedDate(v)) +} + +//SetInterestAccrualDate sets InterestAccrualDate, Tag 874 +func (m NewOrderSingle) SetInterestAccrualDate(v string) { + m.Set(field.NewInterestAccrualDate(v)) +} + +//SetCPProgram sets CPProgram, Tag 875 +func (m NewOrderSingle) SetCPProgram(v int) { + m.Set(field.NewCPProgram(v)) +} + +//SetCPRegType sets CPRegType, Tag 876 +func (m NewOrderSingle) SetCPRegType(v string) { + m.Set(field.NewCPRegType(v)) +} + +//SetMarginRatio sets MarginRatio, Tag 898 +func (m NewOrderSingle) SetMarginRatio(v float64) { + m.Set(field.NewMarginRatio(v)) +} + +//SetAgreementDesc sets AgreementDesc, Tag 913 +func (m NewOrderSingle) SetAgreementDesc(v string) { + m.Set(field.NewAgreementDesc(v)) +} + +//SetAgreementID sets AgreementID, Tag 914 +func (m NewOrderSingle) SetAgreementID(v string) { + m.Set(field.NewAgreementID(v)) +} + +//SetAgreementDate sets AgreementDate, Tag 915 +func (m NewOrderSingle) SetAgreementDate(v string) { + m.Set(field.NewAgreementDate(v)) +} + +//SetStartDate sets StartDate, Tag 916 +func (m NewOrderSingle) SetStartDate(v string) { + m.Set(field.NewStartDate(v)) +} + +//SetEndDate sets EndDate, Tag 917 +func (m NewOrderSingle) SetEndDate(v string) { + m.Set(field.NewEndDate(v)) +} + +//SetAgreementCurrency sets AgreementCurrency, Tag 918 +func (m NewOrderSingle) SetAgreementCurrency(v string) { + m.Set(field.NewAgreementCurrency(v)) +} + +//SetDeliveryType sets DeliveryType, Tag 919 +func (m NewOrderSingle) SetDeliveryType(v int) { + m.Set(field.NewDeliveryType(v)) +} + +//SetStrikeCurrency sets StrikeCurrency, Tag 947 +func (m NewOrderSingle) SetStrikeCurrency(v string) { + m.Set(field.NewStrikeCurrency(v)) +} + +//GetAccount gets Account, Tag 1 +func (m NewOrderSingle) GetAccount() (f field.AccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdID gets ClOrdID, Tag 11 +func (m NewOrderSingle) GetClOrdID() (f field.ClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommission gets Commission, Tag 12 +func (m NewOrderSingle) GetCommission() (f field.CommissionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommType gets CommType, Tag 13 +func (m NewOrderSingle) GetCommType() (f field.CommTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCurrency gets Currency, Tag 15 +func (m NewOrderSingle) GetCurrency() (f field.CurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecInst gets ExecInst, Tag 18 +func (m NewOrderSingle) GetExecInst() (f field.ExecInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetHandlInst gets HandlInst, Tag 21 +func (m NewOrderSingle) GetHandlInst() (f field.HandlInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityIDSource gets SecurityIDSource, Tag 22 +func (m NewOrderSingle) GetSecurityIDSource() (f field.SecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIOIID gets IOIID, Tag 23 +func (m NewOrderSingle) GetIOIID() (f field.IOIIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty gets OrderQty, Tag 38 +func (m NewOrderSingle) GetOrderQty() (f field.OrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdType gets OrdType, Tag 40 +func (m NewOrderSingle) GetOrdType() (f field.OrdTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrice gets Price, Tag 44 +func (m NewOrderSingle) GetPrice() (f field.PriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m NewOrderSingle) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSide gets Side, Tag 54 +func (m NewOrderSingle) GetSide() (f field.SideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbol gets Symbol, Tag 55 +func (m NewOrderSingle) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetText gets Text, Tag 58 +func (m NewOrderSingle) GetText() (f field.TextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTimeInForce gets TimeInForce, Tag 59 +func (m NewOrderSingle) GetTimeInForce() (f field.TimeInForceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTransactTime gets TransactTime, Tag 60 +func (m NewOrderSingle) GetTransactTime() (f field.TransactTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlType gets SettlType, Tag 63 +func (m NewOrderSingle) GetSettlType() (f field.SettlTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlDate gets SettlDate, Tag 64 +func (m NewOrderSingle) GetSettlDate() (f field.SettlDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m NewOrderSingle) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAllocID gets AllocID, Tag 70 +func (m NewOrderSingle) GetAllocID() (f field.AllocIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradeDate gets TradeDate, Tag 75 +func (m NewOrderSingle) GetTradeDate() (f field.TradeDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPositionEffect gets PositionEffect, Tag 77 +func (m NewOrderSingle) GetPositionEffect() (f field.PositionEffectField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoAllocs gets NoAllocs, Tag 78 +func (m NewOrderSingle) GetNoAllocs() (NoAllocsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoAllocsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetProcessCode gets ProcessCode, Tag 81 +func (m NewOrderSingle) GetProcessCode() (f field.ProcessCodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStopPx gets StopPx, Tag 99 +func (m NewOrderSingle) GetStopPx() (f field.StopPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExDestination gets ExDestination, Tag 100 +func (m NewOrderSingle) GetExDestination() (f field.ExDestinationField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m NewOrderSingle) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m NewOrderSingle) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMinQty gets MinQty, Tag 110 +func (m NewOrderSingle) GetMinQty() (f field.MinQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxFloor gets MaxFloor, Tag 111 +func (m NewOrderSingle) GetMaxFloor() (f field.MaxFloorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLocateReqd gets LocateReqd, Tag 114 +func (m NewOrderSingle) GetLocateReqd() (f field.LocateReqdField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetQuoteID gets QuoteID, Tag 117 +func (m NewOrderSingle) GetQuoteID() (f field.QuoteIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrency gets SettlCurrency, Tag 120 +func (m NewOrderSingle) GetSettlCurrency() (f field.SettlCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetForexReq gets ForexReq, Tag 121 +func (m NewOrderSingle) GetForexReq() (f field.ForexReqField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireTime gets ExpireTime, Tag 126 +func (m NewOrderSingle) GetExpireTime() (f field.ExpireTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrevClosePx gets PrevClosePx, Tag 140 +func (m NewOrderSingle) GetPrevClosePx() (f field.PrevClosePxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashOrderQty gets CashOrderQty, Tag 152 +func (m NewOrderSingle) GetCashOrderQty() (f field.CashOrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityType gets SecurityType, Tag 167 +func (m NewOrderSingle) GetSecurityType() (f field.SecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEffectiveTime gets EffectiveTime, Tag 168 +func (m NewOrderSingle) GetEffectiveTime() (f field.EffectiveTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty2 gets OrderQty2, Tag 192 +func (m NewOrderSingle) GetOrderQty2() (f field.OrderQty2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlDate2 gets SettlDate2, Tag 193 +func (m NewOrderSingle) GetSettlDate2() (f field.SettlDate2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityMonthYear gets MaturityMonthYear, Tag 200 +func (m NewOrderSingle) GetMaturityMonthYear() (f field.MaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikePrice gets StrikePrice, Tag 202 +func (m NewOrderSingle) GetStrikePrice() (f field.StrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCoveredOrUncovered gets CoveredOrUncovered, Tag 203 +func (m NewOrderSingle) GetCoveredOrUncovered() (f field.CoveredOrUncoveredField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOptAttribute gets OptAttribute, Tag 206 +func (m NewOrderSingle) GetOptAttribute() (f field.OptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityExchange gets SecurityExchange, Tag 207 +func (m NewOrderSingle) GetSecurityExchange() (f field.SecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxShow gets MaxShow, Tag 210 +func (m NewOrderSingle) GetMaxShow() (f field.MaxShowField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegOffsetValue gets PegOffsetValue, Tag 211 +func (m NewOrderSingle) GetPegOffsetValue() (f field.PegOffsetValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSpread gets Spread, Tag 218 +func (m NewOrderSingle) GetSpread() (f field.SpreadField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkCurveCurrency gets BenchmarkCurveCurrency, Tag 220 +func (m NewOrderSingle) GetBenchmarkCurveCurrency() (f field.BenchmarkCurveCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkCurveName gets BenchmarkCurveName, Tag 221 +func (m NewOrderSingle) GetBenchmarkCurveName() (f field.BenchmarkCurveNameField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkCurvePoint gets BenchmarkCurvePoint, Tag 222 +func (m NewOrderSingle) GetBenchmarkCurvePoint() (f field.BenchmarkCurvePointField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponRate gets CouponRate, Tag 223 +func (m NewOrderSingle) GetCouponRate() (f field.CouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponPaymentDate gets CouponPaymentDate, Tag 224 +func (m NewOrderSingle) GetCouponPaymentDate() (f field.CouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssueDate gets IssueDate, Tag 225 +func (m NewOrderSingle) GetIssueDate() (f field.IssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseTerm gets RepurchaseTerm, Tag 226 +func (m NewOrderSingle) GetRepurchaseTerm() (f field.RepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseRate gets RepurchaseRate, Tag 227 +func (m NewOrderSingle) GetRepurchaseRate() (f field.RepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFactor gets Factor, Tag 228 +func (m NewOrderSingle) GetFactor() (f field.FactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradeOriginationDate gets TradeOriginationDate, Tag 229 +func (m NewOrderSingle) GetTradeOriginationDate() (f field.TradeOriginationDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractMultiplier gets ContractMultiplier, Tag 231 +func (m NewOrderSingle) GetContractMultiplier() (f field.ContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoStipulations gets NoStipulations, Tag 232 +func (m NewOrderSingle) GetNoStipulations() (NoStipulationsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoStipulationsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetYieldType gets YieldType, Tag 235 +func (m NewOrderSingle) GetYieldType() (f field.YieldTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYield gets Yield, Tag 236 +func (m NewOrderSingle) GetYield() (f field.YieldField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepoCollateralSecurityType gets RepoCollateralSecurityType, Tag 239 +func (m NewOrderSingle) GetRepoCollateralSecurityType() (f field.RepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRedemptionDate gets RedemptionDate, Tag 240 +func (m NewOrderSingle) GetRedemptionDate() (f field.RedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCreditRating gets CreditRating, Tag 255 +func (m NewOrderSingle) GetCreditRating() (f field.CreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuerLen gets EncodedIssuerLen, Tag 348 +func (m NewOrderSingle) GetEncodedIssuerLen() (f field.EncodedIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuer gets EncodedIssuer, Tag 349 +func (m NewOrderSingle) GetEncodedIssuer() (f field.EncodedIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDescLen gets EncodedSecurityDescLen, Tag 350 +func (m NewOrderSingle) GetEncodedSecurityDescLen() (f field.EncodedSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDesc gets EncodedSecurityDesc, Tag 351 +func (m NewOrderSingle) GetEncodedSecurityDesc() (f field.EncodedSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedTextLen gets EncodedTextLen, Tag 354 +func (m NewOrderSingle) GetEncodedTextLen() (f field.EncodedTextLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedText gets EncodedText, Tag 355 +func (m NewOrderSingle) GetEncodedText() (f field.EncodedTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetComplianceID gets ComplianceID, Tag 376 +func (m NewOrderSingle) GetComplianceID() (f field.ComplianceIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSolicitedFlag gets SolicitedFlag, Tag 377 +func (m NewOrderSingle) GetSolicitedFlag() (f field.SolicitedFlagField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoTradingSessions gets NoTradingSessions, Tag 386 +func (m NewOrderSingle) GetNoTradingSessions() (NoTradingSessionsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoTradingSessionsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetDiscretionInst gets DiscretionInst, Tag 388 +func (m NewOrderSingle) GetDiscretionInst() (f field.DiscretionInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionOffsetValue gets DiscretionOffsetValue, Tag 389 +func (m NewOrderSingle) GetDiscretionOffsetValue() (f field.DiscretionOffsetValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPriceType gets PriceType, Tag 423 +func (m NewOrderSingle) GetPriceType() (f field.PriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetGTBookingInst gets GTBookingInst, Tag 427 +func (m NewOrderSingle) GetGTBookingInst() (f field.GTBookingInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireDate gets ExpireDate, Tag 432 +func (m NewOrderSingle) GetExpireDate() (f field.ExpireDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoPartyIDs gets NoPartyIDs, Tag 453 +func (m NewOrderSingle) GetNoPartyIDs() (NoPartyIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoPartyIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetNoSecurityAltID gets NoSecurityAltID, Tag 454 +func (m NewOrderSingle) GetNoSecurityAltID() (NoSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetProduct gets Product, Tag 460 +func (m NewOrderSingle) GetProduct() (f field.ProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCFICode gets CFICode, Tag 461 +func (m NewOrderSingle) GetCFICode() (f field.CFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRoundingDirection gets RoundingDirection, Tag 468 +func (m NewOrderSingle) GetRoundingDirection() (f field.RoundingDirectionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRoundingModulus gets RoundingModulus, Tag 469 +func (m NewOrderSingle) GetRoundingModulus() (f field.RoundingModulusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCountryOfIssue gets CountryOfIssue, Tag 470 +func (m NewOrderSingle) GetCountryOfIssue() (f field.CountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStateOrProvinceOfIssue gets StateOrProvinceOfIssue, Tag 471 +func (m NewOrderSingle) GetStateOrProvinceOfIssue() (f field.StateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLocaleOfIssue gets LocaleOfIssue, Tag 472 +func (m NewOrderSingle) GetLocaleOfIssue() (f field.LocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommCurrency gets CommCurrency, Tag 479 +func (m NewOrderSingle) GetCommCurrency() (f field.CommCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCancellationRights gets CancellationRights, Tag 480 +func (m NewOrderSingle) GetCancellationRights() (f field.CancellationRightsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMoneyLaunderingStatus gets MoneyLaunderingStatus, Tag 481 +func (m NewOrderSingle) GetMoneyLaunderingStatus() (f field.MoneyLaunderingStatusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDesignation gets Designation, Tag 494 +func (m NewOrderSingle) GetDesignation() (f field.DesignationField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFundRenewWaiv gets FundRenewWaiv, Tag 497 +func (m NewOrderSingle) GetFundRenewWaiv() (f field.FundRenewWaivField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRegistID gets RegistID, Tag 513 +func (m NewOrderSingle) GetRegistID() (f field.RegistIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderPercent gets OrderPercent, Tag 516 +func (m NewOrderSingle) GetOrderPercent() (f field.OrderPercentField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecondaryClOrdID gets SecondaryClOrdID, Tag 526 +func (m NewOrderSingle) GetSecondaryClOrdID() (f field.SecondaryClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderCapacity gets OrderCapacity, Tag 528 +func (m NewOrderSingle) GetOrderCapacity() (f field.OrderCapacityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderRestrictions gets OrderRestrictions, Tag 529 +func (m NewOrderSingle) GetOrderRestrictions() (f field.OrderRestrictionsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityDate gets MaturityDate, Tag 541 +func (m NewOrderSingle) GetMaturityDate() (f field.MaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrRegistry gets InstrRegistry, Tag 543 +func (m NewOrderSingle) GetInstrRegistry() (f field.InstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashMargin gets CashMargin, Tag 544 +func (m NewOrderSingle) GetCashMargin() (f field.CashMarginField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAccountType gets AccountType, Tag 581 +func (m NewOrderSingle) GetAccountType() (f field.AccountTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCustOrderCapacity gets CustOrderCapacity, Tag 582 +func (m NewOrderSingle) GetCustOrderCapacity() (f field.CustOrderCapacityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdLinkID gets ClOrdLinkID, Tag 583 +func (m NewOrderSingle) GetClOrdLinkID() (f field.ClOrdLinkIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDayBookingInst gets DayBookingInst, Tag 589 +func (m NewOrderSingle) GetDayBookingInst() (f field.DayBookingInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBookingUnit gets BookingUnit, Tag 590 +func (m NewOrderSingle) GetBookingUnit() (f field.BookingUnitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPreallocMethod gets PreallocMethod, Tag 591 +func (m NewOrderSingle) GetPreallocMethod() (f field.PreallocMethodField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClearingFeeIndicator gets ClearingFeeIndicator, Tag 635 +func (m NewOrderSingle) GetClearingFeeIndicator() (f field.ClearingFeeIndicatorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrice2 gets Price2, Tag 640 +func (m NewOrderSingle) GetPrice2() (f field.Price2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAcctIDSource gets AcctIDSource, Tag 660 +func (m NewOrderSingle) GetAcctIDSource() (f field.AcctIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkPrice gets BenchmarkPrice, Tag 662 +func (m NewOrderSingle) GetBenchmarkPrice() (f field.BenchmarkPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkPriceType gets BenchmarkPriceType, Tag 663 +func (m NewOrderSingle) GetBenchmarkPriceType() (f field.BenchmarkPriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractSettlMonth gets ContractSettlMonth, Tag 667 +func (m NewOrderSingle) GetContractSettlMonth() (f field.ContractSettlMonthField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPool gets Pool, Tag 691 +func (m NewOrderSingle) GetPool() (f field.PoolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYieldRedemptionDate gets YieldRedemptionDate, Tag 696 +func (m NewOrderSingle) GetYieldRedemptionDate() (f field.YieldRedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYieldRedemptionPrice gets YieldRedemptionPrice, Tag 697 +func (m NewOrderSingle) GetYieldRedemptionPrice() (f field.YieldRedemptionPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYieldRedemptionPriceType gets YieldRedemptionPriceType, Tag 698 +func (m NewOrderSingle) GetYieldRedemptionPriceType() (f field.YieldRedemptionPriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkSecurityID gets BenchmarkSecurityID, Tag 699 +func (m NewOrderSingle) GetBenchmarkSecurityID() (f field.BenchmarkSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYieldCalcDate gets YieldCalcDate, Tag 701 +func (m NewOrderSingle) GetYieldCalcDate() (f field.YieldCalcDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyings gets NoUnderlyings, Tag 711 +func (m NewOrderSingle) GetNoUnderlyings() (NoUnderlyingsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetBenchmarkSecurityIDSource gets BenchmarkSecurityIDSource, Tag 761 +func (m NewOrderSingle) GetBenchmarkSecurityIDSource() (f field.BenchmarkSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecuritySubType gets SecuritySubType, Tag 762 +func (m NewOrderSingle) GetSecuritySubType() (f field.SecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBookingType gets BookingType, Tag 775 +func (m NewOrderSingle) GetBookingType() (f field.BookingTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTerminationType gets TerminationType, Tag 788 +func (m NewOrderSingle) GetTerminationType() (f field.TerminationTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegMoveType gets PegMoveType, Tag 835 +func (m NewOrderSingle) GetPegMoveType() (f field.PegMoveTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegOffsetType gets PegOffsetType, Tag 836 +func (m NewOrderSingle) GetPegOffsetType() (f field.PegOffsetTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegLimitType gets PegLimitType, Tag 837 +func (m NewOrderSingle) GetPegLimitType() (f field.PegLimitTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegRoundDirection gets PegRoundDirection, Tag 838 +func (m NewOrderSingle) GetPegRoundDirection() (f field.PegRoundDirectionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegScope gets PegScope, Tag 840 +func (m NewOrderSingle) GetPegScope() (f field.PegScopeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionMoveType gets DiscretionMoveType, Tag 841 +func (m NewOrderSingle) GetDiscretionMoveType() (f field.DiscretionMoveTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionOffsetType gets DiscretionOffsetType, Tag 842 +func (m NewOrderSingle) GetDiscretionOffsetType() (f field.DiscretionOffsetTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionLimitType gets DiscretionLimitType, Tag 843 +func (m NewOrderSingle) GetDiscretionLimitType() (f field.DiscretionLimitTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionRoundDirection gets DiscretionRoundDirection, Tag 844 +func (m NewOrderSingle) GetDiscretionRoundDirection() (f field.DiscretionRoundDirectionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionScope gets DiscretionScope, Tag 846 +func (m NewOrderSingle) GetDiscretionScope() (f field.DiscretionScopeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTargetStrategy gets TargetStrategy, Tag 847 +func (m NewOrderSingle) GetTargetStrategy() (f field.TargetStrategyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTargetStrategyParameters gets TargetStrategyParameters, Tag 848 +func (m NewOrderSingle) GetTargetStrategyParameters() (f field.TargetStrategyParametersField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetParticipationRate gets ParticipationRate, Tag 849 +func (m NewOrderSingle) GetParticipationRate() (f field.ParticipationRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetQtyType gets QtyType, Tag 854 +func (m NewOrderSingle) GetQtyType() (f field.QtyTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoEvents gets NoEvents, Tag 864 +func (m NewOrderSingle) GetNoEvents() (NoEventsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoEventsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetDatedDate gets DatedDate, Tag 873 +func (m NewOrderSingle) GetDatedDate() (f field.DatedDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInterestAccrualDate gets InterestAccrualDate, Tag 874 +func (m NewOrderSingle) GetInterestAccrualDate() (f field.InterestAccrualDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCPProgram gets CPProgram, Tag 875 +func (m NewOrderSingle) GetCPProgram() (f field.CPProgramField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCPRegType gets CPRegType, Tag 876 +func (m NewOrderSingle) GetCPRegType() (f field.CPRegTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMarginRatio gets MarginRatio, Tag 898 +func (m NewOrderSingle) GetMarginRatio() (f field.MarginRatioField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementDesc gets AgreementDesc, Tag 913 +func (m NewOrderSingle) GetAgreementDesc() (f field.AgreementDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementID gets AgreementID, Tag 914 +func (m NewOrderSingle) GetAgreementID() (f field.AgreementIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementDate gets AgreementDate, Tag 915 +func (m NewOrderSingle) GetAgreementDate() (f field.AgreementDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStartDate gets StartDate, Tag 916 +func (m NewOrderSingle) GetStartDate() (f field.StartDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEndDate gets EndDate, Tag 917 +func (m NewOrderSingle) GetEndDate() (f field.EndDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementCurrency gets AgreementCurrency, Tag 918 +func (m NewOrderSingle) GetAgreementCurrency() (f field.AgreementCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDeliveryType gets DeliveryType, Tag 919 +func (m NewOrderSingle) GetDeliveryType() (f field.DeliveryTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikeCurrency gets StrikeCurrency, Tag 947 +func (m NewOrderSingle) GetStrikeCurrency() (f field.StrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasAccount returns true if Account is present, Tag 1 +func (m NewOrderSingle) HasAccount() bool { + return m.Has(tag.Account) +} + +//HasClOrdID returns true if ClOrdID is present, Tag 11 +func (m NewOrderSingle) HasClOrdID() bool { + return m.Has(tag.ClOrdID) +} + +//HasCommission returns true if Commission is present, Tag 12 +func (m NewOrderSingle) HasCommission() bool { + return m.Has(tag.Commission) +} + +//HasCommType returns true if CommType is present, Tag 13 +func (m NewOrderSingle) HasCommType() bool { + return m.Has(tag.CommType) +} + +//HasCurrency returns true if Currency is present, Tag 15 +func (m NewOrderSingle) HasCurrency() bool { + return m.Has(tag.Currency) +} + +//HasExecInst returns true if ExecInst is present, Tag 18 +func (m NewOrderSingle) HasExecInst() bool { + return m.Has(tag.ExecInst) +} + +//HasHandlInst returns true if HandlInst is present, Tag 21 +func (m NewOrderSingle) HasHandlInst() bool { + return m.Has(tag.HandlInst) +} + +//HasSecurityIDSource returns true if SecurityIDSource is present, Tag 22 +func (m NewOrderSingle) HasSecurityIDSource() bool { + return m.Has(tag.SecurityIDSource) +} + +//HasIOIID returns true if IOIID is present, Tag 23 +func (m NewOrderSingle) HasIOIID() bool { + return m.Has(tag.IOIID) +} + +//HasOrderQty returns true if OrderQty is present, Tag 38 +func (m NewOrderSingle) HasOrderQty() bool { + return m.Has(tag.OrderQty) +} + +//HasOrdType returns true if OrdType is present, Tag 40 +func (m NewOrderSingle) HasOrdType() bool { + return m.Has(tag.OrdType) +} + +//HasPrice returns true if Price is present, Tag 44 +func (m NewOrderSingle) HasPrice() bool { + return m.Has(tag.Price) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m NewOrderSingle) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSide returns true if Side is present, Tag 54 +func (m NewOrderSingle) HasSide() bool { + return m.Has(tag.Side) +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m NewOrderSingle) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasText returns true if Text is present, Tag 58 +func (m NewOrderSingle) HasText() bool { + return m.Has(tag.Text) +} + +//HasTimeInForce returns true if TimeInForce is present, Tag 59 +func (m NewOrderSingle) HasTimeInForce() bool { + return m.Has(tag.TimeInForce) +} + +//HasTransactTime returns true if TransactTime is present, Tag 60 +func (m NewOrderSingle) HasTransactTime() bool { + return m.Has(tag.TransactTime) +} + +//HasSettlType returns true if SettlType is present, Tag 63 +func (m NewOrderSingle) HasSettlType() bool { + return m.Has(tag.SettlType) +} + +//HasSettlDate returns true if SettlDate is present, Tag 64 +func (m NewOrderSingle) HasSettlDate() bool { + return m.Has(tag.SettlDate) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m NewOrderSingle) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasAllocID returns true if AllocID is present, Tag 70 +func (m NewOrderSingle) HasAllocID() bool { + return m.Has(tag.AllocID) +} + +//HasTradeDate returns true if TradeDate is present, Tag 75 +func (m NewOrderSingle) HasTradeDate() bool { + return m.Has(tag.TradeDate) +} + +//HasPositionEffect returns true if PositionEffect is present, Tag 77 +func (m NewOrderSingle) HasPositionEffect() bool { + return m.Has(tag.PositionEffect) +} + +//HasNoAllocs returns true if NoAllocs is present, Tag 78 +func (m NewOrderSingle) HasNoAllocs() bool { + return m.Has(tag.NoAllocs) +} + +//HasProcessCode returns true if ProcessCode is present, Tag 81 +func (m NewOrderSingle) HasProcessCode() bool { + return m.Has(tag.ProcessCode) +} + +//HasStopPx returns true if StopPx is present, Tag 99 +func (m NewOrderSingle) HasStopPx() bool { + return m.Has(tag.StopPx) +} + +//HasExDestination returns true if ExDestination is present, Tag 100 +func (m NewOrderSingle) HasExDestination() bool { + return m.Has(tag.ExDestination) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m NewOrderSingle) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m NewOrderSingle) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasMinQty returns true if MinQty is present, Tag 110 +func (m NewOrderSingle) HasMinQty() bool { + return m.Has(tag.MinQty) +} + +//HasMaxFloor returns true if MaxFloor is present, Tag 111 +func (m NewOrderSingle) HasMaxFloor() bool { + return m.Has(tag.MaxFloor) +} + +//HasLocateReqd returns true if LocateReqd is present, Tag 114 +func (m NewOrderSingle) HasLocateReqd() bool { + return m.Has(tag.LocateReqd) +} + +//HasQuoteID returns true if QuoteID is present, Tag 117 +func (m NewOrderSingle) HasQuoteID() bool { + return m.Has(tag.QuoteID) +} + +//HasSettlCurrency returns true if SettlCurrency is present, Tag 120 +func (m NewOrderSingle) HasSettlCurrency() bool { + return m.Has(tag.SettlCurrency) +} + +//HasForexReq returns true if ForexReq is present, Tag 121 +func (m NewOrderSingle) HasForexReq() bool { + return m.Has(tag.ForexReq) +} + +//HasExpireTime returns true if ExpireTime is present, Tag 126 +func (m NewOrderSingle) HasExpireTime() bool { + return m.Has(tag.ExpireTime) +} + +//HasPrevClosePx returns true if PrevClosePx is present, Tag 140 +func (m NewOrderSingle) HasPrevClosePx() bool { + return m.Has(tag.PrevClosePx) +} + +//HasCashOrderQty returns true if CashOrderQty is present, Tag 152 +func (m NewOrderSingle) HasCashOrderQty() bool { + return m.Has(tag.CashOrderQty) +} + +//HasSecurityType returns true if SecurityType is present, Tag 167 +func (m NewOrderSingle) HasSecurityType() bool { + return m.Has(tag.SecurityType) +} + +//HasEffectiveTime returns true if EffectiveTime is present, Tag 168 +func (m NewOrderSingle) HasEffectiveTime() bool { + return m.Has(tag.EffectiveTime) +} + +//HasOrderQty2 returns true if OrderQty2 is present, Tag 192 +func (m NewOrderSingle) HasOrderQty2() bool { + return m.Has(tag.OrderQty2) +} + +//HasSettlDate2 returns true if SettlDate2 is present, Tag 193 +func (m NewOrderSingle) HasSettlDate2() bool { + return m.Has(tag.SettlDate2) +} + +//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200 +func (m NewOrderSingle) HasMaturityMonthYear() bool { + return m.Has(tag.MaturityMonthYear) +} + +//HasStrikePrice returns true if StrikePrice is present, Tag 202 +func (m NewOrderSingle) HasStrikePrice() bool { + return m.Has(tag.StrikePrice) +} + +//HasCoveredOrUncovered returns true if CoveredOrUncovered is present, Tag 203 +func (m NewOrderSingle) HasCoveredOrUncovered() bool { + return m.Has(tag.CoveredOrUncovered) +} + +//HasOptAttribute returns true if OptAttribute is present, Tag 206 +func (m NewOrderSingle) HasOptAttribute() bool { + return m.Has(tag.OptAttribute) +} + +//HasSecurityExchange returns true if SecurityExchange is present, Tag 207 +func (m NewOrderSingle) HasSecurityExchange() bool { + return m.Has(tag.SecurityExchange) +} + +//HasMaxShow returns true if MaxShow is present, Tag 210 +func (m NewOrderSingle) HasMaxShow() bool { + return m.Has(tag.MaxShow) +} + +//HasPegOffsetValue returns true if PegOffsetValue is present, Tag 211 +func (m NewOrderSingle) HasPegOffsetValue() bool { + return m.Has(tag.PegOffsetValue) +} + +//HasSpread returns true if Spread is present, Tag 218 +func (m NewOrderSingle) HasSpread() bool { + return m.Has(tag.Spread) +} + +//HasBenchmarkCurveCurrency returns true if BenchmarkCurveCurrency is present, Tag 220 +func (m NewOrderSingle) HasBenchmarkCurveCurrency() bool { + return m.Has(tag.BenchmarkCurveCurrency) +} + +//HasBenchmarkCurveName returns true if BenchmarkCurveName is present, Tag 221 +func (m NewOrderSingle) HasBenchmarkCurveName() bool { + return m.Has(tag.BenchmarkCurveName) +} + +//HasBenchmarkCurvePoint returns true if BenchmarkCurvePoint is present, Tag 222 +func (m NewOrderSingle) HasBenchmarkCurvePoint() bool { + return m.Has(tag.BenchmarkCurvePoint) +} + +//HasCouponRate returns true if CouponRate is present, Tag 223 +func (m NewOrderSingle) HasCouponRate() bool { + return m.Has(tag.CouponRate) +} + +//HasCouponPaymentDate returns true if CouponPaymentDate is present, Tag 224 +func (m NewOrderSingle) HasCouponPaymentDate() bool { + return m.Has(tag.CouponPaymentDate) +} + +//HasIssueDate returns true if IssueDate is present, Tag 225 +func (m NewOrderSingle) HasIssueDate() bool { + return m.Has(tag.IssueDate) +} + +//HasRepurchaseTerm returns true if RepurchaseTerm is present, Tag 226 +func (m NewOrderSingle) HasRepurchaseTerm() bool { + return m.Has(tag.RepurchaseTerm) +} + +//HasRepurchaseRate returns true if RepurchaseRate is present, Tag 227 +func (m NewOrderSingle) HasRepurchaseRate() bool { + return m.Has(tag.RepurchaseRate) +} + +//HasFactor returns true if Factor is present, Tag 228 +func (m NewOrderSingle) HasFactor() bool { + return m.Has(tag.Factor) +} + +//HasTradeOriginationDate returns true if TradeOriginationDate is present, Tag 229 +func (m NewOrderSingle) HasTradeOriginationDate() bool { + return m.Has(tag.TradeOriginationDate) +} + +//HasContractMultiplier returns true if ContractMultiplier is present, Tag 231 +func (m NewOrderSingle) HasContractMultiplier() bool { + return m.Has(tag.ContractMultiplier) +} + +//HasNoStipulations returns true if NoStipulations is present, Tag 232 +func (m NewOrderSingle) HasNoStipulations() bool { + return m.Has(tag.NoStipulations) +} + +//HasYieldType returns true if YieldType is present, Tag 235 +func (m NewOrderSingle) HasYieldType() bool { + return m.Has(tag.YieldType) +} + +//HasYield returns true if Yield is present, Tag 236 +func (m NewOrderSingle) HasYield() bool { + return m.Has(tag.Yield) +} + +//HasRepoCollateralSecurityType returns true if RepoCollateralSecurityType is present, Tag 239 +func (m NewOrderSingle) HasRepoCollateralSecurityType() bool { + return m.Has(tag.RepoCollateralSecurityType) +} + +//HasRedemptionDate returns true if RedemptionDate is present, Tag 240 +func (m NewOrderSingle) HasRedemptionDate() bool { + return m.Has(tag.RedemptionDate) +} + +//HasCreditRating returns true if CreditRating is present, Tag 255 +func (m NewOrderSingle) HasCreditRating() bool { + return m.Has(tag.CreditRating) +} + +//HasEncodedIssuerLen returns true if EncodedIssuerLen is present, Tag 348 +func (m NewOrderSingle) HasEncodedIssuerLen() bool { + return m.Has(tag.EncodedIssuerLen) +} + +//HasEncodedIssuer returns true if EncodedIssuer is present, Tag 349 +func (m NewOrderSingle) HasEncodedIssuer() bool { + return m.Has(tag.EncodedIssuer) +} + +//HasEncodedSecurityDescLen returns true if EncodedSecurityDescLen is present, Tag 350 +func (m NewOrderSingle) HasEncodedSecurityDescLen() bool { + return m.Has(tag.EncodedSecurityDescLen) +} + +//HasEncodedSecurityDesc returns true if EncodedSecurityDesc is present, Tag 351 +func (m NewOrderSingle) HasEncodedSecurityDesc() bool { + return m.Has(tag.EncodedSecurityDesc) +} + +//HasEncodedTextLen returns true if EncodedTextLen is present, Tag 354 +func (m NewOrderSingle) HasEncodedTextLen() bool { + return m.Has(tag.EncodedTextLen) +} + +//HasEncodedText returns true if EncodedText is present, Tag 355 +func (m NewOrderSingle) HasEncodedText() bool { + return m.Has(tag.EncodedText) +} + +//HasComplianceID returns true if ComplianceID is present, Tag 376 +func (m NewOrderSingle) HasComplianceID() bool { + return m.Has(tag.ComplianceID) +} + +//HasSolicitedFlag returns true if SolicitedFlag is present, Tag 377 +func (m NewOrderSingle) HasSolicitedFlag() bool { + return m.Has(tag.SolicitedFlag) +} + +//HasNoTradingSessions returns true if NoTradingSessions is present, Tag 386 +func (m NewOrderSingle) HasNoTradingSessions() bool { + return m.Has(tag.NoTradingSessions) +} + +//HasDiscretionInst returns true if DiscretionInst is present, Tag 388 +func (m NewOrderSingle) HasDiscretionInst() bool { + return m.Has(tag.DiscretionInst) +} + +//HasDiscretionOffsetValue returns true if DiscretionOffsetValue is present, Tag 389 +func (m NewOrderSingle) HasDiscretionOffsetValue() bool { + return m.Has(tag.DiscretionOffsetValue) +} + +//HasPriceType returns true if PriceType is present, Tag 423 +func (m NewOrderSingle) HasPriceType() bool { + return m.Has(tag.PriceType) +} + +//HasGTBookingInst returns true if GTBookingInst is present, Tag 427 +func (m NewOrderSingle) HasGTBookingInst() bool { + return m.Has(tag.GTBookingInst) +} + +//HasExpireDate returns true if ExpireDate is present, Tag 432 +func (m NewOrderSingle) HasExpireDate() bool { + return m.Has(tag.ExpireDate) +} + +//HasNoPartyIDs returns true if NoPartyIDs is present, Tag 453 +func (m NewOrderSingle) HasNoPartyIDs() bool { + return m.Has(tag.NoPartyIDs) +} + +//HasNoSecurityAltID returns true if NoSecurityAltID is present, Tag 454 +func (m NewOrderSingle) HasNoSecurityAltID() bool { + return m.Has(tag.NoSecurityAltID) +} + +//HasProduct returns true if Product is present, Tag 460 +func (m NewOrderSingle) HasProduct() bool { + return m.Has(tag.Product) +} + +//HasCFICode returns true if CFICode is present, Tag 461 +func (m NewOrderSingle) HasCFICode() bool { + return m.Has(tag.CFICode) +} + +//HasRoundingDirection returns true if RoundingDirection is present, Tag 468 +func (m NewOrderSingle) HasRoundingDirection() bool { + return m.Has(tag.RoundingDirection) +} + +//HasRoundingModulus returns true if RoundingModulus is present, Tag 469 +func (m NewOrderSingle) HasRoundingModulus() bool { + return m.Has(tag.RoundingModulus) +} + +//HasCountryOfIssue returns true if CountryOfIssue is present, Tag 470 +func (m NewOrderSingle) HasCountryOfIssue() bool { + return m.Has(tag.CountryOfIssue) +} + +//HasStateOrProvinceOfIssue returns true if StateOrProvinceOfIssue is present, Tag 471 +func (m NewOrderSingle) HasStateOrProvinceOfIssue() bool { + return m.Has(tag.StateOrProvinceOfIssue) +} + +//HasLocaleOfIssue returns true if LocaleOfIssue is present, Tag 472 +func (m NewOrderSingle) HasLocaleOfIssue() bool { + return m.Has(tag.LocaleOfIssue) +} + +//HasCommCurrency returns true if CommCurrency is present, Tag 479 +func (m NewOrderSingle) HasCommCurrency() bool { + return m.Has(tag.CommCurrency) +} + +//HasCancellationRights returns true if CancellationRights is present, Tag 480 +func (m NewOrderSingle) HasCancellationRights() bool { + return m.Has(tag.CancellationRights) +} + +//HasMoneyLaunderingStatus returns true if MoneyLaunderingStatus is present, Tag 481 +func (m NewOrderSingle) HasMoneyLaunderingStatus() bool { + return m.Has(tag.MoneyLaunderingStatus) +} + +//HasDesignation returns true if Designation is present, Tag 494 +func (m NewOrderSingle) HasDesignation() bool { + return m.Has(tag.Designation) +} + +//HasFundRenewWaiv returns true if FundRenewWaiv is present, Tag 497 +func (m NewOrderSingle) HasFundRenewWaiv() bool { + return m.Has(tag.FundRenewWaiv) +} + +//HasRegistID returns true if RegistID is present, Tag 513 +func (m NewOrderSingle) HasRegistID() bool { + return m.Has(tag.RegistID) +} + +//HasOrderPercent returns true if OrderPercent is present, Tag 516 +func (m NewOrderSingle) HasOrderPercent() bool { + return m.Has(tag.OrderPercent) +} + +//HasSecondaryClOrdID returns true if SecondaryClOrdID is present, Tag 526 +func (m NewOrderSingle) HasSecondaryClOrdID() bool { + return m.Has(tag.SecondaryClOrdID) +} + +//HasOrderCapacity returns true if OrderCapacity is present, Tag 528 +func (m NewOrderSingle) HasOrderCapacity() bool { + return m.Has(tag.OrderCapacity) +} + +//HasOrderRestrictions returns true if OrderRestrictions is present, Tag 529 +func (m NewOrderSingle) HasOrderRestrictions() bool { + return m.Has(tag.OrderRestrictions) +} + +//HasMaturityDate returns true if MaturityDate is present, Tag 541 +func (m NewOrderSingle) HasMaturityDate() bool { + return m.Has(tag.MaturityDate) +} + +//HasInstrRegistry returns true if InstrRegistry is present, Tag 543 +func (m NewOrderSingle) HasInstrRegistry() bool { + return m.Has(tag.InstrRegistry) +} + +//HasCashMargin returns true if CashMargin is present, Tag 544 +func (m NewOrderSingle) HasCashMargin() bool { + return m.Has(tag.CashMargin) +} + +//HasAccountType returns true if AccountType is present, Tag 581 +func (m NewOrderSingle) HasAccountType() bool { + return m.Has(tag.AccountType) +} + +//HasCustOrderCapacity returns true if CustOrderCapacity is present, Tag 582 +func (m NewOrderSingle) HasCustOrderCapacity() bool { + return m.Has(tag.CustOrderCapacity) +} + +//HasClOrdLinkID returns true if ClOrdLinkID is present, Tag 583 +func (m NewOrderSingle) HasClOrdLinkID() bool { + return m.Has(tag.ClOrdLinkID) +} + +//HasDayBookingInst returns true if DayBookingInst is present, Tag 589 +func (m NewOrderSingle) HasDayBookingInst() bool { + return m.Has(tag.DayBookingInst) +} + +//HasBookingUnit returns true if BookingUnit is present, Tag 590 +func (m NewOrderSingle) HasBookingUnit() bool { + return m.Has(tag.BookingUnit) +} + +//HasPreallocMethod returns true if PreallocMethod is present, Tag 591 +func (m NewOrderSingle) HasPreallocMethod() bool { + return m.Has(tag.PreallocMethod) +} + +//HasClearingFeeIndicator returns true if ClearingFeeIndicator is present, Tag 635 +func (m NewOrderSingle) HasClearingFeeIndicator() bool { + return m.Has(tag.ClearingFeeIndicator) +} + +//HasPrice2 returns true if Price2 is present, Tag 640 +func (m NewOrderSingle) HasPrice2() bool { + return m.Has(tag.Price2) +} + +//HasAcctIDSource returns true if AcctIDSource is present, Tag 660 +func (m NewOrderSingle) HasAcctIDSource() bool { + return m.Has(tag.AcctIDSource) +} + +//HasBenchmarkPrice returns true if BenchmarkPrice is present, Tag 662 +func (m NewOrderSingle) HasBenchmarkPrice() bool { + return m.Has(tag.BenchmarkPrice) +} + +//HasBenchmarkPriceType returns true if BenchmarkPriceType is present, Tag 663 +func (m NewOrderSingle) HasBenchmarkPriceType() bool { + return m.Has(tag.BenchmarkPriceType) +} + +//HasContractSettlMonth returns true if ContractSettlMonth is present, Tag 667 +func (m NewOrderSingle) HasContractSettlMonth() bool { + return m.Has(tag.ContractSettlMonth) +} + +//HasPool returns true if Pool is present, Tag 691 +func (m NewOrderSingle) HasPool() bool { + return m.Has(tag.Pool) +} + +//HasYieldRedemptionDate returns true if YieldRedemptionDate is present, Tag 696 +func (m NewOrderSingle) HasYieldRedemptionDate() bool { + return m.Has(tag.YieldRedemptionDate) +} + +//HasYieldRedemptionPrice returns true if YieldRedemptionPrice is present, Tag 697 +func (m NewOrderSingle) HasYieldRedemptionPrice() bool { + return m.Has(tag.YieldRedemptionPrice) +} + +//HasYieldRedemptionPriceType returns true if YieldRedemptionPriceType is present, Tag 698 +func (m NewOrderSingle) HasYieldRedemptionPriceType() bool { + return m.Has(tag.YieldRedemptionPriceType) +} + +//HasBenchmarkSecurityID returns true if BenchmarkSecurityID is present, Tag 699 +func (m NewOrderSingle) HasBenchmarkSecurityID() bool { + return m.Has(tag.BenchmarkSecurityID) +} + +//HasYieldCalcDate returns true if YieldCalcDate is present, Tag 701 +func (m NewOrderSingle) HasYieldCalcDate() bool { + return m.Has(tag.YieldCalcDate) +} + +//HasNoUnderlyings returns true if NoUnderlyings is present, Tag 711 +func (m NewOrderSingle) HasNoUnderlyings() bool { + return m.Has(tag.NoUnderlyings) +} + +//HasBenchmarkSecurityIDSource returns true if BenchmarkSecurityIDSource is present, Tag 761 +func (m NewOrderSingle) HasBenchmarkSecurityIDSource() bool { + return m.Has(tag.BenchmarkSecurityIDSource) +} + +//HasSecuritySubType returns true if SecuritySubType is present, Tag 762 +func (m NewOrderSingle) HasSecuritySubType() bool { + return m.Has(tag.SecuritySubType) +} + +//HasBookingType returns true if BookingType is present, Tag 775 +func (m NewOrderSingle) HasBookingType() bool { + return m.Has(tag.BookingType) +} + +//HasTerminationType returns true if TerminationType is present, Tag 788 +func (m NewOrderSingle) HasTerminationType() bool { + return m.Has(tag.TerminationType) +} + +//HasPegMoveType returns true if PegMoveType is present, Tag 835 +func (m NewOrderSingle) HasPegMoveType() bool { + return m.Has(tag.PegMoveType) +} + +//HasPegOffsetType returns true if PegOffsetType is present, Tag 836 +func (m NewOrderSingle) HasPegOffsetType() bool { + return m.Has(tag.PegOffsetType) +} + +//HasPegLimitType returns true if PegLimitType is present, Tag 837 +func (m NewOrderSingle) HasPegLimitType() bool { + return m.Has(tag.PegLimitType) +} + +//HasPegRoundDirection returns true if PegRoundDirection is present, Tag 838 +func (m NewOrderSingle) HasPegRoundDirection() bool { + return m.Has(tag.PegRoundDirection) +} + +//HasPegScope returns true if PegScope is present, Tag 840 +func (m NewOrderSingle) HasPegScope() bool { + return m.Has(tag.PegScope) +} + +//HasDiscretionMoveType returns true if DiscretionMoveType is present, Tag 841 +func (m NewOrderSingle) HasDiscretionMoveType() bool { + return m.Has(tag.DiscretionMoveType) +} + +//HasDiscretionOffsetType returns true if DiscretionOffsetType is present, Tag 842 +func (m NewOrderSingle) HasDiscretionOffsetType() bool { + return m.Has(tag.DiscretionOffsetType) +} + +//HasDiscretionLimitType returns true if DiscretionLimitType is present, Tag 843 +func (m NewOrderSingle) HasDiscretionLimitType() bool { + return m.Has(tag.DiscretionLimitType) +} + +//HasDiscretionRoundDirection returns true if DiscretionRoundDirection is present, Tag 844 +func (m NewOrderSingle) HasDiscretionRoundDirection() bool { + return m.Has(tag.DiscretionRoundDirection) +} + +//HasDiscretionScope returns true if DiscretionScope is present, Tag 846 +func (m NewOrderSingle) HasDiscretionScope() bool { + return m.Has(tag.DiscretionScope) +} + +//HasTargetStrategy returns true if TargetStrategy is present, Tag 847 +func (m NewOrderSingle) HasTargetStrategy() bool { + return m.Has(tag.TargetStrategy) +} + +//HasTargetStrategyParameters returns true if TargetStrategyParameters is present, Tag 848 +func (m NewOrderSingle) HasTargetStrategyParameters() bool { + return m.Has(tag.TargetStrategyParameters) +} + +//HasParticipationRate returns true if ParticipationRate is present, Tag 849 +func (m NewOrderSingle) HasParticipationRate() bool { + return m.Has(tag.ParticipationRate) +} + +//HasQtyType returns true if QtyType is present, Tag 854 +func (m NewOrderSingle) HasQtyType() bool { + return m.Has(tag.QtyType) +} + +//HasNoEvents returns true if NoEvents is present, Tag 864 +func (m NewOrderSingle) HasNoEvents() bool { + return m.Has(tag.NoEvents) +} + +//HasDatedDate returns true if DatedDate is present, Tag 873 +func (m NewOrderSingle) HasDatedDate() bool { + return m.Has(tag.DatedDate) +} + +//HasInterestAccrualDate returns true if InterestAccrualDate is present, Tag 874 +func (m NewOrderSingle) HasInterestAccrualDate() bool { + return m.Has(tag.InterestAccrualDate) +} + +//HasCPProgram returns true if CPProgram is present, Tag 875 +func (m NewOrderSingle) HasCPProgram() bool { + return m.Has(tag.CPProgram) +} + +//HasCPRegType returns true if CPRegType is present, Tag 876 +func (m NewOrderSingle) HasCPRegType() bool { + return m.Has(tag.CPRegType) +} + +//HasMarginRatio returns true if MarginRatio is present, Tag 898 +func (m NewOrderSingle) HasMarginRatio() bool { + return m.Has(tag.MarginRatio) +} + +//HasAgreementDesc returns true if AgreementDesc is present, Tag 913 +func (m NewOrderSingle) HasAgreementDesc() bool { + return m.Has(tag.AgreementDesc) +} + +//HasAgreementID returns true if AgreementID is present, Tag 914 +func (m NewOrderSingle) HasAgreementID() bool { + return m.Has(tag.AgreementID) +} + +//HasAgreementDate returns true if AgreementDate is present, Tag 915 +func (m NewOrderSingle) HasAgreementDate() bool { + return m.Has(tag.AgreementDate) +} + +//HasStartDate returns true if StartDate is present, Tag 916 +func (m NewOrderSingle) HasStartDate() bool { + return m.Has(tag.StartDate) +} + +//HasEndDate returns true if EndDate is present, Tag 917 +func (m NewOrderSingle) HasEndDate() bool { + return m.Has(tag.EndDate) +} + +//HasAgreementCurrency returns true if AgreementCurrency is present, Tag 918 +func (m NewOrderSingle) HasAgreementCurrency() bool { + return m.Has(tag.AgreementCurrency) +} + +//HasDeliveryType returns true if DeliveryType is present, Tag 919 +func (m NewOrderSingle) HasDeliveryType() bool { + return m.Has(tag.DeliveryType) +} + +//HasStrikeCurrency returns true if StrikeCurrency is present, Tag 947 +func (m NewOrderSingle) HasStrikeCurrency() bool { + return m.Has(tag.StrikeCurrency) +} + +//NoAllocs is a repeating group element, Tag 78 +type NoAllocs struct { + quickfix.Group +} + +//SetAllocAccount sets AllocAccount, Tag 79 +func (m NoAllocs) SetAllocAccount(v string) { + m.Set(field.NewAllocAccount(v)) +} + +//SetAllocAcctIDSource sets AllocAcctIDSource, Tag 661 +func (m NoAllocs) SetAllocAcctIDSource(v int) { + m.Set(field.NewAllocAcctIDSource(v)) +} + +//SetAllocSettlCurrency sets AllocSettlCurrency, Tag 736 +func (m NoAllocs) SetAllocSettlCurrency(v string) { + m.Set(field.NewAllocSettlCurrency(v)) +} + +//SetIndividualAllocID sets IndividualAllocID, Tag 467 +func (m NoAllocs) SetIndividualAllocID(v string) { + m.Set(field.NewIndividualAllocID(v)) +} + +//SetNoNestedPartyIDs sets NoNestedPartyIDs, Tag 539 +func (m NoAllocs) SetNoNestedPartyIDs(f NoNestedPartyIDsRepeatingGroup) { + m.SetGroup(f) +} + +//SetAllocQty sets AllocQty, Tag 80 +func (m NoAllocs) SetAllocQty(v float64) { + m.Set(field.NewAllocQty(v)) +} + +//GetAllocAccount gets AllocAccount, Tag 79 +func (m NoAllocs) GetAllocAccount() (f field.AllocAccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAllocAcctIDSource gets AllocAcctIDSource, Tag 661 +func (m NoAllocs) GetAllocAcctIDSource() (f field.AllocAcctIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAllocSettlCurrency gets AllocSettlCurrency, Tag 736 +func (m NoAllocs) GetAllocSettlCurrency() (f field.AllocSettlCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIndividualAllocID gets IndividualAllocID, Tag 467 +func (m NoAllocs) GetIndividualAllocID() (f field.IndividualAllocIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoNestedPartyIDs gets NoNestedPartyIDs, Tag 539 +func (m NoAllocs) GetNoNestedPartyIDs() (NoNestedPartyIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoNestedPartyIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetAllocQty gets AllocQty, Tag 80 +func (m NoAllocs) GetAllocQty() (f field.AllocQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasAllocAccount returns true if AllocAccount is present, Tag 79 +func (m NoAllocs) HasAllocAccount() bool { + return m.Has(tag.AllocAccount) +} + +//HasAllocAcctIDSource returns true if AllocAcctIDSource is present, Tag 661 +func (m NoAllocs) HasAllocAcctIDSource() bool { + return m.Has(tag.AllocAcctIDSource) +} + +//HasAllocSettlCurrency returns true if AllocSettlCurrency is present, Tag 736 +func (m NoAllocs) HasAllocSettlCurrency() bool { + return m.Has(tag.AllocSettlCurrency) +} + +//HasIndividualAllocID returns true if IndividualAllocID is present, Tag 467 +func (m NoAllocs) HasIndividualAllocID() bool { + return m.Has(tag.IndividualAllocID) +} + +//HasNoNestedPartyIDs returns true if NoNestedPartyIDs is present, Tag 539 +func (m NoAllocs) HasNoNestedPartyIDs() bool { + return m.Has(tag.NoNestedPartyIDs) +} + +//HasAllocQty returns true if AllocQty is present, Tag 80 +func (m NoAllocs) HasAllocQty() bool { + return m.Has(tag.AllocQty) +} + +//NoNestedPartyIDs is a repeating group element, Tag 539 +type NoNestedPartyIDs struct { + quickfix.Group +} + +//SetNestedPartyID sets NestedPartyID, Tag 524 +func (m NoNestedPartyIDs) SetNestedPartyID(v string) { + m.Set(field.NewNestedPartyID(v)) +} + +//SetNestedPartyIDSource sets NestedPartyIDSource, Tag 525 +func (m NoNestedPartyIDs) SetNestedPartyIDSource(v string) { + m.Set(field.NewNestedPartyIDSource(v)) +} + +//SetNestedPartyRole sets NestedPartyRole, Tag 538 +func (m NoNestedPartyIDs) SetNestedPartyRole(v int) { + m.Set(field.NewNestedPartyRole(v)) +} + +//SetNoNestedPartySubIDs sets NoNestedPartySubIDs, Tag 804 +func (m NoNestedPartyIDs) SetNoNestedPartySubIDs(f NoNestedPartySubIDsRepeatingGroup) { + m.SetGroup(f) +} + +//GetNestedPartyID gets NestedPartyID, Tag 524 +func (m NoNestedPartyIDs) GetNestedPartyID() (f field.NestedPartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNestedPartyIDSource gets NestedPartyIDSource, Tag 525 +func (m NoNestedPartyIDs) GetNestedPartyIDSource() (f field.NestedPartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNestedPartyRole gets NestedPartyRole, Tag 538 +func (m NoNestedPartyIDs) GetNestedPartyRole() (f field.NestedPartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoNestedPartySubIDs gets NoNestedPartySubIDs, Tag 804 +func (m NoNestedPartyIDs) GetNoNestedPartySubIDs() (NoNestedPartySubIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoNestedPartySubIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasNestedPartyID returns true if NestedPartyID is present, Tag 524 +func (m NoNestedPartyIDs) HasNestedPartyID() bool { + return m.Has(tag.NestedPartyID) +} + +//HasNestedPartyIDSource returns true if NestedPartyIDSource is present, Tag 525 +func (m NoNestedPartyIDs) HasNestedPartyIDSource() bool { + return m.Has(tag.NestedPartyIDSource) +} + +//HasNestedPartyRole returns true if NestedPartyRole is present, Tag 538 +func (m NoNestedPartyIDs) HasNestedPartyRole() bool { + return m.Has(tag.NestedPartyRole) +} + +//HasNoNestedPartySubIDs returns true if NoNestedPartySubIDs is present, Tag 804 +func (m NoNestedPartyIDs) HasNoNestedPartySubIDs() bool { + return m.Has(tag.NoNestedPartySubIDs) +} + +//NoNestedPartySubIDs is a repeating group element, Tag 804 +type NoNestedPartySubIDs struct { + quickfix.Group +} + +//SetNestedPartySubID sets NestedPartySubID, Tag 545 +func (m NoNestedPartySubIDs) SetNestedPartySubID(v string) { + m.Set(field.NewNestedPartySubID(v)) +} + +//SetNestedPartySubIDType sets NestedPartySubIDType, Tag 805 +func (m NoNestedPartySubIDs) SetNestedPartySubIDType(v int) { + m.Set(field.NewNestedPartySubIDType(v)) +} + +//GetNestedPartySubID gets NestedPartySubID, Tag 545 +func (m NoNestedPartySubIDs) GetNestedPartySubID() (f field.NestedPartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNestedPartySubIDType gets NestedPartySubIDType, Tag 805 +func (m NoNestedPartySubIDs) GetNestedPartySubIDType() (f field.NestedPartySubIDTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasNestedPartySubID returns true if NestedPartySubID is present, Tag 545 +func (m NoNestedPartySubIDs) HasNestedPartySubID() bool { + return m.Has(tag.NestedPartySubID) +} + +//HasNestedPartySubIDType returns true if NestedPartySubIDType is present, Tag 805 +func (m NoNestedPartySubIDs) HasNestedPartySubIDType() bool { + return m.Has(tag.NestedPartySubIDType) +} + +//NoNestedPartySubIDsRepeatingGroup is a repeating group, Tag 804 +type NoNestedPartySubIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoNestedPartySubIDsRepeatingGroup returns an initialized, NoNestedPartySubIDsRepeatingGroup +func NewNoNestedPartySubIDsRepeatingGroup() NoNestedPartySubIDsRepeatingGroup { + return NoNestedPartySubIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoNestedPartySubIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.NestedPartySubID), quickfix.GroupElement(tag.NestedPartySubIDType)})} +} + +//Add create and append a new NoNestedPartySubIDs to this group +func (m NoNestedPartySubIDsRepeatingGroup) Add() NoNestedPartySubIDs { + g := m.RepeatingGroup.Add() + return NoNestedPartySubIDs{g} +} + +//Get returns the ith NoNestedPartySubIDs in the NoNestedPartySubIDsRepeatinGroup +func (m NoNestedPartySubIDsRepeatingGroup) Get(i int) NoNestedPartySubIDs { + return NoNestedPartySubIDs{m.RepeatingGroup.Get(i)} +} + +//NoNestedPartyIDsRepeatingGroup is a repeating group, Tag 539 +type NoNestedPartyIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoNestedPartyIDsRepeatingGroup returns an initialized, NoNestedPartyIDsRepeatingGroup +func NewNoNestedPartyIDsRepeatingGroup() NoNestedPartyIDsRepeatingGroup { + return NoNestedPartyIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoNestedPartyIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.NestedPartyID), quickfix.GroupElement(tag.NestedPartyIDSource), quickfix.GroupElement(tag.NestedPartyRole), NewNoNestedPartySubIDsRepeatingGroup()})} +} + +//Add create and append a new NoNestedPartyIDs to this group +func (m NoNestedPartyIDsRepeatingGroup) Add() NoNestedPartyIDs { + g := m.RepeatingGroup.Add() + return NoNestedPartyIDs{g} +} + +//Get returns the ith NoNestedPartyIDs in the NoNestedPartyIDsRepeatinGroup +func (m NoNestedPartyIDsRepeatingGroup) Get(i int) NoNestedPartyIDs { + return NoNestedPartyIDs{m.RepeatingGroup.Get(i)} +} + +//NoAllocsRepeatingGroup is a repeating group, Tag 78 +type NoAllocsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoAllocsRepeatingGroup returns an initialized, NoAllocsRepeatingGroup +func NewNoAllocsRepeatingGroup() NoAllocsRepeatingGroup { + return NoAllocsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoAllocs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.AllocAccount), quickfix.GroupElement(tag.AllocAcctIDSource), quickfix.GroupElement(tag.AllocSettlCurrency), quickfix.GroupElement(tag.IndividualAllocID), NewNoNestedPartyIDsRepeatingGroup(), quickfix.GroupElement(tag.AllocQty)})} +} + +//Add create and append a new NoAllocs to this group +func (m NoAllocsRepeatingGroup) Add() NoAllocs { + g := m.RepeatingGroup.Add() + return NoAllocs{g} +} + +//Get returns the ith NoAllocs in the NoAllocsRepeatinGroup +func (m NoAllocsRepeatingGroup) Get(i int) NoAllocs { + return NoAllocs{m.RepeatingGroup.Get(i)} +} + +//NoStipulations is a repeating group element, Tag 232 +type NoStipulations struct { + quickfix.Group +} + +//SetStipulationType sets StipulationType, Tag 233 +func (m NoStipulations) SetStipulationType(v string) { + m.Set(field.NewStipulationType(v)) +} + +//SetStipulationValue sets StipulationValue, Tag 234 +func (m NoStipulations) SetStipulationValue(v string) { + m.Set(field.NewStipulationValue(v)) +} + +//GetStipulationType gets StipulationType, Tag 233 +func (m NoStipulations) GetStipulationType() (f field.StipulationTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStipulationValue gets StipulationValue, Tag 234 +func (m NoStipulations) GetStipulationValue() (f field.StipulationValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasStipulationType returns true if StipulationType is present, Tag 233 +func (m NoStipulations) HasStipulationType() bool { + return m.Has(tag.StipulationType) +} + +//HasStipulationValue returns true if StipulationValue is present, Tag 234 +func (m NoStipulations) HasStipulationValue() bool { + return m.Has(tag.StipulationValue) +} + +//NoStipulationsRepeatingGroup is a repeating group, Tag 232 +type NoStipulationsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoStipulationsRepeatingGroup returns an initialized, NoStipulationsRepeatingGroup +func NewNoStipulationsRepeatingGroup() NoStipulationsRepeatingGroup { + return NoStipulationsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoStipulations, + quickfix.GroupTemplate{quickfix.GroupElement(tag.StipulationType), quickfix.GroupElement(tag.StipulationValue)})} +} + +//Add create and append a new NoStipulations to this group +func (m NoStipulationsRepeatingGroup) Add() NoStipulations { + g := m.RepeatingGroup.Add() + return NoStipulations{g} +} + +//Get returns the ith NoStipulations in the NoStipulationsRepeatinGroup +func (m NoStipulationsRepeatingGroup) Get(i int) NoStipulations { + return NoStipulations{m.RepeatingGroup.Get(i)} +} + +//NoTradingSessions is a repeating group element, Tag 386 +type NoTradingSessions struct { + quickfix.Group +} + +//SetTradingSessionID sets TradingSessionID, Tag 336 +func (m NoTradingSessions) SetTradingSessionID(v string) { + m.Set(field.NewTradingSessionID(v)) +} + +//SetTradingSessionSubID sets TradingSessionSubID, Tag 625 +func (m NoTradingSessions) SetTradingSessionSubID(v string) { + m.Set(field.NewTradingSessionSubID(v)) +} + +//GetTradingSessionID gets TradingSessionID, Tag 336 +func (m NoTradingSessions) GetTradingSessionID() (f field.TradingSessionIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradingSessionSubID gets TradingSessionSubID, Tag 625 +func (m NoTradingSessions) GetTradingSessionSubID() (f field.TradingSessionSubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasTradingSessionID returns true if TradingSessionID is present, Tag 336 +func (m NoTradingSessions) HasTradingSessionID() bool { + return m.Has(tag.TradingSessionID) +} + +//HasTradingSessionSubID returns true if TradingSessionSubID is present, Tag 625 +func (m NoTradingSessions) HasTradingSessionSubID() bool { + return m.Has(tag.TradingSessionSubID) +} + +//NoTradingSessionsRepeatingGroup is a repeating group, Tag 386 +type NoTradingSessionsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoTradingSessionsRepeatingGroup returns an initialized, NoTradingSessionsRepeatingGroup +func NewNoTradingSessionsRepeatingGroup() NoTradingSessionsRepeatingGroup { + return NoTradingSessionsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoTradingSessions, + quickfix.GroupTemplate{quickfix.GroupElement(tag.TradingSessionID), quickfix.GroupElement(tag.TradingSessionSubID)})} +} + +//Add create and append a new NoTradingSessions to this group +func (m NoTradingSessionsRepeatingGroup) Add() NoTradingSessions { + g := m.RepeatingGroup.Add() + return NoTradingSessions{g} +} + +//Get returns the ith NoTradingSessions in the NoTradingSessionsRepeatinGroup +func (m NoTradingSessionsRepeatingGroup) Get(i int) NoTradingSessions { + return NoTradingSessions{m.RepeatingGroup.Get(i)} +} + +//NoPartyIDs is a repeating group element, Tag 453 +type NoPartyIDs struct { + quickfix.Group +} + +//SetPartyID sets PartyID, Tag 448 +func (m NoPartyIDs) SetPartyID(v string) { + m.Set(field.NewPartyID(v)) +} + +//SetPartyIDSource sets PartyIDSource, Tag 447 +func (m NoPartyIDs) SetPartyIDSource(v string) { + m.Set(field.NewPartyIDSource(v)) +} + +//SetPartyRole sets PartyRole, Tag 452 +func (m NoPartyIDs) SetPartyRole(v int) { + m.Set(field.NewPartyRole(v)) +} + +//SetNoPartySubIDs sets NoPartySubIDs, Tag 802 +func (m NoPartyIDs) SetNoPartySubIDs(f NoPartySubIDsRepeatingGroup) { + m.SetGroup(f) +} + +//GetPartyID gets PartyID, Tag 448 +func (m NoPartyIDs) GetPartyID() (f field.PartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartyIDSource gets PartyIDSource, Tag 447 +func (m NoPartyIDs) GetPartyIDSource() (f field.PartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartyRole gets PartyRole, Tag 452 +func (m NoPartyIDs) GetPartyRole() (f field.PartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoPartySubIDs gets NoPartySubIDs, Tag 802 +func (m NoPartyIDs) GetNoPartySubIDs() (NoPartySubIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoPartySubIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasPartyID returns true if PartyID is present, Tag 448 +func (m NoPartyIDs) HasPartyID() bool { + return m.Has(tag.PartyID) +} + +//HasPartyIDSource returns true if PartyIDSource is present, Tag 447 +func (m NoPartyIDs) HasPartyIDSource() bool { + return m.Has(tag.PartyIDSource) +} + +//HasPartyRole returns true if PartyRole is present, Tag 452 +func (m NoPartyIDs) HasPartyRole() bool { + return m.Has(tag.PartyRole) +} + +//HasNoPartySubIDs returns true if NoPartySubIDs is present, Tag 802 +func (m NoPartyIDs) HasNoPartySubIDs() bool { + return m.Has(tag.NoPartySubIDs) +} + +//NoPartySubIDs is a repeating group element, Tag 802 +type NoPartySubIDs struct { + quickfix.Group +} + +//SetPartySubID sets PartySubID, Tag 523 +func (m NoPartySubIDs) SetPartySubID(v string) { + m.Set(field.NewPartySubID(v)) +} + +//SetPartySubIDType sets PartySubIDType, Tag 803 +func (m NoPartySubIDs) SetPartySubIDType(v int) { + m.Set(field.NewPartySubIDType(v)) +} + +//GetPartySubID gets PartySubID, Tag 523 +func (m NoPartySubIDs) GetPartySubID() (f field.PartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartySubIDType gets PartySubIDType, Tag 803 +func (m NoPartySubIDs) GetPartySubIDType() (f field.PartySubIDTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasPartySubID returns true if PartySubID is present, Tag 523 +func (m NoPartySubIDs) HasPartySubID() bool { + return m.Has(tag.PartySubID) +} + +//HasPartySubIDType returns true if PartySubIDType is present, Tag 803 +func (m NoPartySubIDs) HasPartySubIDType() bool { + return m.Has(tag.PartySubIDType) +} + +//NoPartySubIDsRepeatingGroup is a repeating group, Tag 802 +type NoPartySubIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoPartySubIDsRepeatingGroup returns an initialized, NoPartySubIDsRepeatingGroup +func NewNoPartySubIDsRepeatingGroup() NoPartySubIDsRepeatingGroup { + return NoPartySubIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoPartySubIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.PartySubID), quickfix.GroupElement(tag.PartySubIDType)})} +} + +//Add create and append a new NoPartySubIDs to this group +func (m NoPartySubIDsRepeatingGroup) Add() NoPartySubIDs { + g := m.RepeatingGroup.Add() + return NoPartySubIDs{g} +} + +//Get returns the ith NoPartySubIDs in the NoPartySubIDsRepeatinGroup +func (m NoPartySubIDsRepeatingGroup) Get(i int) NoPartySubIDs { + return NoPartySubIDs{m.RepeatingGroup.Get(i)} +} + +//NoPartyIDsRepeatingGroup is a repeating group, Tag 453 +type NoPartyIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoPartyIDsRepeatingGroup returns an initialized, NoPartyIDsRepeatingGroup +func NewNoPartyIDsRepeatingGroup() NoPartyIDsRepeatingGroup { + return NoPartyIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoPartyIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.PartyID), quickfix.GroupElement(tag.PartyIDSource), quickfix.GroupElement(tag.PartyRole), NewNoPartySubIDsRepeatingGroup()})} +} + +//Add create and append a new NoPartyIDs to this group +func (m NoPartyIDsRepeatingGroup) Add() NoPartyIDs { + g := m.RepeatingGroup.Add() + return NoPartyIDs{g} +} + +//Get returns the ith NoPartyIDs in the NoPartyIDsRepeatinGroup +func (m NoPartyIDsRepeatingGroup) Get(i int) NoPartyIDs { + return NoPartyIDs{m.RepeatingGroup.Get(i)} +} + +//NoSecurityAltID is a repeating group element, Tag 454 +type NoSecurityAltID struct { + quickfix.Group +} + +//SetSecurityAltID sets SecurityAltID, Tag 455 +func (m NoSecurityAltID) SetSecurityAltID(v string) { + m.Set(field.NewSecurityAltID(v)) +} + +//SetSecurityAltIDSource sets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) SetSecurityAltIDSource(v string) { + m.Set(field.NewSecurityAltIDSource(v)) +} + +//GetSecurityAltID gets SecurityAltID, Tag 455 +func (m NoSecurityAltID) GetSecurityAltID() (f field.SecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityAltIDSource gets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) GetSecurityAltIDSource() (f field.SecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasSecurityAltID returns true if SecurityAltID is present, Tag 455 +func (m NoSecurityAltID) HasSecurityAltID() bool { + return m.Has(tag.SecurityAltID) +} + +//HasSecurityAltIDSource returns true if SecurityAltIDSource is present, Tag 456 +func (m NoSecurityAltID) HasSecurityAltIDSource() bool { + return m.Has(tag.SecurityAltIDSource) +} + +//NoSecurityAltIDRepeatingGroup is a repeating group, Tag 454 +type NoSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoSecurityAltIDRepeatingGroup returns an initialized, NoSecurityAltIDRepeatingGroup +func NewNoSecurityAltIDRepeatingGroup() NoSecurityAltIDRepeatingGroup { + return NoSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.SecurityAltID), quickfix.GroupElement(tag.SecurityAltIDSource)})} +} + +//Add create and append a new NoSecurityAltID to this group +func (m NoSecurityAltIDRepeatingGroup) Add() NoSecurityAltID { + g := m.RepeatingGroup.Add() + return NoSecurityAltID{g} +} + +//Get returns the ith NoSecurityAltID in the NoSecurityAltIDRepeatinGroup +func (m NoSecurityAltIDRepeatingGroup) Get(i int) NoSecurityAltID { + return NoSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyings is a repeating group element, Tag 711 +type NoUnderlyings struct { + quickfix.Group +} + +//SetUnderlyingSymbol sets UnderlyingSymbol, Tag 311 +func (m NoUnderlyings) SetUnderlyingSymbol(v string) { + m.Set(field.NewUnderlyingSymbol(v)) +} + +//SetUnderlyingSymbolSfx sets UnderlyingSymbolSfx, Tag 312 +func (m NoUnderlyings) SetUnderlyingSymbolSfx(v string) { + m.Set(field.NewUnderlyingSymbolSfx(v)) +} + +//SetUnderlyingSecurityID sets UnderlyingSecurityID, Tag 309 +func (m NoUnderlyings) SetUnderlyingSecurityID(v string) { + m.Set(field.NewUnderlyingSecurityID(v)) +} + +//SetUnderlyingSecurityIDSource sets UnderlyingSecurityIDSource, Tag 305 +func (m NoUnderlyings) SetUnderlyingSecurityIDSource(v string) { + m.Set(field.NewUnderlyingSecurityIDSource(v)) +} + +//SetNoUnderlyingSecurityAltID sets NoUnderlyingSecurityAltID, Tag 457 +func (m NoUnderlyings) SetNoUnderlyingSecurityAltID(f NoUnderlyingSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetUnderlyingProduct sets UnderlyingProduct, Tag 462 +func (m NoUnderlyings) SetUnderlyingProduct(v int) { + m.Set(field.NewUnderlyingProduct(v)) +} + +//SetUnderlyingCFICode sets UnderlyingCFICode, Tag 463 +func (m NoUnderlyings) SetUnderlyingCFICode(v string) { + m.Set(field.NewUnderlyingCFICode(v)) +} + +//SetUnderlyingSecurityType sets UnderlyingSecurityType, Tag 310 +func (m NoUnderlyings) SetUnderlyingSecurityType(v string) { + m.Set(field.NewUnderlyingSecurityType(v)) +} + +//SetUnderlyingSecuritySubType sets UnderlyingSecuritySubType, Tag 763 +func (m NoUnderlyings) SetUnderlyingSecuritySubType(v string) { + m.Set(field.NewUnderlyingSecuritySubType(v)) +} + +//SetUnderlyingMaturityMonthYear sets UnderlyingMaturityMonthYear, Tag 313 +func (m NoUnderlyings) SetUnderlyingMaturityMonthYear(v string) { + m.Set(field.NewUnderlyingMaturityMonthYear(v)) +} + +//SetUnderlyingMaturityDate sets UnderlyingMaturityDate, Tag 542 +func (m NoUnderlyings) SetUnderlyingMaturityDate(v string) { + m.Set(field.NewUnderlyingMaturityDate(v)) +} + +//SetUnderlyingCouponPaymentDate sets UnderlyingCouponPaymentDate, Tag 241 +func (m NoUnderlyings) SetUnderlyingCouponPaymentDate(v string) { + m.Set(field.NewUnderlyingCouponPaymentDate(v)) +} + +//SetUnderlyingIssueDate sets UnderlyingIssueDate, Tag 242 +func (m NoUnderlyings) SetUnderlyingIssueDate(v string) { + m.Set(field.NewUnderlyingIssueDate(v)) +} + +//SetUnderlyingRepoCollateralSecurityType sets UnderlyingRepoCollateralSecurityType, Tag 243 +func (m NoUnderlyings) SetUnderlyingRepoCollateralSecurityType(v int) { + m.Set(field.NewUnderlyingRepoCollateralSecurityType(v)) +} + +//SetUnderlyingRepurchaseTerm sets UnderlyingRepurchaseTerm, Tag 244 +func (m NoUnderlyings) SetUnderlyingRepurchaseTerm(v int) { + m.Set(field.NewUnderlyingRepurchaseTerm(v)) +} + +//SetUnderlyingRepurchaseRate sets UnderlyingRepurchaseRate, Tag 245 +func (m NoUnderlyings) SetUnderlyingRepurchaseRate(v float64) { + m.Set(field.NewUnderlyingRepurchaseRate(v)) +} + +//SetUnderlyingFactor sets UnderlyingFactor, Tag 246 +func (m NoUnderlyings) SetUnderlyingFactor(v float64) { + m.Set(field.NewUnderlyingFactor(v)) +} + +//SetUnderlyingCreditRating sets UnderlyingCreditRating, Tag 256 +func (m NoUnderlyings) SetUnderlyingCreditRating(v string) { + m.Set(field.NewUnderlyingCreditRating(v)) +} + +//SetUnderlyingInstrRegistry sets UnderlyingInstrRegistry, Tag 595 +func (m NoUnderlyings) SetUnderlyingInstrRegistry(v string) { + m.Set(field.NewUnderlyingInstrRegistry(v)) +} + +//SetUnderlyingCountryOfIssue sets UnderlyingCountryOfIssue, Tag 592 +func (m NoUnderlyings) SetUnderlyingCountryOfIssue(v string) { + m.Set(field.NewUnderlyingCountryOfIssue(v)) +} + +//SetUnderlyingStateOrProvinceOfIssue sets UnderlyingStateOrProvinceOfIssue, Tag 593 +func (m NoUnderlyings) SetUnderlyingStateOrProvinceOfIssue(v string) { + m.Set(field.NewUnderlyingStateOrProvinceOfIssue(v)) +} + +//SetUnderlyingLocaleOfIssue sets UnderlyingLocaleOfIssue, Tag 594 +func (m NoUnderlyings) SetUnderlyingLocaleOfIssue(v string) { + m.Set(field.NewUnderlyingLocaleOfIssue(v)) +} + +//SetUnderlyingRedemptionDate sets UnderlyingRedemptionDate, Tag 247 +func (m NoUnderlyings) SetUnderlyingRedemptionDate(v string) { + m.Set(field.NewUnderlyingRedemptionDate(v)) +} + +//SetUnderlyingStrikePrice sets UnderlyingStrikePrice, Tag 316 +func (m NoUnderlyings) SetUnderlyingStrikePrice(v float64) { + m.Set(field.NewUnderlyingStrikePrice(v)) +} + +//SetUnderlyingStrikeCurrency sets UnderlyingStrikeCurrency, Tag 941 +func (m NoUnderlyings) SetUnderlyingStrikeCurrency(v string) { + m.Set(field.NewUnderlyingStrikeCurrency(v)) +} + +//SetUnderlyingOptAttribute sets UnderlyingOptAttribute, Tag 317 +func (m NoUnderlyings) SetUnderlyingOptAttribute(v string) { + m.Set(field.NewUnderlyingOptAttribute(v)) +} + +//SetUnderlyingContractMultiplier sets UnderlyingContractMultiplier, Tag 436 +func (m NoUnderlyings) SetUnderlyingContractMultiplier(v float64) { + m.Set(field.NewUnderlyingContractMultiplier(v)) +} + +//SetUnderlyingCouponRate sets UnderlyingCouponRate, Tag 435 +func (m NoUnderlyings) SetUnderlyingCouponRate(v float64) { + m.Set(field.NewUnderlyingCouponRate(v)) +} + +//SetUnderlyingSecurityExchange sets UnderlyingSecurityExchange, Tag 308 +func (m NoUnderlyings) SetUnderlyingSecurityExchange(v string) { + m.Set(field.NewUnderlyingSecurityExchange(v)) +} + +//SetUnderlyingIssuer sets UnderlyingIssuer, Tag 306 +func (m NoUnderlyings) SetUnderlyingIssuer(v string) { + m.Set(field.NewUnderlyingIssuer(v)) +} + +//SetEncodedUnderlyingIssuerLen sets EncodedUnderlyingIssuerLen, Tag 362 +func (m NoUnderlyings) SetEncodedUnderlyingIssuerLen(v int) { + m.Set(field.NewEncodedUnderlyingIssuerLen(v)) +} + +//SetEncodedUnderlyingIssuer sets EncodedUnderlyingIssuer, Tag 363 +func (m NoUnderlyings) SetEncodedUnderlyingIssuer(v string) { + m.Set(field.NewEncodedUnderlyingIssuer(v)) +} + +//SetUnderlyingSecurityDesc sets UnderlyingSecurityDesc, Tag 307 +func (m NoUnderlyings) SetUnderlyingSecurityDesc(v string) { + m.Set(field.NewUnderlyingSecurityDesc(v)) +} + +//SetEncodedUnderlyingSecurityDescLen sets EncodedUnderlyingSecurityDescLen, Tag 364 +func (m NoUnderlyings) SetEncodedUnderlyingSecurityDescLen(v int) { + m.Set(field.NewEncodedUnderlyingSecurityDescLen(v)) +} + +//SetEncodedUnderlyingSecurityDesc sets EncodedUnderlyingSecurityDesc, Tag 365 +func (m NoUnderlyings) SetEncodedUnderlyingSecurityDesc(v string) { + m.Set(field.NewEncodedUnderlyingSecurityDesc(v)) +} + +//SetUnderlyingCPProgram sets UnderlyingCPProgram, Tag 877 +func (m NoUnderlyings) SetUnderlyingCPProgram(v string) { + m.Set(field.NewUnderlyingCPProgram(v)) +} + +//SetUnderlyingCPRegType sets UnderlyingCPRegType, Tag 878 +func (m NoUnderlyings) SetUnderlyingCPRegType(v string) { + m.Set(field.NewUnderlyingCPRegType(v)) +} + +//SetUnderlyingCurrency sets UnderlyingCurrency, Tag 318 +func (m NoUnderlyings) SetUnderlyingCurrency(v string) { + m.Set(field.NewUnderlyingCurrency(v)) +} + +//SetUnderlyingQty sets UnderlyingQty, Tag 879 +func (m NoUnderlyings) SetUnderlyingQty(v float64) { + m.Set(field.NewUnderlyingQty(v)) +} + +//SetUnderlyingPx sets UnderlyingPx, Tag 810 +func (m NoUnderlyings) SetUnderlyingPx(v float64) { + m.Set(field.NewUnderlyingPx(v)) +} + +//SetUnderlyingDirtyPrice sets UnderlyingDirtyPrice, Tag 882 +func (m NoUnderlyings) SetUnderlyingDirtyPrice(v float64) { + m.Set(field.NewUnderlyingDirtyPrice(v)) +} + +//SetUnderlyingEndPrice sets UnderlyingEndPrice, Tag 883 +func (m NoUnderlyings) SetUnderlyingEndPrice(v float64) { + m.Set(field.NewUnderlyingEndPrice(v)) +} + +//SetUnderlyingStartValue sets UnderlyingStartValue, Tag 884 +func (m NoUnderlyings) SetUnderlyingStartValue(v float64) { + m.Set(field.NewUnderlyingStartValue(v)) +} + +//SetUnderlyingCurrentValue sets UnderlyingCurrentValue, Tag 885 +func (m NoUnderlyings) SetUnderlyingCurrentValue(v float64) { + m.Set(field.NewUnderlyingCurrentValue(v)) +} + +//SetUnderlyingEndValue sets UnderlyingEndValue, Tag 886 +func (m NoUnderlyings) SetUnderlyingEndValue(v float64) { + m.Set(field.NewUnderlyingEndValue(v)) +} + +//SetNoUnderlyingStips sets NoUnderlyingStips, Tag 887 +func (m NoUnderlyings) SetNoUnderlyingStips(f NoUnderlyingStipsRepeatingGroup) { + m.SetGroup(f) +} + +//GetUnderlyingSymbol gets UnderlyingSymbol, Tag 311 +func (m NoUnderlyings) GetUnderlyingSymbol() (f field.UnderlyingSymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSymbolSfx gets UnderlyingSymbolSfx, Tag 312 +func (m NoUnderlyings) GetUnderlyingSymbolSfx() (f field.UnderlyingSymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityID gets UnderlyingSecurityID, Tag 309 +func (m NoUnderlyings) GetUnderlyingSecurityID() (f field.UnderlyingSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityIDSource gets UnderlyingSecurityIDSource, Tag 305 +func (m NoUnderlyings) GetUnderlyingSecurityIDSource() (f field.UnderlyingSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyingSecurityAltID gets NoUnderlyingSecurityAltID, Tag 457 +func (m NoUnderlyings) GetNoUnderlyingSecurityAltID() (NoUnderlyingSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetUnderlyingProduct gets UnderlyingProduct, Tag 462 +func (m NoUnderlyings) GetUnderlyingProduct() (f field.UnderlyingProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCFICode gets UnderlyingCFICode, Tag 463 +func (m NoUnderlyings) GetUnderlyingCFICode() (f field.UnderlyingCFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityType gets UnderlyingSecurityType, Tag 310 +func (m NoUnderlyings) GetUnderlyingSecurityType() (f field.UnderlyingSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecuritySubType gets UnderlyingSecuritySubType, Tag 763 +func (m NoUnderlyings) GetUnderlyingSecuritySubType() (f field.UnderlyingSecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingMaturityMonthYear gets UnderlyingMaturityMonthYear, Tag 313 +func (m NoUnderlyings) GetUnderlyingMaturityMonthYear() (f field.UnderlyingMaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingMaturityDate gets UnderlyingMaturityDate, Tag 542 +func (m NoUnderlyings) GetUnderlyingMaturityDate() (f field.UnderlyingMaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCouponPaymentDate gets UnderlyingCouponPaymentDate, Tag 241 +func (m NoUnderlyings) GetUnderlyingCouponPaymentDate() (f field.UnderlyingCouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingIssueDate gets UnderlyingIssueDate, Tag 242 +func (m NoUnderlyings) GetUnderlyingIssueDate() (f field.UnderlyingIssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepoCollateralSecurityType gets UnderlyingRepoCollateralSecurityType, Tag 243 +func (m NoUnderlyings) GetUnderlyingRepoCollateralSecurityType() (f field.UnderlyingRepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepurchaseTerm gets UnderlyingRepurchaseTerm, Tag 244 +func (m NoUnderlyings) GetUnderlyingRepurchaseTerm() (f field.UnderlyingRepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepurchaseRate gets UnderlyingRepurchaseRate, Tag 245 +func (m NoUnderlyings) GetUnderlyingRepurchaseRate() (f field.UnderlyingRepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingFactor gets UnderlyingFactor, Tag 246 +func (m NoUnderlyings) GetUnderlyingFactor() (f field.UnderlyingFactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCreditRating gets UnderlyingCreditRating, Tag 256 +func (m NoUnderlyings) GetUnderlyingCreditRating() (f field.UnderlyingCreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingInstrRegistry gets UnderlyingInstrRegistry, Tag 595 +func (m NoUnderlyings) GetUnderlyingInstrRegistry() (f field.UnderlyingInstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCountryOfIssue gets UnderlyingCountryOfIssue, Tag 592 +func (m NoUnderlyings) GetUnderlyingCountryOfIssue() (f field.UnderlyingCountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStateOrProvinceOfIssue gets UnderlyingStateOrProvinceOfIssue, Tag 593 +func (m NoUnderlyings) GetUnderlyingStateOrProvinceOfIssue() (f field.UnderlyingStateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingLocaleOfIssue gets UnderlyingLocaleOfIssue, Tag 594 +func (m NoUnderlyings) GetUnderlyingLocaleOfIssue() (f field.UnderlyingLocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRedemptionDate gets UnderlyingRedemptionDate, Tag 247 +func (m NoUnderlyings) GetUnderlyingRedemptionDate() (f field.UnderlyingRedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStrikePrice gets UnderlyingStrikePrice, Tag 316 +func (m NoUnderlyings) GetUnderlyingStrikePrice() (f field.UnderlyingStrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStrikeCurrency gets UnderlyingStrikeCurrency, Tag 941 +func (m NoUnderlyings) GetUnderlyingStrikeCurrency() (f field.UnderlyingStrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingOptAttribute gets UnderlyingOptAttribute, Tag 317 +func (m NoUnderlyings) GetUnderlyingOptAttribute() (f field.UnderlyingOptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingContractMultiplier gets UnderlyingContractMultiplier, Tag 436 +func (m NoUnderlyings) GetUnderlyingContractMultiplier() (f field.UnderlyingContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCouponRate gets UnderlyingCouponRate, Tag 435 +func (m NoUnderlyings) GetUnderlyingCouponRate() (f field.UnderlyingCouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityExchange gets UnderlyingSecurityExchange, Tag 308 +func (m NoUnderlyings) GetUnderlyingSecurityExchange() (f field.UnderlyingSecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingIssuer gets UnderlyingIssuer, Tag 306 +func (m NoUnderlyings) GetUnderlyingIssuer() (f field.UnderlyingIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingIssuerLen gets EncodedUnderlyingIssuerLen, Tag 362 +func (m NoUnderlyings) GetEncodedUnderlyingIssuerLen() (f field.EncodedUnderlyingIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingIssuer gets EncodedUnderlyingIssuer, Tag 363 +func (m NoUnderlyings) GetEncodedUnderlyingIssuer() (f field.EncodedUnderlyingIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityDesc gets UnderlyingSecurityDesc, Tag 307 +func (m NoUnderlyings) GetUnderlyingSecurityDesc() (f field.UnderlyingSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingSecurityDescLen gets EncodedUnderlyingSecurityDescLen, Tag 364 +func (m NoUnderlyings) GetEncodedUnderlyingSecurityDescLen() (f field.EncodedUnderlyingSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingSecurityDesc gets EncodedUnderlyingSecurityDesc, Tag 365 +func (m NoUnderlyings) GetEncodedUnderlyingSecurityDesc() (f field.EncodedUnderlyingSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCPProgram gets UnderlyingCPProgram, Tag 877 +func (m NoUnderlyings) GetUnderlyingCPProgram() (f field.UnderlyingCPProgramField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCPRegType gets UnderlyingCPRegType, Tag 878 +func (m NoUnderlyings) GetUnderlyingCPRegType() (f field.UnderlyingCPRegTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCurrency gets UnderlyingCurrency, Tag 318 +func (m NoUnderlyings) GetUnderlyingCurrency() (f field.UnderlyingCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingQty gets UnderlyingQty, Tag 879 +func (m NoUnderlyings) GetUnderlyingQty() (f field.UnderlyingQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingPx gets UnderlyingPx, Tag 810 +func (m NoUnderlyings) GetUnderlyingPx() (f field.UnderlyingPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingDirtyPrice gets UnderlyingDirtyPrice, Tag 882 +func (m NoUnderlyings) GetUnderlyingDirtyPrice() (f field.UnderlyingDirtyPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingEndPrice gets UnderlyingEndPrice, Tag 883 +func (m NoUnderlyings) GetUnderlyingEndPrice() (f field.UnderlyingEndPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStartValue gets UnderlyingStartValue, Tag 884 +func (m NoUnderlyings) GetUnderlyingStartValue() (f field.UnderlyingStartValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCurrentValue gets UnderlyingCurrentValue, Tag 885 +func (m NoUnderlyings) GetUnderlyingCurrentValue() (f field.UnderlyingCurrentValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingEndValue gets UnderlyingEndValue, Tag 886 +func (m NoUnderlyings) GetUnderlyingEndValue() (f field.UnderlyingEndValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyingStips gets NoUnderlyingStips, Tag 887 +func (m NoUnderlyings) GetNoUnderlyingStips() (NoUnderlyingStipsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingStipsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasUnderlyingSymbol returns true if UnderlyingSymbol is present, Tag 311 +func (m NoUnderlyings) HasUnderlyingSymbol() bool { + return m.Has(tag.UnderlyingSymbol) +} + +//HasUnderlyingSymbolSfx returns true if UnderlyingSymbolSfx is present, Tag 312 +func (m NoUnderlyings) HasUnderlyingSymbolSfx() bool { + return m.Has(tag.UnderlyingSymbolSfx) +} + +//HasUnderlyingSecurityID returns true if UnderlyingSecurityID is present, Tag 309 +func (m NoUnderlyings) HasUnderlyingSecurityID() bool { + return m.Has(tag.UnderlyingSecurityID) +} + +//HasUnderlyingSecurityIDSource returns true if UnderlyingSecurityIDSource is present, Tag 305 +func (m NoUnderlyings) HasUnderlyingSecurityIDSource() bool { + return m.Has(tag.UnderlyingSecurityIDSource) +} + +//HasNoUnderlyingSecurityAltID returns true if NoUnderlyingSecurityAltID is present, Tag 457 +func (m NoUnderlyings) HasNoUnderlyingSecurityAltID() bool { + return m.Has(tag.NoUnderlyingSecurityAltID) +} + +//HasUnderlyingProduct returns true if UnderlyingProduct is present, Tag 462 +func (m NoUnderlyings) HasUnderlyingProduct() bool { + return m.Has(tag.UnderlyingProduct) +} + +//HasUnderlyingCFICode returns true if UnderlyingCFICode is present, Tag 463 +func (m NoUnderlyings) HasUnderlyingCFICode() bool { + return m.Has(tag.UnderlyingCFICode) +} + +//HasUnderlyingSecurityType returns true if UnderlyingSecurityType is present, Tag 310 +func (m NoUnderlyings) HasUnderlyingSecurityType() bool { + return m.Has(tag.UnderlyingSecurityType) +} + +//HasUnderlyingSecuritySubType returns true if UnderlyingSecuritySubType is present, Tag 763 +func (m NoUnderlyings) HasUnderlyingSecuritySubType() bool { + return m.Has(tag.UnderlyingSecuritySubType) +} + +//HasUnderlyingMaturityMonthYear returns true if UnderlyingMaturityMonthYear is present, Tag 313 +func (m NoUnderlyings) HasUnderlyingMaturityMonthYear() bool { + return m.Has(tag.UnderlyingMaturityMonthYear) +} + +//HasUnderlyingMaturityDate returns true if UnderlyingMaturityDate is present, Tag 542 +func (m NoUnderlyings) HasUnderlyingMaturityDate() bool { + return m.Has(tag.UnderlyingMaturityDate) +} + +//HasUnderlyingCouponPaymentDate returns true if UnderlyingCouponPaymentDate is present, Tag 241 +func (m NoUnderlyings) HasUnderlyingCouponPaymentDate() bool { + return m.Has(tag.UnderlyingCouponPaymentDate) +} + +//HasUnderlyingIssueDate returns true if UnderlyingIssueDate is present, Tag 242 +func (m NoUnderlyings) HasUnderlyingIssueDate() bool { + return m.Has(tag.UnderlyingIssueDate) +} + +//HasUnderlyingRepoCollateralSecurityType returns true if UnderlyingRepoCollateralSecurityType is present, Tag 243 +func (m NoUnderlyings) HasUnderlyingRepoCollateralSecurityType() bool { + return m.Has(tag.UnderlyingRepoCollateralSecurityType) +} + +//HasUnderlyingRepurchaseTerm returns true if UnderlyingRepurchaseTerm is present, Tag 244 +func (m NoUnderlyings) HasUnderlyingRepurchaseTerm() bool { + return m.Has(tag.UnderlyingRepurchaseTerm) +} + +//HasUnderlyingRepurchaseRate returns true if UnderlyingRepurchaseRate is present, Tag 245 +func (m NoUnderlyings) HasUnderlyingRepurchaseRate() bool { + return m.Has(tag.UnderlyingRepurchaseRate) +} + +//HasUnderlyingFactor returns true if UnderlyingFactor is present, Tag 246 +func (m NoUnderlyings) HasUnderlyingFactor() bool { + return m.Has(tag.UnderlyingFactor) +} + +//HasUnderlyingCreditRating returns true if UnderlyingCreditRating is present, Tag 256 +func (m NoUnderlyings) HasUnderlyingCreditRating() bool { + return m.Has(tag.UnderlyingCreditRating) +} + +//HasUnderlyingInstrRegistry returns true if UnderlyingInstrRegistry is present, Tag 595 +func (m NoUnderlyings) HasUnderlyingInstrRegistry() bool { + return m.Has(tag.UnderlyingInstrRegistry) +} + +//HasUnderlyingCountryOfIssue returns true if UnderlyingCountryOfIssue is present, Tag 592 +func (m NoUnderlyings) HasUnderlyingCountryOfIssue() bool { + return m.Has(tag.UnderlyingCountryOfIssue) +} + +//HasUnderlyingStateOrProvinceOfIssue returns true if UnderlyingStateOrProvinceOfIssue is present, Tag 593 +func (m NoUnderlyings) HasUnderlyingStateOrProvinceOfIssue() bool { + return m.Has(tag.UnderlyingStateOrProvinceOfIssue) +} + +//HasUnderlyingLocaleOfIssue returns true if UnderlyingLocaleOfIssue is present, Tag 594 +func (m NoUnderlyings) HasUnderlyingLocaleOfIssue() bool { + return m.Has(tag.UnderlyingLocaleOfIssue) +} + +//HasUnderlyingRedemptionDate returns true if UnderlyingRedemptionDate is present, Tag 247 +func (m NoUnderlyings) HasUnderlyingRedemptionDate() bool { + return m.Has(tag.UnderlyingRedemptionDate) +} + +//HasUnderlyingStrikePrice returns true if UnderlyingStrikePrice is present, Tag 316 +func (m NoUnderlyings) HasUnderlyingStrikePrice() bool { + return m.Has(tag.UnderlyingStrikePrice) +} + +//HasUnderlyingStrikeCurrency returns true if UnderlyingStrikeCurrency is present, Tag 941 +func (m NoUnderlyings) HasUnderlyingStrikeCurrency() bool { + return m.Has(tag.UnderlyingStrikeCurrency) +} + +//HasUnderlyingOptAttribute returns true if UnderlyingOptAttribute is present, Tag 317 +func (m NoUnderlyings) HasUnderlyingOptAttribute() bool { + return m.Has(tag.UnderlyingOptAttribute) +} + +//HasUnderlyingContractMultiplier returns true if UnderlyingContractMultiplier is present, Tag 436 +func (m NoUnderlyings) HasUnderlyingContractMultiplier() bool { + return m.Has(tag.UnderlyingContractMultiplier) +} + +//HasUnderlyingCouponRate returns true if UnderlyingCouponRate is present, Tag 435 +func (m NoUnderlyings) HasUnderlyingCouponRate() bool { + return m.Has(tag.UnderlyingCouponRate) +} + +//HasUnderlyingSecurityExchange returns true if UnderlyingSecurityExchange is present, Tag 308 +func (m NoUnderlyings) HasUnderlyingSecurityExchange() bool { + return m.Has(tag.UnderlyingSecurityExchange) +} + +//HasUnderlyingIssuer returns true if UnderlyingIssuer is present, Tag 306 +func (m NoUnderlyings) HasUnderlyingIssuer() bool { + return m.Has(tag.UnderlyingIssuer) +} + +//HasEncodedUnderlyingIssuerLen returns true if EncodedUnderlyingIssuerLen is present, Tag 362 +func (m NoUnderlyings) HasEncodedUnderlyingIssuerLen() bool { + return m.Has(tag.EncodedUnderlyingIssuerLen) +} + +//HasEncodedUnderlyingIssuer returns true if EncodedUnderlyingIssuer is present, Tag 363 +func (m NoUnderlyings) HasEncodedUnderlyingIssuer() bool { + return m.Has(tag.EncodedUnderlyingIssuer) +} + +//HasUnderlyingSecurityDesc returns true if UnderlyingSecurityDesc is present, Tag 307 +func (m NoUnderlyings) HasUnderlyingSecurityDesc() bool { + return m.Has(tag.UnderlyingSecurityDesc) +} + +//HasEncodedUnderlyingSecurityDescLen returns true if EncodedUnderlyingSecurityDescLen is present, Tag 364 +func (m NoUnderlyings) HasEncodedUnderlyingSecurityDescLen() bool { + return m.Has(tag.EncodedUnderlyingSecurityDescLen) +} + +//HasEncodedUnderlyingSecurityDesc returns true if EncodedUnderlyingSecurityDesc is present, Tag 365 +func (m NoUnderlyings) HasEncodedUnderlyingSecurityDesc() bool { + return m.Has(tag.EncodedUnderlyingSecurityDesc) +} + +//HasUnderlyingCPProgram returns true if UnderlyingCPProgram is present, Tag 877 +func (m NoUnderlyings) HasUnderlyingCPProgram() bool { + return m.Has(tag.UnderlyingCPProgram) +} + +//HasUnderlyingCPRegType returns true if UnderlyingCPRegType is present, Tag 878 +func (m NoUnderlyings) HasUnderlyingCPRegType() bool { + return m.Has(tag.UnderlyingCPRegType) +} + +//HasUnderlyingCurrency returns true if UnderlyingCurrency is present, Tag 318 +func (m NoUnderlyings) HasUnderlyingCurrency() bool { + return m.Has(tag.UnderlyingCurrency) +} + +//HasUnderlyingQty returns true if UnderlyingQty is present, Tag 879 +func (m NoUnderlyings) HasUnderlyingQty() bool { + return m.Has(tag.UnderlyingQty) +} + +//HasUnderlyingPx returns true if UnderlyingPx is present, Tag 810 +func (m NoUnderlyings) HasUnderlyingPx() bool { + return m.Has(tag.UnderlyingPx) +} + +//HasUnderlyingDirtyPrice returns true if UnderlyingDirtyPrice is present, Tag 882 +func (m NoUnderlyings) HasUnderlyingDirtyPrice() bool { + return m.Has(tag.UnderlyingDirtyPrice) +} + +//HasUnderlyingEndPrice returns true if UnderlyingEndPrice is present, Tag 883 +func (m NoUnderlyings) HasUnderlyingEndPrice() bool { + return m.Has(tag.UnderlyingEndPrice) +} + +//HasUnderlyingStartValue returns true if UnderlyingStartValue is present, Tag 884 +func (m NoUnderlyings) HasUnderlyingStartValue() bool { + return m.Has(tag.UnderlyingStartValue) +} + +//HasUnderlyingCurrentValue returns true if UnderlyingCurrentValue is present, Tag 885 +func (m NoUnderlyings) HasUnderlyingCurrentValue() bool { + return m.Has(tag.UnderlyingCurrentValue) +} + +//HasUnderlyingEndValue returns true if UnderlyingEndValue is present, Tag 886 +func (m NoUnderlyings) HasUnderlyingEndValue() bool { + return m.Has(tag.UnderlyingEndValue) +} + +//HasNoUnderlyingStips returns true if NoUnderlyingStips is present, Tag 887 +func (m NoUnderlyings) HasNoUnderlyingStips() bool { + return m.Has(tag.NoUnderlyingStips) +} + +//NoUnderlyingSecurityAltID is a repeating group element, Tag 457 +type NoUnderlyingSecurityAltID struct { + quickfix.Group +} + +//SetUnderlyingSecurityAltID sets UnderlyingSecurityAltID, Tag 458 +func (m NoUnderlyingSecurityAltID) SetUnderlyingSecurityAltID(v string) { + m.Set(field.NewUnderlyingSecurityAltID(v)) +} + +//SetUnderlyingSecurityAltIDSource sets UnderlyingSecurityAltIDSource, Tag 459 +func (m NoUnderlyingSecurityAltID) SetUnderlyingSecurityAltIDSource(v string) { + m.Set(field.NewUnderlyingSecurityAltIDSource(v)) +} + +//GetUnderlyingSecurityAltID gets UnderlyingSecurityAltID, Tag 458 +func (m NoUnderlyingSecurityAltID) GetUnderlyingSecurityAltID() (f field.UnderlyingSecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityAltIDSource gets UnderlyingSecurityAltIDSource, Tag 459 +func (m NoUnderlyingSecurityAltID) GetUnderlyingSecurityAltIDSource() (f field.UnderlyingSecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingSecurityAltID returns true if UnderlyingSecurityAltID is present, Tag 458 +func (m NoUnderlyingSecurityAltID) HasUnderlyingSecurityAltID() bool { + return m.Has(tag.UnderlyingSecurityAltID) +} + +//HasUnderlyingSecurityAltIDSource returns true if UnderlyingSecurityAltIDSource is present, Tag 459 +func (m NoUnderlyingSecurityAltID) HasUnderlyingSecurityAltIDSource() bool { + return m.Has(tag.UnderlyingSecurityAltIDSource) +} + +//NoUnderlyingSecurityAltIDRepeatingGroup is a repeating group, Tag 457 +type NoUnderlyingSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingSecurityAltIDRepeatingGroup returns an initialized, NoUnderlyingSecurityAltIDRepeatingGroup +func NewNoUnderlyingSecurityAltIDRepeatingGroup() NoUnderlyingSecurityAltIDRepeatingGroup { + return NoUnderlyingSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyingSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingSecurityAltID), quickfix.GroupElement(tag.UnderlyingSecurityAltIDSource)})} +} + +//Add create and append a new NoUnderlyingSecurityAltID to this group +func (m NoUnderlyingSecurityAltIDRepeatingGroup) Add() NoUnderlyingSecurityAltID { + g := m.RepeatingGroup.Add() + return NoUnderlyingSecurityAltID{g} +} + +//Get returns the ith NoUnderlyingSecurityAltID in the NoUnderlyingSecurityAltIDRepeatinGroup +func (m NoUnderlyingSecurityAltIDRepeatingGroup) Get(i int) NoUnderlyingSecurityAltID { + return NoUnderlyingSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyingStips is a repeating group element, Tag 887 +type NoUnderlyingStips struct { + quickfix.Group +} + +//SetUnderlyingStipType sets UnderlyingStipType, Tag 888 +func (m NoUnderlyingStips) SetUnderlyingStipType(v string) { + m.Set(field.NewUnderlyingStipType(v)) +} + +//SetUnderlyingStipValue sets UnderlyingStipValue, Tag 889 +func (m NoUnderlyingStips) SetUnderlyingStipValue(v string) { + m.Set(field.NewUnderlyingStipValue(v)) +} + +//GetUnderlyingStipType gets UnderlyingStipType, Tag 888 +func (m NoUnderlyingStips) GetUnderlyingStipType() (f field.UnderlyingStipTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStipValue gets UnderlyingStipValue, Tag 889 +func (m NoUnderlyingStips) GetUnderlyingStipValue() (f field.UnderlyingStipValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingStipType returns true if UnderlyingStipType is present, Tag 888 +func (m NoUnderlyingStips) HasUnderlyingStipType() bool { + return m.Has(tag.UnderlyingStipType) +} + +//HasUnderlyingStipValue returns true if UnderlyingStipValue is present, Tag 889 +func (m NoUnderlyingStips) HasUnderlyingStipValue() bool { + return m.Has(tag.UnderlyingStipValue) +} + +//NoUnderlyingStipsRepeatingGroup is a repeating group, Tag 887 +type NoUnderlyingStipsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingStipsRepeatingGroup returns an initialized, NoUnderlyingStipsRepeatingGroup +func NewNoUnderlyingStipsRepeatingGroup() NoUnderlyingStipsRepeatingGroup { + return NoUnderlyingStipsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyingStips, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingStipType), quickfix.GroupElement(tag.UnderlyingStipValue)})} +} + +//Add create and append a new NoUnderlyingStips to this group +func (m NoUnderlyingStipsRepeatingGroup) Add() NoUnderlyingStips { + g := m.RepeatingGroup.Add() + return NoUnderlyingStips{g} +} + +//Get returns the ith NoUnderlyingStips in the NoUnderlyingStipsRepeatinGroup +func (m NoUnderlyingStipsRepeatingGroup) Get(i int) NoUnderlyingStips { + return NoUnderlyingStips{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyingsRepeatingGroup is a repeating group, Tag 711 +type NoUnderlyingsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingsRepeatingGroup returns an initialized, NoUnderlyingsRepeatingGroup +func NewNoUnderlyingsRepeatingGroup() NoUnderlyingsRepeatingGroup { + return NoUnderlyingsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyings, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingSymbol), quickfix.GroupElement(tag.UnderlyingSymbolSfx), quickfix.GroupElement(tag.UnderlyingSecurityID), quickfix.GroupElement(tag.UnderlyingSecurityIDSource), NewNoUnderlyingSecurityAltIDRepeatingGroup(), quickfix.GroupElement(tag.UnderlyingProduct), quickfix.GroupElement(tag.UnderlyingCFICode), quickfix.GroupElement(tag.UnderlyingSecurityType), quickfix.GroupElement(tag.UnderlyingSecuritySubType), quickfix.GroupElement(tag.UnderlyingMaturityMonthYear), quickfix.GroupElement(tag.UnderlyingMaturityDate), quickfix.GroupElement(tag.UnderlyingCouponPaymentDate), quickfix.GroupElement(tag.UnderlyingIssueDate), quickfix.GroupElement(tag.UnderlyingRepoCollateralSecurityType), quickfix.GroupElement(tag.UnderlyingRepurchaseTerm), quickfix.GroupElement(tag.UnderlyingRepurchaseRate), quickfix.GroupElement(tag.UnderlyingFactor), quickfix.GroupElement(tag.UnderlyingCreditRating), quickfix.GroupElement(tag.UnderlyingInstrRegistry), quickfix.GroupElement(tag.UnderlyingCountryOfIssue), quickfix.GroupElement(tag.UnderlyingStateOrProvinceOfIssue), quickfix.GroupElement(tag.UnderlyingLocaleOfIssue), quickfix.GroupElement(tag.UnderlyingRedemptionDate), quickfix.GroupElement(tag.UnderlyingStrikePrice), quickfix.GroupElement(tag.UnderlyingStrikeCurrency), quickfix.GroupElement(tag.UnderlyingOptAttribute), quickfix.GroupElement(tag.UnderlyingContractMultiplier), quickfix.GroupElement(tag.UnderlyingCouponRate), quickfix.GroupElement(tag.UnderlyingSecurityExchange), quickfix.GroupElement(tag.UnderlyingIssuer), quickfix.GroupElement(tag.EncodedUnderlyingIssuerLen), quickfix.GroupElement(tag.EncodedUnderlyingIssuer), quickfix.GroupElement(tag.UnderlyingSecurityDesc), quickfix.GroupElement(tag.EncodedUnderlyingSecurityDescLen), quickfix.GroupElement(tag.EncodedUnderlyingSecurityDesc), quickfix.GroupElement(tag.UnderlyingCPProgram), quickfix.GroupElement(tag.UnderlyingCPRegType), quickfix.GroupElement(tag.UnderlyingCurrency), quickfix.GroupElement(tag.UnderlyingQty), quickfix.GroupElement(tag.UnderlyingPx), quickfix.GroupElement(tag.UnderlyingDirtyPrice), quickfix.GroupElement(tag.UnderlyingEndPrice), quickfix.GroupElement(tag.UnderlyingStartValue), quickfix.GroupElement(tag.UnderlyingCurrentValue), quickfix.GroupElement(tag.UnderlyingEndValue), NewNoUnderlyingStipsRepeatingGroup()})} +} + +//Add create and append a new NoUnderlyings to this group +func (m NoUnderlyingsRepeatingGroup) Add() NoUnderlyings { + g := m.RepeatingGroup.Add() + return NoUnderlyings{g} +} + +//Get returns the ith NoUnderlyings in the NoUnderlyingsRepeatinGroup +func (m NoUnderlyingsRepeatingGroup) Get(i int) NoUnderlyings { + return NoUnderlyings{m.RepeatingGroup.Get(i)} +} + +//NoEvents is a repeating group element, Tag 864 +type NoEvents struct { + quickfix.Group +} + +//SetEventType sets EventType, Tag 865 +func (m NoEvents) SetEventType(v int) { + m.Set(field.NewEventType(v)) +} + +//SetEventDate sets EventDate, Tag 866 +func (m NoEvents) SetEventDate(v string) { + m.Set(field.NewEventDate(v)) +} + +//SetEventPx sets EventPx, Tag 867 +func (m NoEvents) SetEventPx(v float64) { + m.Set(field.NewEventPx(v)) +} + +//SetEventText sets EventText, Tag 868 +func (m NoEvents) SetEventText(v string) { + m.Set(field.NewEventText(v)) +} + +//GetEventType gets EventType, Tag 865 +func (m NoEvents) GetEventType() (f field.EventTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventDate gets EventDate, Tag 866 +func (m NoEvents) GetEventDate() (f field.EventDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventPx gets EventPx, Tag 867 +func (m NoEvents) GetEventPx() (f field.EventPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventText gets EventText, Tag 868 +func (m NoEvents) GetEventText() (f field.EventTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasEventType returns true if EventType is present, Tag 865 +func (m NoEvents) HasEventType() bool { + return m.Has(tag.EventType) +} + +//HasEventDate returns true if EventDate is present, Tag 866 +func (m NoEvents) HasEventDate() bool { + return m.Has(tag.EventDate) +} + +//HasEventPx returns true if EventPx is present, Tag 867 +func (m NoEvents) HasEventPx() bool { + return m.Has(tag.EventPx) +} + +//HasEventText returns true if EventText is present, Tag 868 +func (m NoEvents) HasEventText() bool { + return m.Has(tag.EventText) +} + +//NoEventsRepeatingGroup is a repeating group, Tag 864 +type NoEventsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoEventsRepeatingGroup returns an initialized, NoEventsRepeatingGroup +func NewNoEventsRepeatingGroup() NoEventsRepeatingGroup { + return NoEventsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoEvents, + quickfix.GroupTemplate{quickfix.GroupElement(tag.EventType), quickfix.GroupElement(tag.EventDate), quickfix.GroupElement(tag.EventPx), quickfix.GroupElement(tag.EventText)})} +} + +//Add create and append a new NoEvents to this group +func (m NoEventsRepeatingGroup) Add() NoEvents { + g := m.RepeatingGroup.Add() + return NoEvents{g} +} + +//Get returns the ith NoEvents in the NoEventsRepeatinGroup +func (m NoEventsRepeatingGroup) Get(i int) NoEvents { + return NoEvents{m.RepeatingGroup.Get(i)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix44/ordercancelrequest/OrderCancelRequest.generated.go b/vendor/github.com/quickfixgo/quickfix/fix44/ordercancelrequest/OrderCancelRequest.generated.go new file mode 100644 index 0000000..11afa9b --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix44/ordercancelrequest/OrderCancelRequest.generated.go @@ -0,0 +1,2444 @@ +package ordercancelrequest + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fix44" + "github.com/quickfixgo/quickfix/tag" +) + +//OrderCancelRequest is the fix44 OrderCancelRequest type, MsgType = F +type OrderCancelRequest struct { + fix44.Header + quickfix.Body + fix44.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a OrderCancelRequest from a quickfix.Message instance +func FromMessage(m quickfix.Message) OrderCancelRequest { + return OrderCancelRequest{ + Header: fix44.Header{Header: m.Header}, + Body: m.Body, + Trailer: fix44.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m OrderCancelRequest) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a OrderCancelRequest initialized with the required fields for OrderCancelRequest +func New(origclordid field.OrigClOrdIDField, clordid field.ClOrdIDField, side field.SideField, transacttime field.TransactTimeField) (m OrderCancelRequest) { + m.Header = fix44.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("F")) + m.Set(origclordid) + m.Set(clordid) + m.Set(side) + m.Set(transacttime) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg OrderCancelRequest, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "FIX.4.4", "F", r +} + +//SetAccount sets Account, Tag 1 +func (m OrderCancelRequest) SetAccount(v string) { + m.Set(field.NewAccount(v)) +} + +//SetClOrdID sets ClOrdID, Tag 11 +func (m OrderCancelRequest) SetClOrdID(v string) { + m.Set(field.NewClOrdID(v)) +} + +//SetSecurityIDSource sets SecurityIDSource, Tag 22 +func (m OrderCancelRequest) SetSecurityIDSource(v string) { + m.Set(field.NewSecurityIDSource(v)) +} + +//SetOrderID sets OrderID, Tag 37 +func (m OrderCancelRequest) SetOrderID(v string) { + m.Set(field.NewOrderID(v)) +} + +//SetOrderQty sets OrderQty, Tag 38 +func (m OrderCancelRequest) SetOrderQty(v float64) { + m.Set(field.NewOrderQty(v)) +} + +//SetOrigClOrdID sets OrigClOrdID, Tag 41 +func (m OrderCancelRequest) SetOrigClOrdID(v string) { + m.Set(field.NewOrigClOrdID(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m OrderCancelRequest) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSide sets Side, Tag 54 +func (m OrderCancelRequest) SetSide(v string) { + m.Set(field.NewSide(v)) +} + +//SetSymbol sets Symbol, Tag 55 +func (m OrderCancelRequest) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetText sets Text, Tag 58 +func (m OrderCancelRequest) SetText(v string) { + m.Set(field.NewText(v)) +} + +//SetTransactTime sets TransactTime, Tag 60 +func (m OrderCancelRequest) SetTransactTime(v time.Time) { + m.Set(field.NewTransactTime(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m OrderCancelRequest) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetListID sets ListID, Tag 66 +func (m OrderCancelRequest) SetListID(v string) { + m.Set(field.NewListID(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m OrderCancelRequest) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m OrderCancelRequest) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetCashOrderQty sets CashOrderQty, Tag 152 +func (m OrderCancelRequest) SetCashOrderQty(v float64) { + m.Set(field.NewCashOrderQty(v)) +} + +//SetSecurityType sets SecurityType, Tag 167 +func (m OrderCancelRequest) SetSecurityType(v string) { + m.Set(field.NewSecurityType(v)) +} + +//SetMaturityMonthYear sets MaturityMonthYear, Tag 200 +func (m OrderCancelRequest) SetMaturityMonthYear(v string) { + m.Set(field.NewMaturityMonthYear(v)) +} + +//SetStrikePrice sets StrikePrice, Tag 202 +func (m OrderCancelRequest) SetStrikePrice(v float64) { + m.Set(field.NewStrikePrice(v)) +} + +//SetOptAttribute sets OptAttribute, Tag 206 +func (m OrderCancelRequest) SetOptAttribute(v string) { + m.Set(field.NewOptAttribute(v)) +} + +//SetSecurityExchange sets SecurityExchange, Tag 207 +func (m OrderCancelRequest) SetSecurityExchange(v string) { + m.Set(field.NewSecurityExchange(v)) +} + +//SetCouponRate sets CouponRate, Tag 223 +func (m OrderCancelRequest) SetCouponRate(v float64) { + m.Set(field.NewCouponRate(v)) +} + +//SetCouponPaymentDate sets CouponPaymentDate, Tag 224 +func (m OrderCancelRequest) SetCouponPaymentDate(v string) { + m.Set(field.NewCouponPaymentDate(v)) +} + +//SetIssueDate sets IssueDate, Tag 225 +func (m OrderCancelRequest) SetIssueDate(v string) { + m.Set(field.NewIssueDate(v)) +} + +//SetRepurchaseTerm sets RepurchaseTerm, Tag 226 +func (m OrderCancelRequest) SetRepurchaseTerm(v int) { + m.Set(field.NewRepurchaseTerm(v)) +} + +//SetRepurchaseRate sets RepurchaseRate, Tag 227 +func (m OrderCancelRequest) SetRepurchaseRate(v float64) { + m.Set(field.NewRepurchaseRate(v)) +} + +//SetFactor sets Factor, Tag 228 +func (m OrderCancelRequest) SetFactor(v float64) { + m.Set(field.NewFactor(v)) +} + +//SetContractMultiplier sets ContractMultiplier, Tag 231 +func (m OrderCancelRequest) SetContractMultiplier(v float64) { + m.Set(field.NewContractMultiplier(v)) +} + +//SetRepoCollateralSecurityType sets RepoCollateralSecurityType, Tag 239 +func (m OrderCancelRequest) SetRepoCollateralSecurityType(v int) { + m.Set(field.NewRepoCollateralSecurityType(v)) +} + +//SetRedemptionDate sets RedemptionDate, Tag 240 +func (m OrderCancelRequest) SetRedemptionDate(v string) { + m.Set(field.NewRedemptionDate(v)) +} + +//SetCreditRating sets CreditRating, Tag 255 +func (m OrderCancelRequest) SetCreditRating(v string) { + m.Set(field.NewCreditRating(v)) +} + +//SetEncodedIssuerLen sets EncodedIssuerLen, Tag 348 +func (m OrderCancelRequest) SetEncodedIssuerLen(v int) { + m.Set(field.NewEncodedIssuerLen(v)) +} + +//SetEncodedIssuer sets EncodedIssuer, Tag 349 +func (m OrderCancelRequest) SetEncodedIssuer(v string) { + m.Set(field.NewEncodedIssuer(v)) +} + +//SetEncodedSecurityDescLen sets EncodedSecurityDescLen, Tag 350 +func (m OrderCancelRequest) SetEncodedSecurityDescLen(v int) { + m.Set(field.NewEncodedSecurityDescLen(v)) +} + +//SetEncodedSecurityDesc sets EncodedSecurityDesc, Tag 351 +func (m OrderCancelRequest) SetEncodedSecurityDesc(v string) { + m.Set(field.NewEncodedSecurityDesc(v)) +} + +//SetEncodedTextLen sets EncodedTextLen, Tag 354 +func (m OrderCancelRequest) SetEncodedTextLen(v int) { + m.Set(field.NewEncodedTextLen(v)) +} + +//SetEncodedText sets EncodedText, Tag 355 +func (m OrderCancelRequest) SetEncodedText(v string) { + m.Set(field.NewEncodedText(v)) +} + +//SetComplianceID sets ComplianceID, Tag 376 +func (m OrderCancelRequest) SetComplianceID(v string) { + m.Set(field.NewComplianceID(v)) +} + +//SetNoPartyIDs sets NoPartyIDs, Tag 453 +func (m OrderCancelRequest) SetNoPartyIDs(f NoPartyIDsRepeatingGroup) { + m.SetGroup(f) +} + +//SetNoSecurityAltID sets NoSecurityAltID, Tag 454 +func (m OrderCancelRequest) SetNoSecurityAltID(f NoSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetProduct sets Product, Tag 460 +func (m OrderCancelRequest) SetProduct(v int) { + m.Set(field.NewProduct(v)) +} + +//SetCFICode sets CFICode, Tag 461 +func (m OrderCancelRequest) SetCFICode(v string) { + m.Set(field.NewCFICode(v)) +} + +//SetRoundingDirection sets RoundingDirection, Tag 468 +func (m OrderCancelRequest) SetRoundingDirection(v string) { + m.Set(field.NewRoundingDirection(v)) +} + +//SetRoundingModulus sets RoundingModulus, Tag 469 +func (m OrderCancelRequest) SetRoundingModulus(v float64) { + m.Set(field.NewRoundingModulus(v)) +} + +//SetCountryOfIssue sets CountryOfIssue, Tag 470 +func (m OrderCancelRequest) SetCountryOfIssue(v string) { + m.Set(field.NewCountryOfIssue(v)) +} + +//SetStateOrProvinceOfIssue sets StateOrProvinceOfIssue, Tag 471 +func (m OrderCancelRequest) SetStateOrProvinceOfIssue(v string) { + m.Set(field.NewStateOrProvinceOfIssue(v)) +} + +//SetLocaleOfIssue sets LocaleOfIssue, Tag 472 +func (m OrderCancelRequest) SetLocaleOfIssue(v string) { + m.Set(field.NewLocaleOfIssue(v)) +} + +//SetOrderPercent sets OrderPercent, Tag 516 +func (m OrderCancelRequest) SetOrderPercent(v float64) { + m.Set(field.NewOrderPercent(v)) +} + +//SetSecondaryClOrdID sets SecondaryClOrdID, Tag 526 +func (m OrderCancelRequest) SetSecondaryClOrdID(v string) { + m.Set(field.NewSecondaryClOrdID(v)) +} + +//SetMaturityDate sets MaturityDate, Tag 541 +func (m OrderCancelRequest) SetMaturityDate(v string) { + m.Set(field.NewMaturityDate(v)) +} + +//SetInstrRegistry sets InstrRegistry, Tag 543 +func (m OrderCancelRequest) SetInstrRegistry(v string) { + m.Set(field.NewInstrRegistry(v)) +} + +//SetAccountType sets AccountType, Tag 581 +func (m OrderCancelRequest) SetAccountType(v int) { + m.Set(field.NewAccountType(v)) +} + +//SetClOrdLinkID sets ClOrdLinkID, Tag 583 +func (m OrderCancelRequest) SetClOrdLinkID(v string) { + m.Set(field.NewClOrdLinkID(v)) +} + +//SetOrigOrdModTime sets OrigOrdModTime, Tag 586 +func (m OrderCancelRequest) SetOrigOrdModTime(v time.Time) { + m.Set(field.NewOrigOrdModTime(v)) +} + +//SetAcctIDSource sets AcctIDSource, Tag 660 +func (m OrderCancelRequest) SetAcctIDSource(v int) { + m.Set(field.NewAcctIDSource(v)) +} + +//SetContractSettlMonth sets ContractSettlMonth, Tag 667 +func (m OrderCancelRequest) SetContractSettlMonth(v string) { + m.Set(field.NewContractSettlMonth(v)) +} + +//SetPool sets Pool, Tag 691 +func (m OrderCancelRequest) SetPool(v string) { + m.Set(field.NewPool(v)) +} + +//SetNoUnderlyings sets NoUnderlyings, Tag 711 +func (m OrderCancelRequest) SetNoUnderlyings(f NoUnderlyingsRepeatingGroup) { + m.SetGroup(f) +} + +//SetSecuritySubType sets SecuritySubType, Tag 762 +func (m OrderCancelRequest) SetSecuritySubType(v string) { + m.Set(field.NewSecuritySubType(v)) +} + +//SetTerminationType sets TerminationType, Tag 788 +func (m OrderCancelRequest) SetTerminationType(v int) { + m.Set(field.NewTerminationType(v)) +} + +//SetNoEvents sets NoEvents, Tag 864 +func (m OrderCancelRequest) SetNoEvents(f NoEventsRepeatingGroup) { + m.SetGroup(f) +} + +//SetDatedDate sets DatedDate, Tag 873 +func (m OrderCancelRequest) SetDatedDate(v string) { + m.Set(field.NewDatedDate(v)) +} + +//SetInterestAccrualDate sets InterestAccrualDate, Tag 874 +func (m OrderCancelRequest) SetInterestAccrualDate(v string) { + m.Set(field.NewInterestAccrualDate(v)) +} + +//SetCPProgram sets CPProgram, Tag 875 +func (m OrderCancelRequest) SetCPProgram(v int) { + m.Set(field.NewCPProgram(v)) +} + +//SetCPRegType sets CPRegType, Tag 876 +func (m OrderCancelRequest) SetCPRegType(v string) { + m.Set(field.NewCPRegType(v)) +} + +//SetMarginRatio sets MarginRatio, Tag 898 +func (m OrderCancelRequest) SetMarginRatio(v float64) { + m.Set(field.NewMarginRatio(v)) +} + +//SetAgreementDesc sets AgreementDesc, Tag 913 +func (m OrderCancelRequest) SetAgreementDesc(v string) { + m.Set(field.NewAgreementDesc(v)) +} + +//SetAgreementID sets AgreementID, Tag 914 +func (m OrderCancelRequest) SetAgreementID(v string) { + m.Set(field.NewAgreementID(v)) +} + +//SetAgreementDate sets AgreementDate, Tag 915 +func (m OrderCancelRequest) SetAgreementDate(v string) { + m.Set(field.NewAgreementDate(v)) +} + +//SetStartDate sets StartDate, Tag 916 +func (m OrderCancelRequest) SetStartDate(v string) { + m.Set(field.NewStartDate(v)) +} + +//SetEndDate sets EndDate, Tag 917 +func (m OrderCancelRequest) SetEndDate(v string) { + m.Set(field.NewEndDate(v)) +} + +//SetAgreementCurrency sets AgreementCurrency, Tag 918 +func (m OrderCancelRequest) SetAgreementCurrency(v string) { + m.Set(field.NewAgreementCurrency(v)) +} + +//SetDeliveryType sets DeliveryType, Tag 919 +func (m OrderCancelRequest) SetDeliveryType(v int) { + m.Set(field.NewDeliveryType(v)) +} + +//SetStrikeCurrency sets StrikeCurrency, Tag 947 +func (m OrderCancelRequest) SetStrikeCurrency(v string) { + m.Set(field.NewStrikeCurrency(v)) +} + +//GetAccount gets Account, Tag 1 +func (m OrderCancelRequest) GetAccount() (f field.AccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdID gets ClOrdID, Tag 11 +func (m OrderCancelRequest) GetClOrdID() (f field.ClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityIDSource gets SecurityIDSource, Tag 22 +func (m OrderCancelRequest) GetSecurityIDSource() (f field.SecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderID gets OrderID, Tag 37 +func (m OrderCancelRequest) GetOrderID() (f field.OrderIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty gets OrderQty, Tag 38 +func (m OrderCancelRequest) GetOrderQty() (f field.OrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrigClOrdID gets OrigClOrdID, Tag 41 +func (m OrderCancelRequest) GetOrigClOrdID() (f field.OrigClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m OrderCancelRequest) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSide gets Side, Tag 54 +func (m OrderCancelRequest) GetSide() (f field.SideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbol gets Symbol, Tag 55 +func (m OrderCancelRequest) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetText gets Text, Tag 58 +func (m OrderCancelRequest) GetText() (f field.TextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTransactTime gets TransactTime, Tag 60 +func (m OrderCancelRequest) GetTransactTime() (f field.TransactTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m OrderCancelRequest) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetListID gets ListID, Tag 66 +func (m OrderCancelRequest) GetListID() (f field.ListIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m OrderCancelRequest) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m OrderCancelRequest) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashOrderQty gets CashOrderQty, Tag 152 +func (m OrderCancelRequest) GetCashOrderQty() (f field.CashOrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityType gets SecurityType, Tag 167 +func (m OrderCancelRequest) GetSecurityType() (f field.SecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityMonthYear gets MaturityMonthYear, Tag 200 +func (m OrderCancelRequest) GetMaturityMonthYear() (f field.MaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikePrice gets StrikePrice, Tag 202 +func (m OrderCancelRequest) GetStrikePrice() (f field.StrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOptAttribute gets OptAttribute, Tag 206 +func (m OrderCancelRequest) GetOptAttribute() (f field.OptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityExchange gets SecurityExchange, Tag 207 +func (m OrderCancelRequest) GetSecurityExchange() (f field.SecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponRate gets CouponRate, Tag 223 +func (m OrderCancelRequest) GetCouponRate() (f field.CouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponPaymentDate gets CouponPaymentDate, Tag 224 +func (m OrderCancelRequest) GetCouponPaymentDate() (f field.CouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssueDate gets IssueDate, Tag 225 +func (m OrderCancelRequest) GetIssueDate() (f field.IssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseTerm gets RepurchaseTerm, Tag 226 +func (m OrderCancelRequest) GetRepurchaseTerm() (f field.RepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseRate gets RepurchaseRate, Tag 227 +func (m OrderCancelRequest) GetRepurchaseRate() (f field.RepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFactor gets Factor, Tag 228 +func (m OrderCancelRequest) GetFactor() (f field.FactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractMultiplier gets ContractMultiplier, Tag 231 +func (m OrderCancelRequest) GetContractMultiplier() (f field.ContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepoCollateralSecurityType gets RepoCollateralSecurityType, Tag 239 +func (m OrderCancelRequest) GetRepoCollateralSecurityType() (f field.RepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRedemptionDate gets RedemptionDate, Tag 240 +func (m OrderCancelRequest) GetRedemptionDate() (f field.RedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCreditRating gets CreditRating, Tag 255 +func (m OrderCancelRequest) GetCreditRating() (f field.CreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuerLen gets EncodedIssuerLen, Tag 348 +func (m OrderCancelRequest) GetEncodedIssuerLen() (f field.EncodedIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuer gets EncodedIssuer, Tag 349 +func (m OrderCancelRequest) GetEncodedIssuer() (f field.EncodedIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDescLen gets EncodedSecurityDescLen, Tag 350 +func (m OrderCancelRequest) GetEncodedSecurityDescLen() (f field.EncodedSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDesc gets EncodedSecurityDesc, Tag 351 +func (m OrderCancelRequest) GetEncodedSecurityDesc() (f field.EncodedSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedTextLen gets EncodedTextLen, Tag 354 +func (m OrderCancelRequest) GetEncodedTextLen() (f field.EncodedTextLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedText gets EncodedText, Tag 355 +func (m OrderCancelRequest) GetEncodedText() (f field.EncodedTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetComplianceID gets ComplianceID, Tag 376 +func (m OrderCancelRequest) GetComplianceID() (f field.ComplianceIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoPartyIDs gets NoPartyIDs, Tag 453 +func (m OrderCancelRequest) GetNoPartyIDs() (NoPartyIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoPartyIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetNoSecurityAltID gets NoSecurityAltID, Tag 454 +func (m OrderCancelRequest) GetNoSecurityAltID() (NoSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetProduct gets Product, Tag 460 +func (m OrderCancelRequest) GetProduct() (f field.ProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCFICode gets CFICode, Tag 461 +func (m OrderCancelRequest) GetCFICode() (f field.CFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRoundingDirection gets RoundingDirection, Tag 468 +func (m OrderCancelRequest) GetRoundingDirection() (f field.RoundingDirectionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRoundingModulus gets RoundingModulus, Tag 469 +func (m OrderCancelRequest) GetRoundingModulus() (f field.RoundingModulusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCountryOfIssue gets CountryOfIssue, Tag 470 +func (m OrderCancelRequest) GetCountryOfIssue() (f field.CountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStateOrProvinceOfIssue gets StateOrProvinceOfIssue, Tag 471 +func (m OrderCancelRequest) GetStateOrProvinceOfIssue() (f field.StateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLocaleOfIssue gets LocaleOfIssue, Tag 472 +func (m OrderCancelRequest) GetLocaleOfIssue() (f field.LocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderPercent gets OrderPercent, Tag 516 +func (m OrderCancelRequest) GetOrderPercent() (f field.OrderPercentField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecondaryClOrdID gets SecondaryClOrdID, Tag 526 +func (m OrderCancelRequest) GetSecondaryClOrdID() (f field.SecondaryClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityDate gets MaturityDate, Tag 541 +func (m OrderCancelRequest) GetMaturityDate() (f field.MaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrRegistry gets InstrRegistry, Tag 543 +func (m OrderCancelRequest) GetInstrRegistry() (f field.InstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAccountType gets AccountType, Tag 581 +func (m OrderCancelRequest) GetAccountType() (f field.AccountTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdLinkID gets ClOrdLinkID, Tag 583 +func (m OrderCancelRequest) GetClOrdLinkID() (f field.ClOrdLinkIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrigOrdModTime gets OrigOrdModTime, Tag 586 +func (m OrderCancelRequest) GetOrigOrdModTime() (f field.OrigOrdModTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAcctIDSource gets AcctIDSource, Tag 660 +func (m OrderCancelRequest) GetAcctIDSource() (f field.AcctIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractSettlMonth gets ContractSettlMonth, Tag 667 +func (m OrderCancelRequest) GetContractSettlMonth() (f field.ContractSettlMonthField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPool gets Pool, Tag 691 +func (m OrderCancelRequest) GetPool() (f field.PoolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyings gets NoUnderlyings, Tag 711 +func (m OrderCancelRequest) GetNoUnderlyings() (NoUnderlyingsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetSecuritySubType gets SecuritySubType, Tag 762 +func (m OrderCancelRequest) GetSecuritySubType() (f field.SecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTerminationType gets TerminationType, Tag 788 +func (m OrderCancelRequest) GetTerminationType() (f field.TerminationTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoEvents gets NoEvents, Tag 864 +func (m OrderCancelRequest) GetNoEvents() (NoEventsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoEventsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetDatedDate gets DatedDate, Tag 873 +func (m OrderCancelRequest) GetDatedDate() (f field.DatedDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInterestAccrualDate gets InterestAccrualDate, Tag 874 +func (m OrderCancelRequest) GetInterestAccrualDate() (f field.InterestAccrualDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCPProgram gets CPProgram, Tag 875 +func (m OrderCancelRequest) GetCPProgram() (f field.CPProgramField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCPRegType gets CPRegType, Tag 876 +func (m OrderCancelRequest) GetCPRegType() (f field.CPRegTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMarginRatio gets MarginRatio, Tag 898 +func (m OrderCancelRequest) GetMarginRatio() (f field.MarginRatioField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementDesc gets AgreementDesc, Tag 913 +func (m OrderCancelRequest) GetAgreementDesc() (f field.AgreementDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementID gets AgreementID, Tag 914 +func (m OrderCancelRequest) GetAgreementID() (f field.AgreementIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementDate gets AgreementDate, Tag 915 +func (m OrderCancelRequest) GetAgreementDate() (f field.AgreementDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStartDate gets StartDate, Tag 916 +func (m OrderCancelRequest) GetStartDate() (f field.StartDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEndDate gets EndDate, Tag 917 +func (m OrderCancelRequest) GetEndDate() (f field.EndDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementCurrency gets AgreementCurrency, Tag 918 +func (m OrderCancelRequest) GetAgreementCurrency() (f field.AgreementCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDeliveryType gets DeliveryType, Tag 919 +func (m OrderCancelRequest) GetDeliveryType() (f field.DeliveryTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikeCurrency gets StrikeCurrency, Tag 947 +func (m OrderCancelRequest) GetStrikeCurrency() (f field.StrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasAccount returns true if Account is present, Tag 1 +func (m OrderCancelRequest) HasAccount() bool { + return m.Has(tag.Account) +} + +//HasClOrdID returns true if ClOrdID is present, Tag 11 +func (m OrderCancelRequest) HasClOrdID() bool { + return m.Has(tag.ClOrdID) +} + +//HasSecurityIDSource returns true if SecurityIDSource is present, Tag 22 +func (m OrderCancelRequest) HasSecurityIDSource() bool { + return m.Has(tag.SecurityIDSource) +} + +//HasOrderID returns true if OrderID is present, Tag 37 +func (m OrderCancelRequest) HasOrderID() bool { + return m.Has(tag.OrderID) +} + +//HasOrderQty returns true if OrderQty is present, Tag 38 +func (m OrderCancelRequest) HasOrderQty() bool { + return m.Has(tag.OrderQty) +} + +//HasOrigClOrdID returns true if OrigClOrdID is present, Tag 41 +func (m OrderCancelRequest) HasOrigClOrdID() bool { + return m.Has(tag.OrigClOrdID) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m OrderCancelRequest) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSide returns true if Side is present, Tag 54 +func (m OrderCancelRequest) HasSide() bool { + return m.Has(tag.Side) +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m OrderCancelRequest) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasText returns true if Text is present, Tag 58 +func (m OrderCancelRequest) HasText() bool { + return m.Has(tag.Text) +} + +//HasTransactTime returns true if TransactTime is present, Tag 60 +func (m OrderCancelRequest) HasTransactTime() bool { + return m.Has(tag.TransactTime) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m OrderCancelRequest) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasListID returns true if ListID is present, Tag 66 +func (m OrderCancelRequest) HasListID() bool { + return m.Has(tag.ListID) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m OrderCancelRequest) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m OrderCancelRequest) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasCashOrderQty returns true if CashOrderQty is present, Tag 152 +func (m OrderCancelRequest) HasCashOrderQty() bool { + return m.Has(tag.CashOrderQty) +} + +//HasSecurityType returns true if SecurityType is present, Tag 167 +func (m OrderCancelRequest) HasSecurityType() bool { + return m.Has(tag.SecurityType) +} + +//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200 +func (m OrderCancelRequest) HasMaturityMonthYear() bool { + return m.Has(tag.MaturityMonthYear) +} + +//HasStrikePrice returns true if StrikePrice is present, Tag 202 +func (m OrderCancelRequest) HasStrikePrice() bool { + return m.Has(tag.StrikePrice) +} + +//HasOptAttribute returns true if OptAttribute is present, Tag 206 +func (m OrderCancelRequest) HasOptAttribute() bool { + return m.Has(tag.OptAttribute) +} + +//HasSecurityExchange returns true if SecurityExchange is present, Tag 207 +func (m OrderCancelRequest) HasSecurityExchange() bool { + return m.Has(tag.SecurityExchange) +} + +//HasCouponRate returns true if CouponRate is present, Tag 223 +func (m OrderCancelRequest) HasCouponRate() bool { + return m.Has(tag.CouponRate) +} + +//HasCouponPaymentDate returns true if CouponPaymentDate is present, Tag 224 +func (m OrderCancelRequest) HasCouponPaymentDate() bool { + return m.Has(tag.CouponPaymentDate) +} + +//HasIssueDate returns true if IssueDate is present, Tag 225 +func (m OrderCancelRequest) HasIssueDate() bool { + return m.Has(tag.IssueDate) +} + +//HasRepurchaseTerm returns true if RepurchaseTerm is present, Tag 226 +func (m OrderCancelRequest) HasRepurchaseTerm() bool { + return m.Has(tag.RepurchaseTerm) +} + +//HasRepurchaseRate returns true if RepurchaseRate is present, Tag 227 +func (m OrderCancelRequest) HasRepurchaseRate() bool { + return m.Has(tag.RepurchaseRate) +} + +//HasFactor returns true if Factor is present, Tag 228 +func (m OrderCancelRequest) HasFactor() bool { + return m.Has(tag.Factor) +} + +//HasContractMultiplier returns true if ContractMultiplier is present, Tag 231 +func (m OrderCancelRequest) HasContractMultiplier() bool { + return m.Has(tag.ContractMultiplier) +} + +//HasRepoCollateralSecurityType returns true if RepoCollateralSecurityType is present, Tag 239 +func (m OrderCancelRequest) HasRepoCollateralSecurityType() bool { + return m.Has(tag.RepoCollateralSecurityType) +} + +//HasRedemptionDate returns true if RedemptionDate is present, Tag 240 +func (m OrderCancelRequest) HasRedemptionDate() bool { + return m.Has(tag.RedemptionDate) +} + +//HasCreditRating returns true if CreditRating is present, Tag 255 +func (m OrderCancelRequest) HasCreditRating() bool { + return m.Has(tag.CreditRating) +} + +//HasEncodedIssuerLen returns true if EncodedIssuerLen is present, Tag 348 +func (m OrderCancelRequest) HasEncodedIssuerLen() bool { + return m.Has(tag.EncodedIssuerLen) +} + +//HasEncodedIssuer returns true if EncodedIssuer is present, Tag 349 +func (m OrderCancelRequest) HasEncodedIssuer() bool { + return m.Has(tag.EncodedIssuer) +} + +//HasEncodedSecurityDescLen returns true if EncodedSecurityDescLen is present, Tag 350 +func (m OrderCancelRequest) HasEncodedSecurityDescLen() bool { + return m.Has(tag.EncodedSecurityDescLen) +} + +//HasEncodedSecurityDesc returns true if EncodedSecurityDesc is present, Tag 351 +func (m OrderCancelRequest) HasEncodedSecurityDesc() bool { + return m.Has(tag.EncodedSecurityDesc) +} + +//HasEncodedTextLen returns true if EncodedTextLen is present, Tag 354 +func (m OrderCancelRequest) HasEncodedTextLen() bool { + return m.Has(tag.EncodedTextLen) +} + +//HasEncodedText returns true if EncodedText is present, Tag 355 +func (m OrderCancelRequest) HasEncodedText() bool { + return m.Has(tag.EncodedText) +} + +//HasComplianceID returns true if ComplianceID is present, Tag 376 +func (m OrderCancelRequest) HasComplianceID() bool { + return m.Has(tag.ComplianceID) +} + +//HasNoPartyIDs returns true if NoPartyIDs is present, Tag 453 +func (m OrderCancelRequest) HasNoPartyIDs() bool { + return m.Has(tag.NoPartyIDs) +} + +//HasNoSecurityAltID returns true if NoSecurityAltID is present, Tag 454 +func (m OrderCancelRequest) HasNoSecurityAltID() bool { + return m.Has(tag.NoSecurityAltID) +} + +//HasProduct returns true if Product is present, Tag 460 +func (m OrderCancelRequest) HasProduct() bool { + return m.Has(tag.Product) +} + +//HasCFICode returns true if CFICode is present, Tag 461 +func (m OrderCancelRequest) HasCFICode() bool { + return m.Has(tag.CFICode) +} + +//HasRoundingDirection returns true if RoundingDirection is present, Tag 468 +func (m OrderCancelRequest) HasRoundingDirection() bool { + return m.Has(tag.RoundingDirection) +} + +//HasRoundingModulus returns true if RoundingModulus is present, Tag 469 +func (m OrderCancelRequest) HasRoundingModulus() bool { + return m.Has(tag.RoundingModulus) +} + +//HasCountryOfIssue returns true if CountryOfIssue is present, Tag 470 +func (m OrderCancelRequest) HasCountryOfIssue() bool { + return m.Has(tag.CountryOfIssue) +} + +//HasStateOrProvinceOfIssue returns true if StateOrProvinceOfIssue is present, Tag 471 +func (m OrderCancelRequest) HasStateOrProvinceOfIssue() bool { + return m.Has(tag.StateOrProvinceOfIssue) +} + +//HasLocaleOfIssue returns true if LocaleOfIssue is present, Tag 472 +func (m OrderCancelRequest) HasLocaleOfIssue() bool { + return m.Has(tag.LocaleOfIssue) +} + +//HasOrderPercent returns true if OrderPercent is present, Tag 516 +func (m OrderCancelRequest) HasOrderPercent() bool { + return m.Has(tag.OrderPercent) +} + +//HasSecondaryClOrdID returns true if SecondaryClOrdID is present, Tag 526 +func (m OrderCancelRequest) HasSecondaryClOrdID() bool { + return m.Has(tag.SecondaryClOrdID) +} + +//HasMaturityDate returns true if MaturityDate is present, Tag 541 +func (m OrderCancelRequest) HasMaturityDate() bool { + return m.Has(tag.MaturityDate) +} + +//HasInstrRegistry returns true if InstrRegistry is present, Tag 543 +func (m OrderCancelRequest) HasInstrRegistry() bool { + return m.Has(tag.InstrRegistry) +} + +//HasAccountType returns true if AccountType is present, Tag 581 +func (m OrderCancelRequest) HasAccountType() bool { + return m.Has(tag.AccountType) +} + +//HasClOrdLinkID returns true if ClOrdLinkID is present, Tag 583 +func (m OrderCancelRequest) HasClOrdLinkID() bool { + return m.Has(tag.ClOrdLinkID) +} + +//HasOrigOrdModTime returns true if OrigOrdModTime is present, Tag 586 +func (m OrderCancelRequest) HasOrigOrdModTime() bool { + return m.Has(tag.OrigOrdModTime) +} + +//HasAcctIDSource returns true if AcctIDSource is present, Tag 660 +func (m OrderCancelRequest) HasAcctIDSource() bool { + return m.Has(tag.AcctIDSource) +} + +//HasContractSettlMonth returns true if ContractSettlMonth is present, Tag 667 +func (m OrderCancelRequest) HasContractSettlMonth() bool { + return m.Has(tag.ContractSettlMonth) +} + +//HasPool returns true if Pool is present, Tag 691 +func (m OrderCancelRequest) HasPool() bool { + return m.Has(tag.Pool) +} + +//HasNoUnderlyings returns true if NoUnderlyings is present, Tag 711 +func (m OrderCancelRequest) HasNoUnderlyings() bool { + return m.Has(tag.NoUnderlyings) +} + +//HasSecuritySubType returns true if SecuritySubType is present, Tag 762 +func (m OrderCancelRequest) HasSecuritySubType() bool { + return m.Has(tag.SecuritySubType) +} + +//HasTerminationType returns true if TerminationType is present, Tag 788 +func (m OrderCancelRequest) HasTerminationType() bool { + return m.Has(tag.TerminationType) +} + +//HasNoEvents returns true if NoEvents is present, Tag 864 +func (m OrderCancelRequest) HasNoEvents() bool { + return m.Has(tag.NoEvents) +} + +//HasDatedDate returns true if DatedDate is present, Tag 873 +func (m OrderCancelRequest) HasDatedDate() bool { + return m.Has(tag.DatedDate) +} + +//HasInterestAccrualDate returns true if InterestAccrualDate is present, Tag 874 +func (m OrderCancelRequest) HasInterestAccrualDate() bool { + return m.Has(tag.InterestAccrualDate) +} + +//HasCPProgram returns true if CPProgram is present, Tag 875 +func (m OrderCancelRequest) HasCPProgram() bool { + return m.Has(tag.CPProgram) +} + +//HasCPRegType returns true if CPRegType is present, Tag 876 +func (m OrderCancelRequest) HasCPRegType() bool { + return m.Has(tag.CPRegType) +} + +//HasMarginRatio returns true if MarginRatio is present, Tag 898 +func (m OrderCancelRequest) HasMarginRatio() bool { + return m.Has(tag.MarginRatio) +} + +//HasAgreementDesc returns true if AgreementDesc is present, Tag 913 +func (m OrderCancelRequest) HasAgreementDesc() bool { + return m.Has(tag.AgreementDesc) +} + +//HasAgreementID returns true if AgreementID is present, Tag 914 +func (m OrderCancelRequest) HasAgreementID() bool { + return m.Has(tag.AgreementID) +} + +//HasAgreementDate returns true if AgreementDate is present, Tag 915 +func (m OrderCancelRequest) HasAgreementDate() bool { + return m.Has(tag.AgreementDate) +} + +//HasStartDate returns true if StartDate is present, Tag 916 +func (m OrderCancelRequest) HasStartDate() bool { + return m.Has(tag.StartDate) +} + +//HasEndDate returns true if EndDate is present, Tag 917 +func (m OrderCancelRequest) HasEndDate() bool { + return m.Has(tag.EndDate) +} + +//HasAgreementCurrency returns true if AgreementCurrency is present, Tag 918 +func (m OrderCancelRequest) HasAgreementCurrency() bool { + return m.Has(tag.AgreementCurrency) +} + +//HasDeliveryType returns true if DeliveryType is present, Tag 919 +func (m OrderCancelRequest) HasDeliveryType() bool { + return m.Has(tag.DeliveryType) +} + +//HasStrikeCurrency returns true if StrikeCurrency is present, Tag 947 +func (m OrderCancelRequest) HasStrikeCurrency() bool { + return m.Has(tag.StrikeCurrency) +} + +//NoPartyIDs is a repeating group element, Tag 453 +type NoPartyIDs struct { + quickfix.Group +} + +//SetPartyID sets PartyID, Tag 448 +func (m NoPartyIDs) SetPartyID(v string) { + m.Set(field.NewPartyID(v)) +} + +//SetPartyIDSource sets PartyIDSource, Tag 447 +func (m NoPartyIDs) SetPartyIDSource(v string) { + m.Set(field.NewPartyIDSource(v)) +} + +//SetPartyRole sets PartyRole, Tag 452 +func (m NoPartyIDs) SetPartyRole(v int) { + m.Set(field.NewPartyRole(v)) +} + +//SetNoPartySubIDs sets NoPartySubIDs, Tag 802 +func (m NoPartyIDs) SetNoPartySubIDs(f NoPartySubIDsRepeatingGroup) { + m.SetGroup(f) +} + +//GetPartyID gets PartyID, Tag 448 +func (m NoPartyIDs) GetPartyID() (f field.PartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartyIDSource gets PartyIDSource, Tag 447 +func (m NoPartyIDs) GetPartyIDSource() (f field.PartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartyRole gets PartyRole, Tag 452 +func (m NoPartyIDs) GetPartyRole() (f field.PartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoPartySubIDs gets NoPartySubIDs, Tag 802 +func (m NoPartyIDs) GetNoPartySubIDs() (NoPartySubIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoPartySubIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasPartyID returns true if PartyID is present, Tag 448 +func (m NoPartyIDs) HasPartyID() bool { + return m.Has(tag.PartyID) +} + +//HasPartyIDSource returns true if PartyIDSource is present, Tag 447 +func (m NoPartyIDs) HasPartyIDSource() bool { + return m.Has(tag.PartyIDSource) +} + +//HasPartyRole returns true if PartyRole is present, Tag 452 +func (m NoPartyIDs) HasPartyRole() bool { + return m.Has(tag.PartyRole) +} + +//HasNoPartySubIDs returns true if NoPartySubIDs is present, Tag 802 +func (m NoPartyIDs) HasNoPartySubIDs() bool { + return m.Has(tag.NoPartySubIDs) +} + +//NoPartySubIDs is a repeating group element, Tag 802 +type NoPartySubIDs struct { + quickfix.Group +} + +//SetPartySubID sets PartySubID, Tag 523 +func (m NoPartySubIDs) SetPartySubID(v string) { + m.Set(field.NewPartySubID(v)) +} + +//SetPartySubIDType sets PartySubIDType, Tag 803 +func (m NoPartySubIDs) SetPartySubIDType(v int) { + m.Set(field.NewPartySubIDType(v)) +} + +//GetPartySubID gets PartySubID, Tag 523 +func (m NoPartySubIDs) GetPartySubID() (f field.PartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartySubIDType gets PartySubIDType, Tag 803 +func (m NoPartySubIDs) GetPartySubIDType() (f field.PartySubIDTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasPartySubID returns true if PartySubID is present, Tag 523 +func (m NoPartySubIDs) HasPartySubID() bool { + return m.Has(tag.PartySubID) +} + +//HasPartySubIDType returns true if PartySubIDType is present, Tag 803 +func (m NoPartySubIDs) HasPartySubIDType() bool { + return m.Has(tag.PartySubIDType) +} + +//NoPartySubIDsRepeatingGroup is a repeating group, Tag 802 +type NoPartySubIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoPartySubIDsRepeatingGroup returns an initialized, NoPartySubIDsRepeatingGroup +func NewNoPartySubIDsRepeatingGroup() NoPartySubIDsRepeatingGroup { + return NoPartySubIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoPartySubIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.PartySubID), quickfix.GroupElement(tag.PartySubIDType)})} +} + +//Add create and append a new NoPartySubIDs to this group +func (m NoPartySubIDsRepeatingGroup) Add() NoPartySubIDs { + g := m.RepeatingGroup.Add() + return NoPartySubIDs{g} +} + +//Get returns the ith NoPartySubIDs in the NoPartySubIDsRepeatinGroup +func (m NoPartySubIDsRepeatingGroup) Get(i int) NoPartySubIDs { + return NoPartySubIDs{m.RepeatingGroup.Get(i)} +} + +//NoPartyIDsRepeatingGroup is a repeating group, Tag 453 +type NoPartyIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoPartyIDsRepeatingGroup returns an initialized, NoPartyIDsRepeatingGroup +func NewNoPartyIDsRepeatingGroup() NoPartyIDsRepeatingGroup { + return NoPartyIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoPartyIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.PartyID), quickfix.GroupElement(tag.PartyIDSource), quickfix.GroupElement(tag.PartyRole), NewNoPartySubIDsRepeatingGroup()})} +} + +//Add create and append a new NoPartyIDs to this group +func (m NoPartyIDsRepeatingGroup) Add() NoPartyIDs { + g := m.RepeatingGroup.Add() + return NoPartyIDs{g} +} + +//Get returns the ith NoPartyIDs in the NoPartyIDsRepeatinGroup +func (m NoPartyIDsRepeatingGroup) Get(i int) NoPartyIDs { + return NoPartyIDs{m.RepeatingGroup.Get(i)} +} + +//NoSecurityAltID is a repeating group element, Tag 454 +type NoSecurityAltID struct { + quickfix.Group +} + +//SetSecurityAltID sets SecurityAltID, Tag 455 +func (m NoSecurityAltID) SetSecurityAltID(v string) { + m.Set(field.NewSecurityAltID(v)) +} + +//SetSecurityAltIDSource sets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) SetSecurityAltIDSource(v string) { + m.Set(field.NewSecurityAltIDSource(v)) +} + +//GetSecurityAltID gets SecurityAltID, Tag 455 +func (m NoSecurityAltID) GetSecurityAltID() (f field.SecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityAltIDSource gets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) GetSecurityAltIDSource() (f field.SecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasSecurityAltID returns true if SecurityAltID is present, Tag 455 +func (m NoSecurityAltID) HasSecurityAltID() bool { + return m.Has(tag.SecurityAltID) +} + +//HasSecurityAltIDSource returns true if SecurityAltIDSource is present, Tag 456 +func (m NoSecurityAltID) HasSecurityAltIDSource() bool { + return m.Has(tag.SecurityAltIDSource) +} + +//NoSecurityAltIDRepeatingGroup is a repeating group, Tag 454 +type NoSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoSecurityAltIDRepeatingGroup returns an initialized, NoSecurityAltIDRepeatingGroup +func NewNoSecurityAltIDRepeatingGroup() NoSecurityAltIDRepeatingGroup { + return NoSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.SecurityAltID), quickfix.GroupElement(tag.SecurityAltIDSource)})} +} + +//Add create and append a new NoSecurityAltID to this group +func (m NoSecurityAltIDRepeatingGroup) Add() NoSecurityAltID { + g := m.RepeatingGroup.Add() + return NoSecurityAltID{g} +} + +//Get returns the ith NoSecurityAltID in the NoSecurityAltIDRepeatinGroup +func (m NoSecurityAltIDRepeatingGroup) Get(i int) NoSecurityAltID { + return NoSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyings is a repeating group element, Tag 711 +type NoUnderlyings struct { + quickfix.Group +} + +//SetUnderlyingSymbol sets UnderlyingSymbol, Tag 311 +func (m NoUnderlyings) SetUnderlyingSymbol(v string) { + m.Set(field.NewUnderlyingSymbol(v)) +} + +//SetUnderlyingSymbolSfx sets UnderlyingSymbolSfx, Tag 312 +func (m NoUnderlyings) SetUnderlyingSymbolSfx(v string) { + m.Set(field.NewUnderlyingSymbolSfx(v)) +} + +//SetUnderlyingSecurityID sets UnderlyingSecurityID, Tag 309 +func (m NoUnderlyings) SetUnderlyingSecurityID(v string) { + m.Set(field.NewUnderlyingSecurityID(v)) +} + +//SetUnderlyingSecurityIDSource sets UnderlyingSecurityIDSource, Tag 305 +func (m NoUnderlyings) SetUnderlyingSecurityIDSource(v string) { + m.Set(field.NewUnderlyingSecurityIDSource(v)) +} + +//SetNoUnderlyingSecurityAltID sets NoUnderlyingSecurityAltID, Tag 457 +func (m NoUnderlyings) SetNoUnderlyingSecurityAltID(f NoUnderlyingSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetUnderlyingProduct sets UnderlyingProduct, Tag 462 +func (m NoUnderlyings) SetUnderlyingProduct(v int) { + m.Set(field.NewUnderlyingProduct(v)) +} + +//SetUnderlyingCFICode sets UnderlyingCFICode, Tag 463 +func (m NoUnderlyings) SetUnderlyingCFICode(v string) { + m.Set(field.NewUnderlyingCFICode(v)) +} + +//SetUnderlyingSecurityType sets UnderlyingSecurityType, Tag 310 +func (m NoUnderlyings) SetUnderlyingSecurityType(v string) { + m.Set(field.NewUnderlyingSecurityType(v)) +} + +//SetUnderlyingSecuritySubType sets UnderlyingSecuritySubType, Tag 763 +func (m NoUnderlyings) SetUnderlyingSecuritySubType(v string) { + m.Set(field.NewUnderlyingSecuritySubType(v)) +} + +//SetUnderlyingMaturityMonthYear sets UnderlyingMaturityMonthYear, Tag 313 +func (m NoUnderlyings) SetUnderlyingMaturityMonthYear(v string) { + m.Set(field.NewUnderlyingMaturityMonthYear(v)) +} + +//SetUnderlyingMaturityDate sets UnderlyingMaturityDate, Tag 542 +func (m NoUnderlyings) SetUnderlyingMaturityDate(v string) { + m.Set(field.NewUnderlyingMaturityDate(v)) +} + +//SetUnderlyingCouponPaymentDate sets UnderlyingCouponPaymentDate, Tag 241 +func (m NoUnderlyings) SetUnderlyingCouponPaymentDate(v string) { + m.Set(field.NewUnderlyingCouponPaymentDate(v)) +} + +//SetUnderlyingIssueDate sets UnderlyingIssueDate, Tag 242 +func (m NoUnderlyings) SetUnderlyingIssueDate(v string) { + m.Set(field.NewUnderlyingIssueDate(v)) +} + +//SetUnderlyingRepoCollateralSecurityType sets UnderlyingRepoCollateralSecurityType, Tag 243 +func (m NoUnderlyings) SetUnderlyingRepoCollateralSecurityType(v int) { + m.Set(field.NewUnderlyingRepoCollateralSecurityType(v)) +} + +//SetUnderlyingRepurchaseTerm sets UnderlyingRepurchaseTerm, Tag 244 +func (m NoUnderlyings) SetUnderlyingRepurchaseTerm(v int) { + m.Set(field.NewUnderlyingRepurchaseTerm(v)) +} + +//SetUnderlyingRepurchaseRate sets UnderlyingRepurchaseRate, Tag 245 +func (m NoUnderlyings) SetUnderlyingRepurchaseRate(v float64) { + m.Set(field.NewUnderlyingRepurchaseRate(v)) +} + +//SetUnderlyingFactor sets UnderlyingFactor, Tag 246 +func (m NoUnderlyings) SetUnderlyingFactor(v float64) { + m.Set(field.NewUnderlyingFactor(v)) +} + +//SetUnderlyingCreditRating sets UnderlyingCreditRating, Tag 256 +func (m NoUnderlyings) SetUnderlyingCreditRating(v string) { + m.Set(field.NewUnderlyingCreditRating(v)) +} + +//SetUnderlyingInstrRegistry sets UnderlyingInstrRegistry, Tag 595 +func (m NoUnderlyings) SetUnderlyingInstrRegistry(v string) { + m.Set(field.NewUnderlyingInstrRegistry(v)) +} + +//SetUnderlyingCountryOfIssue sets UnderlyingCountryOfIssue, Tag 592 +func (m NoUnderlyings) SetUnderlyingCountryOfIssue(v string) { + m.Set(field.NewUnderlyingCountryOfIssue(v)) +} + +//SetUnderlyingStateOrProvinceOfIssue sets UnderlyingStateOrProvinceOfIssue, Tag 593 +func (m NoUnderlyings) SetUnderlyingStateOrProvinceOfIssue(v string) { + m.Set(field.NewUnderlyingStateOrProvinceOfIssue(v)) +} + +//SetUnderlyingLocaleOfIssue sets UnderlyingLocaleOfIssue, Tag 594 +func (m NoUnderlyings) SetUnderlyingLocaleOfIssue(v string) { + m.Set(field.NewUnderlyingLocaleOfIssue(v)) +} + +//SetUnderlyingRedemptionDate sets UnderlyingRedemptionDate, Tag 247 +func (m NoUnderlyings) SetUnderlyingRedemptionDate(v string) { + m.Set(field.NewUnderlyingRedemptionDate(v)) +} + +//SetUnderlyingStrikePrice sets UnderlyingStrikePrice, Tag 316 +func (m NoUnderlyings) SetUnderlyingStrikePrice(v float64) { + m.Set(field.NewUnderlyingStrikePrice(v)) +} + +//SetUnderlyingStrikeCurrency sets UnderlyingStrikeCurrency, Tag 941 +func (m NoUnderlyings) SetUnderlyingStrikeCurrency(v string) { + m.Set(field.NewUnderlyingStrikeCurrency(v)) +} + +//SetUnderlyingOptAttribute sets UnderlyingOptAttribute, Tag 317 +func (m NoUnderlyings) SetUnderlyingOptAttribute(v string) { + m.Set(field.NewUnderlyingOptAttribute(v)) +} + +//SetUnderlyingContractMultiplier sets UnderlyingContractMultiplier, Tag 436 +func (m NoUnderlyings) SetUnderlyingContractMultiplier(v float64) { + m.Set(field.NewUnderlyingContractMultiplier(v)) +} + +//SetUnderlyingCouponRate sets UnderlyingCouponRate, Tag 435 +func (m NoUnderlyings) SetUnderlyingCouponRate(v float64) { + m.Set(field.NewUnderlyingCouponRate(v)) +} + +//SetUnderlyingSecurityExchange sets UnderlyingSecurityExchange, Tag 308 +func (m NoUnderlyings) SetUnderlyingSecurityExchange(v string) { + m.Set(field.NewUnderlyingSecurityExchange(v)) +} + +//SetUnderlyingIssuer sets UnderlyingIssuer, Tag 306 +func (m NoUnderlyings) SetUnderlyingIssuer(v string) { + m.Set(field.NewUnderlyingIssuer(v)) +} + +//SetEncodedUnderlyingIssuerLen sets EncodedUnderlyingIssuerLen, Tag 362 +func (m NoUnderlyings) SetEncodedUnderlyingIssuerLen(v int) { + m.Set(field.NewEncodedUnderlyingIssuerLen(v)) +} + +//SetEncodedUnderlyingIssuer sets EncodedUnderlyingIssuer, Tag 363 +func (m NoUnderlyings) SetEncodedUnderlyingIssuer(v string) { + m.Set(field.NewEncodedUnderlyingIssuer(v)) +} + +//SetUnderlyingSecurityDesc sets UnderlyingSecurityDesc, Tag 307 +func (m NoUnderlyings) SetUnderlyingSecurityDesc(v string) { + m.Set(field.NewUnderlyingSecurityDesc(v)) +} + +//SetEncodedUnderlyingSecurityDescLen sets EncodedUnderlyingSecurityDescLen, Tag 364 +func (m NoUnderlyings) SetEncodedUnderlyingSecurityDescLen(v int) { + m.Set(field.NewEncodedUnderlyingSecurityDescLen(v)) +} + +//SetEncodedUnderlyingSecurityDesc sets EncodedUnderlyingSecurityDesc, Tag 365 +func (m NoUnderlyings) SetEncodedUnderlyingSecurityDesc(v string) { + m.Set(field.NewEncodedUnderlyingSecurityDesc(v)) +} + +//SetUnderlyingCPProgram sets UnderlyingCPProgram, Tag 877 +func (m NoUnderlyings) SetUnderlyingCPProgram(v string) { + m.Set(field.NewUnderlyingCPProgram(v)) +} + +//SetUnderlyingCPRegType sets UnderlyingCPRegType, Tag 878 +func (m NoUnderlyings) SetUnderlyingCPRegType(v string) { + m.Set(field.NewUnderlyingCPRegType(v)) +} + +//SetUnderlyingCurrency sets UnderlyingCurrency, Tag 318 +func (m NoUnderlyings) SetUnderlyingCurrency(v string) { + m.Set(field.NewUnderlyingCurrency(v)) +} + +//SetUnderlyingQty sets UnderlyingQty, Tag 879 +func (m NoUnderlyings) SetUnderlyingQty(v float64) { + m.Set(field.NewUnderlyingQty(v)) +} + +//SetUnderlyingPx sets UnderlyingPx, Tag 810 +func (m NoUnderlyings) SetUnderlyingPx(v float64) { + m.Set(field.NewUnderlyingPx(v)) +} + +//SetUnderlyingDirtyPrice sets UnderlyingDirtyPrice, Tag 882 +func (m NoUnderlyings) SetUnderlyingDirtyPrice(v float64) { + m.Set(field.NewUnderlyingDirtyPrice(v)) +} + +//SetUnderlyingEndPrice sets UnderlyingEndPrice, Tag 883 +func (m NoUnderlyings) SetUnderlyingEndPrice(v float64) { + m.Set(field.NewUnderlyingEndPrice(v)) +} + +//SetUnderlyingStartValue sets UnderlyingStartValue, Tag 884 +func (m NoUnderlyings) SetUnderlyingStartValue(v float64) { + m.Set(field.NewUnderlyingStartValue(v)) +} + +//SetUnderlyingCurrentValue sets UnderlyingCurrentValue, Tag 885 +func (m NoUnderlyings) SetUnderlyingCurrentValue(v float64) { + m.Set(field.NewUnderlyingCurrentValue(v)) +} + +//SetUnderlyingEndValue sets UnderlyingEndValue, Tag 886 +func (m NoUnderlyings) SetUnderlyingEndValue(v float64) { + m.Set(field.NewUnderlyingEndValue(v)) +} + +//SetNoUnderlyingStips sets NoUnderlyingStips, Tag 887 +func (m NoUnderlyings) SetNoUnderlyingStips(f NoUnderlyingStipsRepeatingGroup) { + m.SetGroup(f) +} + +//GetUnderlyingSymbol gets UnderlyingSymbol, Tag 311 +func (m NoUnderlyings) GetUnderlyingSymbol() (f field.UnderlyingSymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSymbolSfx gets UnderlyingSymbolSfx, Tag 312 +func (m NoUnderlyings) GetUnderlyingSymbolSfx() (f field.UnderlyingSymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityID gets UnderlyingSecurityID, Tag 309 +func (m NoUnderlyings) GetUnderlyingSecurityID() (f field.UnderlyingSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityIDSource gets UnderlyingSecurityIDSource, Tag 305 +func (m NoUnderlyings) GetUnderlyingSecurityIDSource() (f field.UnderlyingSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyingSecurityAltID gets NoUnderlyingSecurityAltID, Tag 457 +func (m NoUnderlyings) GetNoUnderlyingSecurityAltID() (NoUnderlyingSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetUnderlyingProduct gets UnderlyingProduct, Tag 462 +func (m NoUnderlyings) GetUnderlyingProduct() (f field.UnderlyingProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCFICode gets UnderlyingCFICode, Tag 463 +func (m NoUnderlyings) GetUnderlyingCFICode() (f field.UnderlyingCFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityType gets UnderlyingSecurityType, Tag 310 +func (m NoUnderlyings) GetUnderlyingSecurityType() (f field.UnderlyingSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecuritySubType gets UnderlyingSecuritySubType, Tag 763 +func (m NoUnderlyings) GetUnderlyingSecuritySubType() (f field.UnderlyingSecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingMaturityMonthYear gets UnderlyingMaturityMonthYear, Tag 313 +func (m NoUnderlyings) GetUnderlyingMaturityMonthYear() (f field.UnderlyingMaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingMaturityDate gets UnderlyingMaturityDate, Tag 542 +func (m NoUnderlyings) GetUnderlyingMaturityDate() (f field.UnderlyingMaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCouponPaymentDate gets UnderlyingCouponPaymentDate, Tag 241 +func (m NoUnderlyings) GetUnderlyingCouponPaymentDate() (f field.UnderlyingCouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingIssueDate gets UnderlyingIssueDate, Tag 242 +func (m NoUnderlyings) GetUnderlyingIssueDate() (f field.UnderlyingIssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepoCollateralSecurityType gets UnderlyingRepoCollateralSecurityType, Tag 243 +func (m NoUnderlyings) GetUnderlyingRepoCollateralSecurityType() (f field.UnderlyingRepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepurchaseTerm gets UnderlyingRepurchaseTerm, Tag 244 +func (m NoUnderlyings) GetUnderlyingRepurchaseTerm() (f field.UnderlyingRepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepurchaseRate gets UnderlyingRepurchaseRate, Tag 245 +func (m NoUnderlyings) GetUnderlyingRepurchaseRate() (f field.UnderlyingRepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingFactor gets UnderlyingFactor, Tag 246 +func (m NoUnderlyings) GetUnderlyingFactor() (f field.UnderlyingFactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCreditRating gets UnderlyingCreditRating, Tag 256 +func (m NoUnderlyings) GetUnderlyingCreditRating() (f field.UnderlyingCreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingInstrRegistry gets UnderlyingInstrRegistry, Tag 595 +func (m NoUnderlyings) GetUnderlyingInstrRegistry() (f field.UnderlyingInstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCountryOfIssue gets UnderlyingCountryOfIssue, Tag 592 +func (m NoUnderlyings) GetUnderlyingCountryOfIssue() (f field.UnderlyingCountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStateOrProvinceOfIssue gets UnderlyingStateOrProvinceOfIssue, Tag 593 +func (m NoUnderlyings) GetUnderlyingStateOrProvinceOfIssue() (f field.UnderlyingStateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingLocaleOfIssue gets UnderlyingLocaleOfIssue, Tag 594 +func (m NoUnderlyings) GetUnderlyingLocaleOfIssue() (f field.UnderlyingLocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRedemptionDate gets UnderlyingRedemptionDate, Tag 247 +func (m NoUnderlyings) GetUnderlyingRedemptionDate() (f field.UnderlyingRedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStrikePrice gets UnderlyingStrikePrice, Tag 316 +func (m NoUnderlyings) GetUnderlyingStrikePrice() (f field.UnderlyingStrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStrikeCurrency gets UnderlyingStrikeCurrency, Tag 941 +func (m NoUnderlyings) GetUnderlyingStrikeCurrency() (f field.UnderlyingStrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingOptAttribute gets UnderlyingOptAttribute, Tag 317 +func (m NoUnderlyings) GetUnderlyingOptAttribute() (f field.UnderlyingOptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingContractMultiplier gets UnderlyingContractMultiplier, Tag 436 +func (m NoUnderlyings) GetUnderlyingContractMultiplier() (f field.UnderlyingContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCouponRate gets UnderlyingCouponRate, Tag 435 +func (m NoUnderlyings) GetUnderlyingCouponRate() (f field.UnderlyingCouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityExchange gets UnderlyingSecurityExchange, Tag 308 +func (m NoUnderlyings) GetUnderlyingSecurityExchange() (f field.UnderlyingSecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingIssuer gets UnderlyingIssuer, Tag 306 +func (m NoUnderlyings) GetUnderlyingIssuer() (f field.UnderlyingIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingIssuerLen gets EncodedUnderlyingIssuerLen, Tag 362 +func (m NoUnderlyings) GetEncodedUnderlyingIssuerLen() (f field.EncodedUnderlyingIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingIssuer gets EncodedUnderlyingIssuer, Tag 363 +func (m NoUnderlyings) GetEncodedUnderlyingIssuer() (f field.EncodedUnderlyingIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityDesc gets UnderlyingSecurityDesc, Tag 307 +func (m NoUnderlyings) GetUnderlyingSecurityDesc() (f field.UnderlyingSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingSecurityDescLen gets EncodedUnderlyingSecurityDescLen, Tag 364 +func (m NoUnderlyings) GetEncodedUnderlyingSecurityDescLen() (f field.EncodedUnderlyingSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingSecurityDesc gets EncodedUnderlyingSecurityDesc, Tag 365 +func (m NoUnderlyings) GetEncodedUnderlyingSecurityDesc() (f field.EncodedUnderlyingSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCPProgram gets UnderlyingCPProgram, Tag 877 +func (m NoUnderlyings) GetUnderlyingCPProgram() (f field.UnderlyingCPProgramField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCPRegType gets UnderlyingCPRegType, Tag 878 +func (m NoUnderlyings) GetUnderlyingCPRegType() (f field.UnderlyingCPRegTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCurrency gets UnderlyingCurrency, Tag 318 +func (m NoUnderlyings) GetUnderlyingCurrency() (f field.UnderlyingCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingQty gets UnderlyingQty, Tag 879 +func (m NoUnderlyings) GetUnderlyingQty() (f field.UnderlyingQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingPx gets UnderlyingPx, Tag 810 +func (m NoUnderlyings) GetUnderlyingPx() (f field.UnderlyingPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingDirtyPrice gets UnderlyingDirtyPrice, Tag 882 +func (m NoUnderlyings) GetUnderlyingDirtyPrice() (f field.UnderlyingDirtyPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingEndPrice gets UnderlyingEndPrice, Tag 883 +func (m NoUnderlyings) GetUnderlyingEndPrice() (f field.UnderlyingEndPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStartValue gets UnderlyingStartValue, Tag 884 +func (m NoUnderlyings) GetUnderlyingStartValue() (f field.UnderlyingStartValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCurrentValue gets UnderlyingCurrentValue, Tag 885 +func (m NoUnderlyings) GetUnderlyingCurrentValue() (f field.UnderlyingCurrentValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingEndValue gets UnderlyingEndValue, Tag 886 +func (m NoUnderlyings) GetUnderlyingEndValue() (f field.UnderlyingEndValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyingStips gets NoUnderlyingStips, Tag 887 +func (m NoUnderlyings) GetNoUnderlyingStips() (NoUnderlyingStipsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingStipsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasUnderlyingSymbol returns true if UnderlyingSymbol is present, Tag 311 +func (m NoUnderlyings) HasUnderlyingSymbol() bool { + return m.Has(tag.UnderlyingSymbol) +} + +//HasUnderlyingSymbolSfx returns true if UnderlyingSymbolSfx is present, Tag 312 +func (m NoUnderlyings) HasUnderlyingSymbolSfx() bool { + return m.Has(tag.UnderlyingSymbolSfx) +} + +//HasUnderlyingSecurityID returns true if UnderlyingSecurityID is present, Tag 309 +func (m NoUnderlyings) HasUnderlyingSecurityID() bool { + return m.Has(tag.UnderlyingSecurityID) +} + +//HasUnderlyingSecurityIDSource returns true if UnderlyingSecurityIDSource is present, Tag 305 +func (m NoUnderlyings) HasUnderlyingSecurityIDSource() bool { + return m.Has(tag.UnderlyingSecurityIDSource) +} + +//HasNoUnderlyingSecurityAltID returns true if NoUnderlyingSecurityAltID is present, Tag 457 +func (m NoUnderlyings) HasNoUnderlyingSecurityAltID() bool { + return m.Has(tag.NoUnderlyingSecurityAltID) +} + +//HasUnderlyingProduct returns true if UnderlyingProduct is present, Tag 462 +func (m NoUnderlyings) HasUnderlyingProduct() bool { + return m.Has(tag.UnderlyingProduct) +} + +//HasUnderlyingCFICode returns true if UnderlyingCFICode is present, Tag 463 +func (m NoUnderlyings) HasUnderlyingCFICode() bool { + return m.Has(tag.UnderlyingCFICode) +} + +//HasUnderlyingSecurityType returns true if UnderlyingSecurityType is present, Tag 310 +func (m NoUnderlyings) HasUnderlyingSecurityType() bool { + return m.Has(tag.UnderlyingSecurityType) +} + +//HasUnderlyingSecuritySubType returns true if UnderlyingSecuritySubType is present, Tag 763 +func (m NoUnderlyings) HasUnderlyingSecuritySubType() bool { + return m.Has(tag.UnderlyingSecuritySubType) +} + +//HasUnderlyingMaturityMonthYear returns true if UnderlyingMaturityMonthYear is present, Tag 313 +func (m NoUnderlyings) HasUnderlyingMaturityMonthYear() bool { + return m.Has(tag.UnderlyingMaturityMonthYear) +} + +//HasUnderlyingMaturityDate returns true if UnderlyingMaturityDate is present, Tag 542 +func (m NoUnderlyings) HasUnderlyingMaturityDate() bool { + return m.Has(tag.UnderlyingMaturityDate) +} + +//HasUnderlyingCouponPaymentDate returns true if UnderlyingCouponPaymentDate is present, Tag 241 +func (m NoUnderlyings) HasUnderlyingCouponPaymentDate() bool { + return m.Has(tag.UnderlyingCouponPaymentDate) +} + +//HasUnderlyingIssueDate returns true if UnderlyingIssueDate is present, Tag 242 +func (m NoUnderlyings) HasUnderlyingIssueDate() bool { + return m.Has(tag.UnderlyingIssueDate) +} + +//HasUnderlyingRepoCollateralSecurityType returns true if UnderlyingRepoCollateralSecurityType is present, Tag 243 +func (m NoUnderlyings) HasUnderlyingRepoCollateralSecurityType() bool { + return m.Has(tag.UnderlyingRepoCollateralSecurityType) +} + +//HasUnderlyingRepurchaseTerm returns true if UnderlyingRepurchaseTerm is present, Tag 244 +func (m NoUnderlyings) HasUnderlyingRepurchaseTerm() bool { + return m.Has(tag.UnderlyingRepurchaseTerm) +} + +//HasUnderlyingRepurchaseRate returns true if UnderlyingRepurchaseRate is present, Tag 245 +func (m NoUnderlyings) HasUnderlyingRepurchaseRate() bool { + return m.Has(tag.UnderlyingRepurchaseRate) +} + +//HasUnderlyingFactor returns true if UnderlyingFactor is present, Tag 246 +func (m NoUnderlyings) HasUnderlyingFactor() bool { + return m.Has(tag.UnderlyingFactor) +} + +//HasUnderlyingCreditRating returns true if UnderlyingCreditRating is present, Tag 256 +func (m NoUnderlyings) HasUnderlyingCreditRating() bool { + return m.Has(tag.UnderlyingCreditRating) +} + +//HasUnderlyingInstrRegistry returns true if UnderlyingInstrRegistry is present, Tag 595 +func (m NoUnderlyings) HasUnderlyingInstrRegistry() bool { + return m.Has(tag.UnderlyingInstrRegistry) +} + +//HasUnderlyingCountryOfIssue returns true if UnderlyingCountryOfIssue is present, Tag 592 +func (m NoUnderlyings) HasUnderlyingCountryOfIssue() bool { + return m.Has(tag.UnderlyingCountryOfIssue) +} + +//HasUnderlyingStateOrProvinceOfIssue returns true if UnderlyingStateOrProvinceOfIssue is present, Tag 593 +func (m NoUnderlyings) HasUnderlyingStateOrProvinceOfIssue() bool { + return m.Has(tag.UnderlyingStateOrProvinceOfIssue) +} + +//HasUnderlyingLocaleOfIssue returns true if UnderlyingLocaleOfIssue is present, Tag 594 +func (m NoUnderlyings) HasUnderlyingLocaleOfIssue() bool { + return m.Has(tag.UnderlyingLocaleOfIssue) +} + +//HasUnderlyingRedemptionDate returns true if UnderlyingRedemptionDate is present, Tag 247 +func (m NoUnderlyings) HasUnderlyingRedemptionDate() bool { + return m.Has(tag.UnderlyingRedemptionDate) +} + +//HasUnderlyingStrikePrice returns true if UnderlyingStrikePrice is present, Tag 316 +func (m NoUnderlyings) HasUnderlyingStrikePrice() bool { + return m.Has(tag.UnderlyingStrikePrice) +} + +//HasUnderlyingStrikeCurrency returns true if UnderlyingStrikeCurrency is present, Tag 941 +func (m NoUnderlyings) HasUnderlyingStrikeCurrency() bool { + return m.Has(tag.UnderlyingStrikeCurrency) +} + +//HasUnderlyingOptAttribute returns true if UnderlyingOptAttribute is present, Tag 317 +func (m NoUnderlyings) HasUnderlyingOptAttribute() bool { + return m.Has(tag.UnderlyingOptAttribute) +} + +//HasUnderlyingContractMultiplier returns true if UnderlyingContractMultiplier is present, Tag 436 +func (m NoUnderlyings) HasUnderlyingContractMultiplier() bool { + return m.Has(tag.UnderlyingContractMultiplier) +} + +//HasUnderlyingCouponRate returns true if UnderlyingCouponRate is present, Tag 435 +func (m NoUnderlyings) HasUnderlyingCouponRate() bool { + return m.Has(tag.UnderlyingCouponRate) +} + +//HasUnderlyingSecurityExchange returns true if UnderlyingSecurityExchange is present, Tag 308 +func (m NoUnderlyings) HasUnderlyingSecurityExchange() bool { + return m.Has(tag.UnderlyingSecurityExchange) +} + +//HasUnderlyingIssuer returns true if UnderlyingIssuer is present, Tag 306 +func (m NoUnderlyings) HasUnderlyingIssuer() bool { + return m.Has(tag.UnderlyingIssuer) +} + +//HasEncodedUnderlyingIssuerLen returns true if EncodedUnderlyingIssuerLen is present, Tag 362 +func (m NoUnderlyings) HasEncodedUnderlyingIssuerLen() bool { + return m.Has(tag.EncodedUnderlyingIssuerLen) +} + +//HasEncodedUnderlyingIssuer returns true if EncodedUnderlyingIssuer is present, Tag 363 +func (m NoUnderlyings) HasEncodedUnderlyingIssuer() bool { + return m.Has(tag.EncodedUnderlyingIssuer) +} + +//HasUnderlyingSecurityDesc returns true if UnderlyingSecurityDesc is present, Tag 307 +func (m NoUnderlyings) HasUnderlyingSecurityDesc() bool { + return m.Has(tag.UnderlyingSecurityDesc) +} + +//HasEncodedUnderlyingSecurityDescLen returns true if EncodedUnderlyingSecurityDescLen is present, Tag 364 +func (m NoUnderlyings) HasEncodedUnderlyingSecurityDescLen() bool { + return m.Has(tag.EncodedUnderlyingSecurityDescLen) +} + +//HasEncodedUnderlyingSecurityDesc returns true if EncodedUnderlyingSecurityDesc is present, Tag 365 +func (m NoUnderlyings) HasEncodedUnderlyingSecurityDesc() bool { + return m.Has(tag.EncodedUnderlyingSecurityDesc) +} + +//HasUnderlyingCPProgram returns true if UnderlyingCPProgram is present, Tag 877 +func (m NoUnderlyings) HasUnderlyingCPProgram() bool { + return m.Has(tag.UnderlyingCPProgram) +} + +//HasUnderlyingCPRegType returns true if UnderlyingCPRegType is present, Tag 878 +func (m NoUnderlyings) HasUnderlyingCPRegType() bool { + return m.Has(tag.UnderlyingCPRegType) +} + +//HasUnderlyingCurrency returns true if UnderlyingCurrency is present, Tag 318 +func (m NoUnderlyings) HasUnderlyingCurrency() bool { + return m.Has(tag.UnderlyingCurrency) +} + +//HasUnderlyingQty returns true if UnderlyingQty is present, Tag 879 +func (m NoUnderlyings) HasUnderlyingQty() bool { + return m.Has(tag.UnderlyingQty) +} + +//HasUnderlyingPx returns true if UnderlyingPx is present, Tag 810 +func (m NoUnderlyings) HasUnderlyingPx() bool { + return m.Has(tag.UnderlyingPx) +} + +//HasUnderlyingDirtyPrice returns true if UnderlyingDirtyPrice is present, Tag 882 +func (m NoUnderlyings) HasUnderlyingDirtyPrice() bool { + return m.Has(tag.UnderlyingDirtyPrice) +} + +//HasUnderlyingEndPrice returns true if UnderlyingEndPrice is present, Tag 883 +func (m NoUnderlyings) HasUnderlyingEndPrice() bool { + return m.Has(tag.UnderlyingEndPrice) +} + +//HasUnderlyingStartValue returns true if UnderlyingStartValue is present, Tag 884 +func (m NoUnderlyings) HasUnderlyingStartValue() bool { + return m.Has(tag.UnderlyingStartValue) +} + +//HasUnderlyingCurrentValue returns true if UnderlyingCurrentValue is present, Tag 885 +func (m NoUnderlyings) HasUnderlyingCurrentValue() bool { + return m.Has(tag.UnderlyingCurrentValue) +} + +//HasUnderlyingEndValue returns true if UnderlyingEndValue is present, Tag 886 +func (m NoUnderlyings) HasUnderlyingEndValue() bool { + return m.Has(tag.UnderlyingEndValue) +} + +//HasNoUnderlyingStips returns true if NoUnderlyingStips is present, Tag 887 +func (m NoUnderlyings) HasNoUnderlyingStips() bool { + return m.Has(tag.NoUnderlyingStips) +} + +//NoUnderlyingSecurityAltID is a repeating group element, Tag 457 +type NoUnderlyingSecurityAltID struct { + quickfix.Group +} + +//SetUnderlyingSecurityAltID sets UnderlyingSecurityAltID, Tag 458 +func (m NoUnderlyingSecurityAltID) SetUnderlyingSecurityAltID(v string) { + m.Set(field.NewUnderlyingSecurityAltID(v)) +} + +//SetUnderlyingSecurityAltIDSource sets UnderlyingSecurityAltIDSource, Tag 459 +func (m NoUnderlyingSecurityAltID) SetUnderlyingSecurityAltIDSource(v string) { + m.Set(field.NewUnderlyingSecurityAltIDSource(v)) +} + +//GetUnderlyingSecurityAltID gets UnderlyingSecurityAltID, Tag 458 +func (m NoUnderlyingSecurityAltID) GetUnderlyingSecurityAltID() (f field.UnderlyingSecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityAltIDSource gets UnderlyingSecurityAltIDSource, Tag 459 +func (m NoUnderlyingSecurityAltID) GetUnderlyingSecurityAltIDSource() (f field.UnderlyingSecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingSecurityAltID returns true if UnderlyingSecurityAltID is present, Tag 458 +func (m NoUnderlyingSecurityAltID) HasUnderlyingSecurityAltID() bool { + return m.Has(tag.UnderlyingSecurityAltID) +} + +//HasUnderlyingSecurityAltIDSource returns true if UnderlyingSecurityAltIDSource is present, Tag 459 +func (m NoUnderlyingSecurityAltID) HasUnderlyingSecurityAltIDSource() bool { + return m.Has(tag.UnderlyingSecurityAltIDSource) +} + +//NoUnderlyingSecurityAltIDRepeatingGroup is a repeating group, Tag 457 +type NoUnderlyingSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingSecurityAltIDRepeatingGroup returns an initialized, NoUnderlyingSecurityAltIDRepeatingGroup +func NewNoUnderlyingSecurityAltIDRepeatingGroup() NoUnderlyingSecurityAltIDRepeatingGroup { + return NoUnderlyingSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyingSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingSecurityAltID), quickfix.GroupElement(tag.UnderlyingSecurityAltIDSource)})} +} + +//Add create and append a new NoUnderlyingSecurityAltID to this group +func (m NoUnderlyingSecurityAltIDRepeatingGroup) Add() NoUnderlyingSecurityAltID { + g := m.RepeatingGroup.Add() + return NoUnderlyingSecurityAltID{g} +} + +//Get returns the ith NoUnderlyingSecurityAltID in the NoUnderlyingSecurityAltIDRepeatinGroup +func (m NoUnderlyingSecurityAltIDRepeatingGroup) Get(i int) NoUnderlyingSecurityAltID { + return NoUnderlyingSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyingStips is a repeating group element, Tag 887 +type NoUnderlyingStips struct { + quickfix.Group +} + +//SetUnderlyingStipType sets UnderlyingStipType, Tag 888 +func (m NoUnderlyingStips) SetUnderlyingStipType(v string) { + m.Set(field.NewUnderlyingStipType(v)) +} + +//SetUnderlyingStipValue sets UnderlyingStipValue, Tag 889 +func (m NoUnderlyingStips) SetUnderlyingStipValue(v string) { + m.Set(field.NewUnderlyingStipValue(v)) +} + +//GetUnderlyingStipType gets UnderlyingStipType, Tag 888 +func (m NoUnderlyingStips) GetUnderlyingStipType() (f field.UnderlyingStipTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStipValue gets UnderlyingStipValue, Tag 889 +func (m NoUnderlyingStips) GetUnderlyingStipValue() (f field.UnderlyingStipValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingStipType returns true if UnderlyingStipType is present, Tag 888 +func (m NoUnderlyingStips) HasUnderlyingStipType() bool { + return m.Has(tag.UnderlyingStipType) +} + +//HasUnderlyingStipValue returns true if UnderlyingStipValue is present, Tag 889 +func (m NoUnderlyingStips) HasUnderlyingStipValue() bool { + return m.Has(tag.UnderlyingStipValue) +} + +//NoUnderlyingStipsRepeatingGroup is a repeating group, Tag 887 +type NoUnderlyingStipsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingStipsRepeatingGroup returns an initialized, NoUnderlyingStipsRepeatingGroup +func NewNoUnderlyingStipsRepeatingGroup() NoUnderlyingStipsRepeatingGroup { + return NoUnderlyingStipsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyingStips, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingStipType), quickfix.GroupElement(tag.UnderlyingStipValue)})} +} + +//Add create and append a new NoUnderlyingStips to this group +func (m NoUnderlyingStipsRepeatingGroup) Add() NoUnderlyingStips { + g := m.RepeatingGroup.Add() + return NoUnderlyingStips{g} +} + +//Get returns the ith NoUnderlyingStips in the NoUnderlyingStipsRepeatinGroup +func (m NoUnderlyingStipsRepeatingGroup) Get(i int) NoUnderlyingStips { + return NoUnderlyingStips{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyingsRepeatingGroup is a repeating group, Tag 711 +type NoUnderlyingsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingsRepeatingGroup returns an initialized, NoUnderlyingsRepeatingGroup +func NewNoUnderlyingsRepeatingGroup() NoUnderlyingsRepeatingGroup { + return NoUnderlyingsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyings, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingSymbol), quickfix.GroupElement(tag.UnderlyingSymbolSfx), quickfix.GroupElement(tag.UnderlyingSecurityID), quickfix.GroupElement(tag.UnderlyingSecurityIDSource), NewNoUnderlyingSecurityAltIDRepeatingGroup(), quickfix.GroupElement(tag.UnderlyingProduct), quickfix.GroupElement(tag.UnderlyingCFICode), quickfix.GroupElement(tag.UnderlyingSecurityType), quickfix.GroupElement(tag.UnderlyingSecuritySubType), quickfix.GroupElement(tag.UnderlyingMaturityMonthYear), quickfix.GroupElement(tag.UnderlyingMaturityDate), quickfix.GroupElement(tag.UnderlyingCouponPaymentDate), quickfix.GroupElement(tag.UnderlyingIssueDate), quickfix.GroupElement(tag.UnderlyingRepoCollateralSecurityType), quickfix.GroupElement(tag.UnderlyingRepurchaseTerm), quickfix.GroupElement(tag.UnderlyingRepurchaseRate), quickfix.GroupElement(tag.UnderlyingFactor), quickfix.GroupElement(tag.UnderlyingCreditRating), quickfix.GroupElement(tag.UnderlyingInstrRegistry), quickfix.GroupElement(tag.UnderlyingCountryOfIssue), quickfix.GroupElement(tag.UnderlyingStateOrProvinceOfIssue), quickfix.GroupElement(tag.UnderlyingLocaleOfIssue), quickfix.GroupElement(tag.UnderlyingRedemptionDate), quickfix.GroupElement(tag.UnderlyingStrikePrice), quickfix.GroupElement(tag.UnderlyingStrikeCurrency), quickfix.GroupElement(tag.UnderlyingOptAttribute), quickfix.GroupElement(tag.UnderlyingContractMultiplier), quickfix.GroupElement(tag.UnderlyingCouponRate), quickfix.GroupElement(tag.UnderlyingSecurityExchange), quickfix.GroupElement(tag.UnderlyingIssuer), quickfix.GroupElement(tag.EncodedUnderlyingIssuerLen), quickfix.GroupElement(tag.EncodedUnderlyingIssuer), quickfix.GroupElement(tag.UnderlyingSecurityDesc), quickfix.GroupElement(tag.EncodedUnderlyingSecurityDescLen), quickfix.GroupElement(tag.EncodedUnderlyingSecurityDesc), quickfix.GroupElement(tag.UnderlyingCPProgram), quickfix.GroupElement(tag.UnderlyingCPRegType), quickfix.GroupElement(tag.UnderlyingCurrency), quickfix.GroupElement(tag.UnderlyingQty), quickfix.GroupElement(tag.UnderlyingPx), quickfix.GroupElement(tag.UnderlyingDirtyPrice), quickfix.GroupElement(tag.UnderlyingEndPrice), quickfix.GroupElement(tag.UnderlyingStartValue), quickfix.GroupElement(tag.UnderlyingCurrentValue), quickfix.GroupElement(tag.UnderlyingEndValue), NewNoUnderlyingStipsRepeatingGroup()})} +} + +//Add create and append a new NoUnderlyings to this group +func (m NoUnderlyingsRepeatingGroup) Add() NoUnderlyings { + g := m.RepeatingGroup.Add() + return NoUnderlyings{g} +} + +//Get returns the ith NoUnderlyings in the NoUnderlyingsRepeatinGroup +func (m NoUnderlyingsRepeatingGroup) Get(i int) NoUnderlyings { + return NoUnderlyings{m.RepeatingGroup.Get(i)} +} + +//NoEvents is a repeating group element, Tag 864 +type NoEvents struct { + quickfix.Group +} + +//SetEventType sets EventType, Tag 865 +func (m NoEvents) SetEventType(v int) { + m.Set(field.NewEventType(v)) +} + +//SetEventDate sets EventDate, Tag 866 +func (m NoEvents) SetEventDate(v string) { + m.Set(field.NewEventDate(v)) +} + +//SetEventPx sets EventPx, Tag 867 +func (m NoEvents) SetEventPx(v float64) { + m.Set(field.NewEventPx(v)) +} + +//SetEventText sets EventText, Tag 868 +func (m NoEvents) SetEventText(v string) { + m.Set(field.NewEventText(v)) +} + +//GetEventType gets EventType, Tag 865 +func (m NoEvents) GetEventType() (f field.EventTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventDate gets EventDate, Tag 866 +func (m NoEvents) GetEventDate() (f field.EventDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventPx gets EventPx, Tag 867 +func (m NoEvents) GetEventPx() (f field.EventPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventText gets EventText, Tag 868 +func (m NoEvents) GetEventText() (f field.EventTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasEventType returns true if EventType is present, Tag 865 +func (m NoEvents) HasEventType() bool { + return m.Has(tag.EventType) +} + +//HasEventDate returns true if EventDate is present, Tag 866 +func (m NoEvents) HasEventDate() bool { + return m.Has(tag.EventDate) +} + +//HasEventPx returns true if EventPx is present, Tag 867 +func (m NoEvents) HasEventPx() bool { + return m.Has(tag.EventPx) +} + +//HasEventText returns true if EventText is present, Tag 868 +func (m NoEvents) HasEventText() bool { + return m.Has(tag.EventText) +} + +//NoEventsRepeatingGroup is a repeating group, Tag 864 +type NoEventsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoEventsRepeatingGroup returns an initialized, NoEventsRepeatingGroup +func NewNoEventsRepeatingGroup() NoEventsRepeatingGroup { + return NoEventsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoEvents, + quickfix.GroupTemplate{quickfix.GroupElement(tag.EventType), quickfix.GroupElement(tag.EventDate), quickfix.GroupElement(tag.EventPx), quickfix.GroupElement(tag.EventText)})} +} + +//Add create and append a new NoEvents to this group +func (m NoEventsRepeatingGroup) Add() NoEvents { + g := m.RepeatingGroup.Add() + return NoEvents{g} +} + +//Get returns the ith NoEvents in the NoEventsRepeatinGroup +func (m NoEventsRepeatingGroup) Get(i int) NoEvents { + return NoEvents{m.RepeatingGroup.Get(i)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix44/trailer.generated.go b/vendor/github.com/quickfixgo/quickfix/fix44/trailer.generated.go new file mode 100644 index 0000000..2b25d24 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix44/trailer.generated.go @@ -0,0 +1,60 @@ +package fix44 + +import ( + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/tag" +) + +//Trailer is the fix44 Trailer type +type Trailer struct { + quickfix.Trailer +} + +//SetCheckSum sets CheckSum, Tag 10 +func (t Trailer) SetCheckSum(v string) { + t.Set(field.NewCheckSum(v)) +} + +//SetSignature sets Signature, Tag 89 +func (t Trailer) SetSignature(v string) { + t.Set(field.NewSignature(v)) +} + +//SetSignatureLength sets SignatureLength, Tag 93 +func (t Trailer) SetSignatureLength(v int) { + t.Set(field.NewSignatureLength(v)) +} + +//GetCheckSum gets CheckSum, Tag 10 +func (t Trailer) GetCheckSum() (f field.CheckSumField, err quickfix.MessageRejectError) { + err = t.Get(&f) + return +} + +//GetSignature gets Signature, Tag 89 +func (t Trailer) GetSignature() (f field.SignatureField, err quickfix.MessageRejectError) { + err = t.Get(&f) + return +} + +//GetSignatureLength gets SignatureLength, Tag 93 +func (t Trailer) GetSignatureLength() (f field.SignatureLengthField, err quickfix.MessageRejectError) { + err = t.Get(&f) + return +} + +//HasCheckSum returns true if CheckSum is present, Tag 10 +func (t Trailer) HasCheckSum() bool { + return t.Has(tag.CheckSum) +} + +//HasSignature returns true if Signature is present, Tag 89 +func (t Trailer) HasSignature() bool { + return t.Has(tag.Signature) +} + +//HasSignatureLength returns true if SignatureLength is present, Tag 93 +func (t Trailer) HasSignatureLength() bool { + return t.Has(tag.SignatureLength) +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix50/executionreport/ExecutionReport.generated.go b/vendor/github.com/quickfixgo/quickfix/fix50/executionreport/ExecutionReport.generated.go new file mode 100644 index 0000000..b3b5bf4 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix50/executionreport/ExecutionReport.generated.go @@ -0,0 +1,7986 @@ +package executionreport + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fixt11" + "github.com/quickfixgo/quickfix/tag" +) + +//ExecutionReport is the fix50 ExecutionReport type, MsgType = 8 +type ExecutionReport struct { + fixt11.Header + quickfix.Body + fixt11.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a ExecutionReport from a quickfix.Message instance +func FromMessage(m quickfix.Message) ExecutionReport { + return ExecutionReport{ + Header: fixt11.Header{Header: m.Header}, + Body: m.Body, + Trailer: fixt11.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m ExecutionReport) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a ExecutionReport initialized with the required fields for ExecutionReport +func New(orderid field.OrderIDField, execid field.ExecIDField, exectype field.ExecTypeField, ordstatus field.OrdStatusField, side field.SideField, leavesqty field.LeavesQtyField, cumqty field.CumQtyField) (m ExecutionReport) { + m.Header = fixt11.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("8")) + m.Set(orderid) + m.Set(execid) + m.Set(exectype) + m.Set(ordstatus) + m.Set(side) + m.Set(leavesqty) + m.Set(cumqty) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg ExecutionReport, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "7", "8", r +} + +//SetAccount sets Account, Tag 1 +func (m ExecutionReport) SetAccount(v string) { + m.Set(field.NewAccount(v)) +} + +//SetAvgPx sets AvgPx, Tag 6 +func (m ExecutionReport) SetAvgPx(v float64) { + m.Set(field.NewAvgPx(v)) +} + +//SetClOrdID sets ClOrdID, Tag 11 +func (m ExecutionReport) SetClOrdID(v string) { + m.Set(field.NewClOrdID(v)) +} + +//SetCommission sets Commission, Tag 12 +func (m ExecutionReport) SetCommission(v float64) { + m.Set(field.NewCommission(v)) +} + +//SetCommType sets CommType, Tag 13 +func (m ExecutionReport) SetCommType(v string) { + m.Set(field.NewCommType(v)) +} + +//SetCumQty sets CumQty, Tag 14 +func (m ExecutionReport) SetCumQty(v float64) { + m.Set(field.NewCumQty(v)) +} + +//SetCurrency sets Currency, Tag 15 +func (m ExecutionReport) SetCurrency(v string) { + m.Set(field.NewCurrency(v)) +} + +//SetExecID sets ExecID, Tag 17 +func (m ExecutionReport) SetExecID(v string) { + m.Set(field.NewExecID(v)) +} + +//SetExecInst sets ExecInst, Tag 18 +func (m ExecutionReport) SetExecInst(v string) { + m.Set(field.NewExecInst(v)) +} + +//SetExecRefID sets ExecRefID, Tag 19 +func (m ExecutionReport) SetExecRefID(v string) { + m.Set(field.NewExecRefID(v)) +} + +//SetHandlInst sets HandlInst, Tag 21 +func (m ExecutionReport) SetHandlInst(v string) { + m.Set(field.NewHandlInst(v)) +} + +//SetSecurityIDSource sets SecurityIDSource, Tag 22 +func (m ExecutionReport) SetSecurityIDSource(v string) { + m.Set(field.NewSecurityIDSource(v)) +} + +//SetLastCapacity sets LastCapacity, Tag 29 +func (m ExecutionReport) SetLastCapacity(v string) { + m.Set(field.NewLastCapacity(v)) +} + +//SetLastMkt sets LastMkt, Tag 30 +func (m ExecutionReport) SetLastMkt(v string) { + m.Set(field.NewLastMkt(v)) +} + +//SetLastPx sets LastPx, Tag 31 +func (m ExecutionReport) SetLastPx(v float64) { + m.Set(field.NewLastPx(v)) +} + +//SetLastQty sets LastQty, Tag 32 +func (m ExecutionReport) SetLastQty(v float64) { + m.Set(field.NewLastQty(v)) +} + +//SetOrderID sets OrderID, Tag 37 +func (m ExecutionReport) SetOrderID(v string) { + m.Set(field.NewOrderID(v)) +} + +//SetOrderQty sets OrderQty, Tag 38 +func (m ExecutionReport) SetOrderQty(v float64) { + m.Set(field.NewOrderQty(v)) +} + +//SetOrdStatus sets OrdStatus, Tag 39 +func (m ExecutionReport) SetOrdStatus(v string) { + m.Set(field.NewOrdStatus(v)) +} + +//SetOrdType sets OrdType, Tag 40 +func (m ExecutionReport) SetOrdType(v string) { + m.Set(field.NewOrdType(v)) +} + +//SetOrigClOrdID sets OrigClOrdID, Tag 41 +func (m ExecutionReport) SetOrigClOrdID(v string) { + m.Set(field.NewOrigClOrdID(v)) +} + +//SetPrice sets Price, Tag 44 +func (m ExecutionReport) SetPrice(v float64) { + m.Set(field.NewPrice(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m ExecutionReport) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSide sets Side, Tag 54 +func (m ExecutionReport) SetSide(v string) { + m.Set(field.NewSide(v)) +} + +//SetSymbol sets Symbol, Tag 55 +func (m ExecutionReport) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetText sets Text, Tag 58 +func (m ExecutionReport) SetText(v string) { + m.Set(field.NewText(v)) +} + +//SetTimeInForce sets TimeInForce, Tag 59 +func (m ExecutionReport) SetTimeInForce(v string) { + m.Set(field.NewTimeInForce(v)) +} + +//SetTransactTime sets TransactTime, Tag 60 +func (m ExecutionReport) SetTransactTime(v time.Time) { + m.Set(field.NewTransactTime(v)) +} + +//SetSettlType sets SettlType, Tag 63 +func (m ExecutionReport) SetSettlType(v string) { + m.Set(field.NewSettlType(v)) +} + +//SetSettlDate sets SettlDate, Tag 64 +func (m ExecutionReport) SetSettlDate(v string) { + m.Set(field.NewSettlDate(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m ExecutionReport) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetListID sets ListID, Tag 66 +func (m ExecutionReport) SetListID(v string) { + m.Set(field.NewListID(v)) +} + +//SetTradeDate sets TradeDate, Tag 75 +func (m ExecutionReport) SetTradeDate(v string) { + m.Set(field.NewTradeDate(v)) +} + +//SetPositionEffect sets PositionEffect, Tag 77 +func (m ExecutionReport) SetPositionEffect(v string) { + m.Set(field.NewPositionEffect(v)) +} + +//SetStopPx sets StopPx, Tag 99 +func (m ExecutionReport) SetStopPx(v float64) { + m.Set(field.NewStopPx(v)) +} + +//SetOrdRejReason sets OrdRejReason, Tag 103 +func (m ExecutionReport) SetOrdRejReason(v int) { + m.Set(field.NewOrdRejReason(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m ExecutionReport) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m ExecutionReport) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetMinQty sets MinQty, Tag 110 +func (m ExecutionReport) SetMinQty(v float64) { + m.Set(field.NewMinQty(v)) +} + +//SetMaxFloor sets MaxFloor, Tag 111 +func (m ExecutionReport) SetMaxFloor(v float64) { + m.Set(field.NewMaxFloor(v)) +} + +//SetReportToExch sets ReportToExch, Tag 113 +func (m ExecutionReport) SetReportToExch(v bool) { + m.Set(field.NewReportToExch(v)) +} + +//SetNetMoney sets NetMoney, Tag 118 +func (m ExecutionReport) SetNetMoney(v float64) { + m.Set(field.NewNetMoney(v)) +} + +//SetSettlCurrAmt sets SettlCurrAmt, Tag 119 +func (m ExecutionReport) SetSettlCurrAmt(v float64) { + m.Set(field.NewSettlCurrAmt(v)) +} + +//SetSettlCurrency sets SettlCurrency, Tag 120 +func (m ExecutionReport) SetSettlCurrency(v string) { + m.Set(field.NewSettlCurrency(v)) +} + +//SetExpireTime sets ExpireTime, Tag 126 +func (m ExecutionReport) SetExpireTime(v time.Time) { + m.Set(field.NewExpireTime(v)) +} + +//SetNoMiscFees sets NoMiscFees, Tag 136 +func (m ExecutionReport) SetNoMiscFees(f NoMiscFeesRepeatingGroup) { + m.SetGroup(f) +} + +//SetExecType sets ExecType, Tag 150 +func (m ExecutionReport) SetExecType(v string) { + m.Set(field.NewExecType(v)) +} + +//SetLeavesQty sets LeavesQty, Tag 151 +func (m ExecutionReport) SetLeavesQty(v float64) { + m.Set(field.NewLeavesQty(v)) +} + +//SetCashOrderQty sets CashOrderQty, Tag 152 +func (m ExecutionReport) SetCashOrderQty(v float64) { + m.Set(field.NewCashOrderQty(v)) +} + +//SetSettlCurrFxRate sets SettlCurrFxRate, Tag 155 +func (m ExecutionReport) SetSettlCurrFxRate(v float64) { + m.Set(field.NewSettlCurrFxRate(v)) +} + +//SetSettlCurrFxRateCalc sets SettlCurrFxRateCalc, Tag 156 +func (m ExecutionReport) SetSettlCurrFxRateCalc(v string) { + m.Set(field.NewSettlCurrFxRateCalc(v)) +} + +//SetNumDaysInterest sets NumDaysInterest, Tag 157 +func (m ExecutionReport) SetNumDaysInterest(v int) { + m.Set(field.NewNumDaysInterest(v)) +} + +//SetAccruedInterestRate sets AccruedInterestRate, Tag 158 +func (m ExecutionReport) SetAccruedInterestRate(v float64) { + m.Set(field.NewAccruedInterestRate(v)) +} + +//SetAccruedInterestAmt sets AccruedInterestAmt, Tag 159 +func (m ExecutionReport) SetAccruedInterestAmt(v float64) { + m.Set(field.NewAccruedInterestAmt(v)) +} + +//SetSecurityType sets SecurityType, Tag 167 +func (m ExecutionReport) SetSecurityType(v string) { + m.Set(field.NewSecurityType(v)) +} + +//SetEffectiveTime sets EffectiveTime, Tag 168 +func (m ExecutionReport) SetEffectiveTime(v time.Time) { + m.Set(field.NewEffectiveTime(v)) +} + +//SetOrderQty2 sets OrderQty2, Tag 192 +func (m ExecutionReport) SetOrderQty2(v float64) { + m.Set(field.NewOrderQty2(v)) +} + +//SetSettlDate2 sets SettlDate2, Tag 193 +func (m ExecutionReport) SetSettlDate2(v string) { + m.Set(field.NewSettlDate2(v)) +} + +//SetLastSpotRate sets LastSpotRate, Tag 194 +func (m ExecutionReport) SetLastSpotRate(v float64) { + m.Set(field.NewLastSpotRate(v)) +} + +//SetLastForwardPoints sets LastForwardPoints, Tag 195 +func (m ExecutionReport) SetLastForwardPoints(v float64) { + m.Set(field.NewLastForwardPoints(v)) +} + +//SetSecondaryOrderID sets SecondaryOrderID, Tag 198 +func (m ExecutionReport) SetSecondaryOrderID(v string) { + m.Set(field.NewSecondaryOrderID(v)) +} + +//SetMaturityMonthYear sets MaturityMonthYear, Tag 200 +func (m ExecutionReport) SetMaturityMonthYear(v string) { + m.Set(field.NewMaturityMonthYear(v)) +} + +//SetStrikePrice sets StrikePrice, Tag 202 +func (m ExecutionReport) SetStrikePrice(v float64) { + m.Set(field.NewStrikePrice(v)) +} + +//SetOptAttribute sets OptAttribute, Tag 206 +func (m ExecutionReport) SetOptAttribute(v string) { + m.Set(field.NewOptAttribute(v)) +} + +//SetSecurityExchange sets SecurityExchange, Tag 207 +func (m ExecutionReport) SetSecurityExchange(v string) { + m.Set(field.NewSecurityExchange(v)) +} + +//SetMaxShow sets MaxShow, Tag 210 +func (m ExecutionReport) SetMaxShow(v float64) { + m.Set(field.NewMaxShow(v)) +} + +//SetPegOffsetValue sets PegOffsetValue, Tag 211 +func (m ExecutionReport) SetPegOffsetValue(v float64) { + m.Set(field.NewPegOffsetValue(v)) +} + +//SetSpread sets Spread, Tag 218 +func (m ExecutionReport) SetSpread(v float64) { + m.Set(field.NewSpread(v)) +} + +//SetBenchmarkCurveCurrency sets BenchmarkCurveCurrency, Tag 220 +func (m ExecutionReport) SetBenchmarkCurveCurrency(v string) { + m.Set(field.NewBenchmarkCurveCurrency(v)) +} + +//SetBenchmarkCurveName sets BenchmarkCurveName, Tag 221 +func (m ExecutionReport) SetBenchmarkCurveName(v string) { + m.Set(field.NewBenchmarkCurveName(v)) +} + +//SetBenchmarkCurvePoint sets BenchmarkCurvePoint, Tag 222 +func (m ExecutionReport) SetBenchmarkCurvePoint(v string) { + m.Set(field.NewBenchmarkCurvePoint(v)) +} + +//SetCouponRate sets CouponRate, Tag 223 +func (m ExecutionReport) SetCouponRate(v float64) { + m.Set(field.NewCouponRate(v)) +} + +//SetCouponPaymentDate sets CouponPaymentDate, Tag 224 +func (m ExecutionReport) SetCouponPaymentDate(v string) { + m.Set(field.NewCouponPaymentDate(v)) +} + +//SetIssueDate sets IssueDate, Tag 225 +func (m ExecutionReport) SetIssueDate(v string) { + m.Set(field.NewIssueDate(v)) +} + +//SetRepurchaseTerm sets RepurchaseTerm, Tag 226 +func (m ExecutionReport) SetRepurchaseTerm(v int) { + m.Set(field.NewRepurchaseTerm(v)) +} + +//SetRepurchaseRate sets RepurchaseRate, Tag 227 +func (m ExecutionReport) SetRepurchaseRate(v float64) { + m.Set(field.NewRepurchaseRate(v)) +} + +//SetFactor sets Factor, Tag 228 +func (m ExecutionReport) SetFactor(v float64) { + m.Set(field.NewFactor(v)) +} + +//SetTradeOriginationDate sets TradeOriginationDate, Tag 229 +func (m ExecutionReport) SetTradeOriginationDate(v string) { + m.Set(field.NewTradeOriginationDate(v)) +} + +//SetExDate sets ExDate, Tag 230 +func (m ExecutionReport) SetExDate(v string) { + m.Set(field.NewExDate(v)) +} + +//SetContractMultiplier sets ContractMultiplier, Tag 231 +func (m ExecutionReport) SetContractMultiplier(v float64) { + m.Set(field.NewContractMultiplier(v)) +} + +//SetNoStipulations sets NoStipulations, Tag 232 +func (m ExecutionReport) SetNoStipulations(f NoStipulationsRepeatingGroup) { + m.SetGroup(f) +} + +//SetYieldType sets YieldType, Tag 235 +func (m ExecutionReport) SetYieldType(v string) { + m.Set(field.NewYieldType(v)) +} + +//SetYield sets Yield, Tag 236 +func (m ExecutionReport) SetYield(v float64) { + m.Set(field.NewYield(v)) +} + +//SetTotalTakedown sets TotalTakedown, Tag 237 +func (m ExecutionReport) SetTotalTakedown(v float64) { + m.Set(field.NewTotalTakedown(v)) +} + +//SetConcession sets Concession, Tag 238 +func (m ExecutionReport) SetConcession(v float64) { + m.Set(field.NewConcession(v)) +} + +//SetRepoCollateralSecurityType sets RepoCollateralSecurityType, Tag 239 +func (m ExecutionReport) SetRepoCollateralSecurityType(v int) { + m.Set(field.NewRepoCollateralSecurityType(v)) +} + +//SetRedemptionDate sets RedemptionDate, Tag 240 +func (m ExecutionReport) SetRedemptionDate(v string) { + m.Set(field.NewRedemptionDate(v)) +} + +//SetCreditRating sets CreditRating, Tag 255 +func (m ExecutionReport) SetCreditRating(v string) { + m.Set(field.NewCreditRating(v)) +} + +//SetTradedFlatSwitch sets TradedFlatSwitch, Tag 258 +func (m ExecutionReport) SetTradedFlatSwitch(v bool) { + m.Set(field.NewTradedFlatSwitch(v)) +} + +//SetBasisFeatureDate sets BasisFeatureDate, Tag 259 +func (m ExecutionReport) SetBasisFeatureDate(v string) { + m.Set(field.NewBasisFeatureDate(v)) +} + +//SetBasisFeaturePrice sets BasisFeaturePrice, Tag 260 +func (m ExecutionReport) SetBasisFeaturePrice(v float64) { + m.Set(field.NewBasisFeaturePrice(v)) +} + +//SetTradingSessionID sets TradingSessionID, Tag 336 +func (m ExecutionReport) SetTradingSessionID(v string) { + m.Set(field.NewTradingSessionID(v)) +} + +//SetEncodedIssuerLen sets EncodedIssuerLen, Tag 348 +func (m ExecutionReport) SetEncodedIssuerLen(v int) { + m.Set(field.NewEncodedIssuerLen(v)) +} + +//SetEncodedIssuer sets EncodedIssuer, Tag 349 +func (m ExecutionReport) SetEncodedIssuer(v string) { + m.Set(field.NewEncodedIssuer(v)) +} + +//SetEncodedSecurityDescLen sets EncodedSecurityDescLen, Tag 350 +func (m ExecutionReport) SetEncodedSecurityDescLen(v int) { + m.Set(field.NewEncodedSecurityDescLen(v)) +} + +//SetEncodedSecurityDesc sets EncodedSecurityDesc, Tag 351 +func (m ExecutionReport) SetEncodedSecurityDesc(v string) { + m.Set(field.NewEncodedSecurityDesc(v)) +} + +//SetEncodedTextLen sets EncodedTextLen, Tag 354 +func (m ExecutionReport) SetEncodedTextLen(v int) { + m.Set(field.NewEncodedTextLen(v)) +} + +//SetEncodedText sets EncodedText, Tag 355 +func (m ExecutionReport) SetEncodedText(v string) { + m.Set(field.NewEncodedText(v)) +} + +//SetComplianceID sets ComplianceID, Tag 376 +func (m ExecutionReport) SetComplianceID(v string) { + m.Set(field.NewComplianceID(v)) +} + +//SetSolicitedFlag sets SolicitedFlag, Tag 377 +func (m ExecutionReport) SetSolicitedFlag(v bool) { + m.Set(field.NewSolicitedFlag(v)) +} + +//SetExecRestatementReason sets ExecRestatementReason, Tag 378 +func (m ExecutionReport) SetExecRestatementReason(v int) { + m.Set(field.NewExecRestatementReason(v)) +} + +//SetGrossTradeAmt sets GrossTradeAmt, Tag 381 +func (m ExecutionReport) SetGrossTradeAmt(v float64) { + m.Set(field.NewGrossTradeAmt(v)) +} + +//SetNoContraBrokers sets NoContraBrokers, Tag 382 +func (m ExecutionReport) SetNoContraBrokers(f NoContraBrokersRepeatingGroup) { + m.SetGroup(f) +} + +//SetDiscretionInst sets DiscretionInst, Tag 388 +func (m ExecutionReport) SetDiscretionInst(v string) { + m.Set(field.NewDiscretionInst(v)) +} + +//SetDiscretionOffsetValue sets DiscretionOffsetValue, Tag 389 +func (m ExecutionReport) SetDiscretionOffsetValue(v float64) { + m.Set(field.NewDiscretionOffsetValue(v)) +} + +//SetPriceType sets PriceType, Tag 423 +func (m ExecutionReport) SetPriceType(v int) { + m.Set(field.NewPriceType(v)) +} + +//SetDayOrderQty sets DayOrderQty, Tag 424 +func (m ExecutionReport) SetDayOrderQty(v float64) { + m.Set(field.NewDayOrderQty(v)) +} + +//SetDayCumQty sets DayCumQty, Tag 425 +func (m ExecutionReport) SetDayCumQty(v float64) { + m.Set(field.NewDayCumQty(v)) +} + +//SetDayAvgPx sets DayAvgPx, Tag 426 +func (m ExecutionReport) SetDayAvgPx(v float64) { + m.Set(field.NewDayAvgPx(v)) +} + +//SetGTBookingInst sets GTBookingInst, Tag 427 +func (m ExecutionReport) SetGTBookingInst(v int) { + m.Set(field.NewGTBookingInst(v)) +} + +//SetExpireDate sets ExpireDate, Tag 432 +func (m ExecutionReport) SetExpireDate(v string) { + m.Set(field.NewExpireDate(v)) +} + +//SetMultiLegReportingType sets MultiLegReportingType, Tag 442 +func (m ExecutionReport) SetMultiLegReportingType(v string) { + m.Set(field.NewMultiLegReportingType(v)) +} + +//SetNoPartyIDs sets NoPartyIDs, Tag 453 +func (m ExecutionReport) SetNoPartyIDs(f NoPartyIDsRepeatingGroup) { + m.SetGroup(f) +} + +//SetNoSecurityAltID sets NoSecurityAltID, Tag 454 +func (m ExecutionReport) SetNoSecurityAltID(f NoSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetProduct sets Product, Tag 460 +func (m ExecutionReport) SetProduct(v int) { + m.Set(field.NewProduct(v)) +} + +//SetCFICode sets CFICode, Tag 461 +func (m ExecutionReport) SetCFICode(v string) { + m.Set(field.NewCFICode(v)) +} + +//SetRoundingDirection sets RoundingDirection, Tag 468 +func (m ExecutionReport) SetRoundingDirection(v string) { + m.Set(field.NewRoundingDirection(v)) +} + +//SetRoundingModulus sets RoundingModulus, Tag 469 +func (m ExecutionReport) SetRoundingModulus(v float64) { + m.Set(field.NewRoundingModulus(v)) +} + +//SetCountryOfIssue sets CountryOfIssue, Tag 470 +func (m ExecutionReport) SetCountryOfIssue(v string) { + m.Set(field.NewCountryOfIssue(v)) +} + +//SetStateOrProvinceOfIssue sets StateOrProvinceOfIssue, Tag 471 +func (m ExecutionReport) SetStateOrProvinceOfIssue(v string) { + m.Set(field.NewStateOrProvinceOfIssue(v)) +} + +//SetLocaleOfIssue sets LocaleOfIssue, Tag 472 +func (m ExecutionReport) SetLocaleOfIssue(v string) { + m.Set(field.NewLocaleOfIssue(v)) +} + +//SetCommCurrency sets CommCurrency, Tag 479 +func (m ExecutionReport) SetCommCurrency(v string) { + m.Set(field.NewCommCurrency(v)) +} + +//SetCancellationRights sets CancellationRights, Tag 480 +func (m ExecutionReport) SetCancellationRights(v string) { + m.Set(field.NewCancellationRights(v)) +} + +//SetMoneyLaunderingStatus sets MoneyLaunderingStatus, Tag 481 +func (m ExecutionReport) SetMoneyLaunderingStatus(v string) { + m.Set(field.NewMoneyLaunderingStatus(v)) +} + +//SetTransBkdTime sets TransBkdTime, Tag 483 +func (m ExecutionReport) SetTransBkdTime(v time.Time) { + m.Set(field.NewTransBkdTime(v)) +} + +//SetExecPriceType sets ExecPriceType, Tag 484 +func (m ExecutionReport) SetExecPriceType(v string) { + m.Set(field.NewExecPriceType(v)) +} + +//SetExecPriceAdjustment sets ExecPriceAdjustment, Tag 485 +func (m ExecutionReport) SetExecPriceAdjustment(v float64) { + m.Set(field.NewExecPriceAdjustment(v)) +} + +//SetDesignation sets Designation, Tag 494 +func (m ExecutionReport) SetDesignation(v string) { + m.Set(field.NewDesignation(v)) +} + +//SetFundRenewWaiv sets FundRenewWaiv, Tag 497 +func (m ExecutionReport) SetFundRenewWaiv(v string) { + m.Set(field.NewFundRenewWaiv(v)) +} + +//SetRegistID sets RegistID, Tag 513 +func (m ExecutionReport) SetRegistID(v string) { + m.Set(field.NewRegistID(v)) +} + +//SetExecValuationPoint sets ExecValuationPoint, Tag 515 +func (m ExecutionReport) SetExecValuationPoint(v time.Time) { + m.Set(field.NewExecValuationPoint(v)) +} + +//SetOrderPercent sets OrderPercent, Tag 516 +func (m ExecutionReport) SetOrderPercent(v float64) { + m.Set(field.NewOrderPercent(v)) +} + +//SetNoContAmts sets NoContAmts, Tag 518 +func (m ExecutionReport) SetNoContAmts(f NoContAmtsRepeatingGroup) { + m.SetGroup(f) +} + +//SetSecondaryClOrdID sets SecondaryClOrdID, Tag 526 +func (m ExecutionReport) SetSecondaryClOrdID(v string) { + m.Set(field.NewSecondaryClOrdID(v)) +} + +//SetSecondaryExecID sets SecondaryExecID, Tag 527 +func (m ExecutionReport) SetSecondaryExecID(v string) { + m.Set(field.NewSecondaryExecID(v)) +} + +//SetOrderCapacity sets OrderCapacity, Tag 528 +func (m ExecutionReport) SetOrderCapacity(v string) { + m.Set(field.NewOrderCapacity(v)) +} + +//SetOrderRestrictions sets OrderRestrictions, Tag 529 +func (m ExecutionReport) SetOrderRestrictions(v string) { + m.Set(field.NewOrderRestrictions(v)) +} + +//SetMaturityDate sets MaturityDate, Tag 541 +func (m ExecutionReport) SetMaturityDate(v string) { + m.Set(field.NewMaturityDate(v)) +} + +//SetInstrRegistry sets InstrRegistry, Tag 543 +func (m ExecutionReport) SetInstrRegistry(v string) { + m.Set(field.NewInstrRegistry(v)) +} + +//SetCashMargin sets CashMargin, Tag 544 +func (m ExecutionReport) SetCashMargin(v string) { + m.Set(field.NewCashMargin(v)) +} + +//SetCrossID sets CrossID, Tag 548 +func (m ExecutionReport) SetCrossID(v string) { + m.Set(field.NewCrossID(v)) +} + +//SetCrossType sets CrossType, Tag 549 +func (m ExecutionReport) SetCrossType(v int) { + m.Set(field.NewCrossType(v)) +} + +//SetOrigCrossID sets OrigCrossID, Tag 551 +func (m ExecutionReport) SetOrigCrossID(v string) { + m.Set(field.NewOrigCrossID(v)) +} + +//SetNoLegs sets NoLegs, Tag 555 +func (m ExecutionReport) SetNoLegs(f NoLegsRepeatingGroup) { + m.SetGroup(f) +} + +//SetMatchType sets MatchType, Tag 574 +func (m ExecutionReport) SetMatchType(v string) { + m.Set(field.NewMatchType(v)) +} + +//SetAccountType sets AccountType, Tag 581 +func (m ExecutionReport) SetAccountType(v int) { + m.Set(field.NewAccountType(v)) +} + +//SetCustOrderCapacity sets CustOrderCapacity, Tag 582 +func (m ExecutionReport) SetCustOrderCapacity(v int) { + m.Set(field.NewCustOrderCapacity(v)) +} + +//SetClOrdLinkID sets ClOrdLinkID, Tag 583 +func (m ExecutionReport) SetClOrdLinkID(v string) { + m.Set(field.NewClOrdLinkID(v)) +} + +//SetMassStatusReqID sets MassStatusReqID, Tag 584 +func (m ExecutionReport) SetMassStatusReqID(v string) { + m.Set(field.NewMassStatusReqID(v)) +} + +//SetDayBookingInst sets DayBookingInst, Tag 589 +func (m ExecutionReport) SetDayBookingInst(v string) { + m.Set(field.NewDayBookingInst(v)) +} + +//SetBookingUnit sets BookingUnit, Tag 590 +func (m ExecutionReport) SetBookingUnit(v string) { + m.Set(field.NewBookingUnit(v)) +} + +//SetPreallocMethod sets PreallocMethod, Tag 591 +func (m ExecutionReport) SetPreallocMethod(v string) { + m.Set(field.NewPreallocMethod(v)) +} + +//SetTradingSessionSubID sets TradingSessionSubID, Tag 625 +func (m ExecutionReport) SetTradingSessionSubID(v string) { + m.Set(field.NewTradingSessionSubID(v)) +} + +//SetClearingFeeIndicator sets ClearingFeeIndicator, Tag 635 +func (m ExecutionReport) SetClearingFeeIndicator(v string) { + m.Set(field.NewClearingFeeIndicator(v)) +} + +//SetWorkingIndicator sets WorkingIndicator, Tag 636 +func (m ExecutionReport) SetWorkingIndicator(v bool) { + m.Set(field.NewWorkingIndicator(v)) +} + +//SetPriorityIndicator sets PriorityIndicator, Tag 638 +func (m ExecutionReport) SetPriorityIndicator(v int) { + m.Set(field.NewPriorityIndicator(v)) +} + +//SetPriceImprovement sets PriceImprovement, Tag 639 +func (m ExecutionReport) SetPriceImprovement(v float64) { + m.Set(field.NewPriceImprovement(v)) +} + +//SetLastForwardPoints2 sets LastForwardPoints2, Tag 641 +func (m ExecutionReport) SetLastForwardPoints2(v float64) { + m.Set(field.NewLastForwardPoints2(v)) +} + +//SetUnderlyingLastPx sets UnderlyingLastPx, Tag 651 +func (m ExecutionReport) SetUnderlyingLastPx(v float64) { + m.Set(field.NewUnderlyingLastPx(v)) +} + +//SetUnderlyingLastQty sets UnderlyingLastQty, Tag 652 +func (m ExecutionReport) SetUnderlyingLastQty(v float64) { + m.Set(field.NewUnderlyingLastQty(v)) +} + +//SetAcctIDSource sets AcctIDSource, Tag 660 +func (m ExecutionReport) SetAcctIDSource(v int) { + m.Set(field.NewAcctIDSource(v)) +} + +//SetBenchmarkPrice sets BenchmarkPrice, Tag 662 +func (m ExecutionReport) SetBenchmarkPrice(v float64) { + m.Set(field.NewBenchmarkPrice(v)) +} + +//SetBenchmarkPriceType sets BenchmarkPriceType, Tag 663 +func (m ExecutionReport) SetBenchmarkPriceType(v int) { + m.Set(field.NewBenchmarkPriceType(v)) +} + +//SetContractSettlMonth sets ContractSettlMonth, Tag 667 +func (m ExecutionReport) SetContractSettlMonth(v string) { + m.Set(field.NewContractSettlMonth(v)) +} + +//SetLastParPx sets LastParPx, Tag 669 +func (m ExecutionReport) SetLastParPx(v float64) { + m.Set(field.NewLastParPx(v)) +} + +//SetPool sets Pool, Tag 691 +func (m ExecutionReport) SetPool(v string) { + m.Set(field.NewPool(v)) +} + +//SetQuoteRespID sets QuoteRespID, Tag 693 +func (m ExecutionReport) SetQuoteRespID(v string) { + m.Set(field.NewQuoteRespID(v)) +} + +//SetYieldRedemptionDate sets YieldRedemptionDate, Tag 696 +func (m ExecutionReport) SetYieldRedemptionDate(v string) { + m.Set(field.NewYieldRedemptionDate(v)) +} + +//SetYieldRedemptionPrice sets YieldRedemptionPrice, Tag 697 +func (m ExecutionReport) SetYieldRedemptionPrice(v float64) { + m.Set(field.NewYieldRedemptionPrice(v)) +} + +//SetYieldRedemptionPriceType sets YieldRedemptionPriceType, Tag 698 +func (m ExecutionReport) SetYieldRedemptionPriceType(v int) { + m.Set(field.NewYieldRedemptionPriceType(v)) +} + +//SetBenchmarkSecurityID sets BenchmarkSecurityID, Tag 699 +func (m ExecutionReport) SetBenchmarkSecurityID(v string) { + m.Set(field.NewBenchmarkSecurityID(v)) +} + +//SetYieldCalcDate sets YieldCalcDate, Tag 701 +func (m ExecutionReport) SetYieldCalcDate(v string) { + m.Set(field.NewYieldCalcDate(v)) +} + +//SetNoUnderlyings sets NoUnderlyings, Tag 711 +func (m ExecutionReport) SetNoUnderlyings(f NoUnderlyingsRepeatingGroup) { + m.SetGroup(f) +} + +//SetInterestAtMaturity sets InterestAtMaturity, Tag 738 +func (m ExecutionReport) SetInterestAtMaturity(v float64) { + m.Set(field.NewInterestAtMaturity(v)) +} + +//SetBenchmarkSecurityIDSource sets BenchmarkSecurityIDSource, Tag 761 +func (m ExecutionReport) SetBenchmarkSecurityIDSource(v string) { + m.Set(field.NewBenchmarkSecurityIDSource(v)) +} + +//SetSecuritySubType sets SecuritySubType, Tag 762 +func (m ExecutionReport) SetSecuritySubType(v string) { + m.Set(field.NewSecuritySubType(v)) +} + +//SetNoTrdRegTimestamps sets NoTrdRegTimestamps, Tag 768 +func (m ExecutionReport) SetNoTrdRegTimestamps(f NoTrdRegTimestampsRepeatingGroup) { + m.SetGroup(f) +} + +//SetBookingType sets BookingType, Tag 775 +func (m ExecutionReport) SetBookingType(v int) { + m.Set(field.NewBookingType(v)) +} + +//SetTerminationType sets TerminationType, Tag 788 +func (m ExecutionReport) SetTerminationType(v int) { + m.Set(field.NewTerminationType(v)) +} + +//SetOrdStatusReqID sets OrdStatusReqID, Tag 790 +func (m ExecutionReport) SetOrdStatusReqID(v string) { + m.Set(field.NewOrdStatusReqID(v)) +} + +//SetCopyMsgIndicator sets CopyMsgIndicator, Tag 797 +func (m ExecutionReport) SetCopyMsgIndicator(v bool) { + m.Set(field.NewCopyMsgIndicator(v)) +} + +//SetPegMoveType sets PegMoveType, Tag 835 +func (m ExecutionReport) SetPegMoveType(v int) { + m.Set(field.NewPegMoveType(v)) +} + +//SetPegOffsetType sets PegOffsetType, Tag 836 +func (m ExecutionReport) SetPegOffsetType(v int) { + m.Set(field.NewPegOffsetType(v)) +} + +//SetPegLimitType sets PegLimitType, Tag 837 +func (m ExecutionReport) SetPegLimitType(v int) { + m.Set(field.NewPegLimitType(v)) +} + +//SetPegRoundDirection sets PegRoundDirection, Tag 838 +func (m ExecutionReport) SetPegRoundDirection(v int) { + m.Set(field.NewPegRoundDirection(v)) +} + +//SetPeggedPrice sets PeggedPrice, Tag 839 +func (m ExecutionReport) SetPeggedPrice(v float64) { + m.Set(field.NewPeggedPrice(v)) +} + +//SetPegScope sets PegScope, Tag 840 +func (m ExecutionReport) SetPegScope(v int) { + m.Set(field.NewPegScope(v)) +} + +//SetDiscretionMoveType sets DiscretionMoveType, Tag 841 +func (m ExecutionReport) SetDiscretionMoveType(v int) { + m.Set(field.NewDiscretionMoveType(v)) +} + +//SetDiscretionOffsetType sets DiscretionOffsetType, Tag 842 +func (m ExecutionReport) SetDiscretionOffsetType(v int) { + m.Set(field.NewDiscretionOffsetType(v)) +} + +//SetDiscretionLimitType sets DiscretionLimitType, Tag 843 +func (m ExecutionReport) SetDiscretionLimitType(v int) { + m.Set(field.NewDiscretionLimitType(v)) +} + +//SetDiscretionRoundDirection sets DiscretionRoundDirection, Tag 844 +func (m ExecutionReport) SetDiscretionRoundDirection(v int) { + m.Set(field.NewDiscretionRoundDirection(v)) +} + +//SetDiscretionPrice sets DiscretionPrice, Tag 845 +func (m ExecutionReport) SetDiscretionPrice(v float64) { + m.Set(field.NewDiscretionPrice(v)) +} + +//SetDiscretionScope sets DiscretionScope, Tag 846 +func (m ExecutionReport) SetDiscretionScope(v int) { + m.Set(field.NewDiscretionScope(v)) +} + +//SetTargetStrategy sets TargetStrategy, Tag 847 +func (m ExecutionReport) SetTargetStrategy(v int) { + m.Set(field.NewTargetStrategy(v)) +} + +//SetTargetStrategyParameters sets TargetStrategyParameters, Tag 848 +func (m ExecutionReport) SetTargetStrategyParameters(v string) { + m.Set(field.NewTargetStrategyParameters(v)) +} + +//SetParticipationRate sets ParticipationRate, Tag 849 +func (m ExecutionReport) SetParticipationRate(v float64) { + m.Set(field.NewParticipationRate(v)) +} + +//SetTargetStrategyPerformance sets TargetStrategyPerformance, Tag 850 +func (m ExecutionReport) SetTargetStrategyPerformance(v float64) { + m.Set(field.NewTargetStrategyPerformance(v)) +} + +//SetLastLiquidityInd sets LastLiquidityInd, Tag 851 +func (m ExecutionReport) SetLastLiquidityInd(v int) { + m.Set(field.NewLastLiquidityInd(v)) +} + +//SetQtyType sets QtyType, Tag 854 +func (m ExecutionReport) SetQtyType(v int) { + m.Set(field.NewQtyType(v)) +} + +//SetNoEvents sets NoEvents, Tag 864 +func (m ExecutionReport) SetNoEvents(f NoEventsRepeatingGroup) { + m.SetGroup(f) +} + +//SetDatedDate sets DatedDate, Tag 873 +func (m ExecutionReport) SetDatedDate(v string) { + m.Set(field.NewDatedDate(v)) +} + +//SetInterestAccrualDate sets InterestAccrualDate, Tag 874 +func (m ExecutionReport) SetInterestAccrualDate(v string) { + m.Set(field.NewInterestAccrualDate(v)) +} + +//SetCPProgram sets CPProgram, Tag 875 +func (m ExecutionReport) SetCPProgram(v int) { + m.Set(field.NewCPProgram(v)) +} + +//SetCPRegType sets CPRegType, Tag 876 +func (m ExecutionReport) SetCPRegType(v string) { + m.Set(field.NewCPRegType(v)) +} + +//SetMarginRatio sets MarginRatio, Tag 898 +func (m ExecutionReport) SetMarginRatio(v float64) { + m.Set(field.NewMarginRatio(v)) +} + +//SetTotNumReports sets TotNumReports, Tag 911 +func (m ExecutionReport) SetTotNumReports(v int) { + m.Set(field.NewTotNumReports(v)) +} + +//SetLastRptRequested sets LastRptRequested, Tag 912 +func (m ExecutionReport) SetLastRptRequested(v bool) { + m.Set(field.NewLastRptRequested(v)) +} + +//SetAgreementDesc sets AgreementDesc, Tag 913 +func (m ExecutionReport) SetAgreementDesc(v string) { + m.Set(field.NewAgreementDesc(v)) +} + +//SetAgreementID sets AgreementID, Tag 914 +func (m ExecutionReport) SetAgreementID(v string) { + m.Set(field.NewAgreementID(v)) +} + +//SetAgreementDate sets AgreementDate, Tag 915 +func (m ExecutionReport) SetAgreementDate(v string) { + m.Set(field.NewAgreementDate(v)) +} + +//SetStartDate sets StartDate, Tag 916 +func (m ExecutionReport) SetStartDate(v string) { + m.Set(field.NewStartDate(v)) +} + +//SetEndDate sets EndDate, Tag 917 +func (m ExecutionReport) SetEndDate(v string) { + m.Set(field.NewEndDate(v)) +} + +//SetAgreementCurrency sets AgreementCurrency, Tag 918 +func (m ExecutionReport) SetAgreementCurrency(v string) { + m.Set(field.NewAgreementCurrency(v)) +} + +//SetDeliveryType sets DeliveryType, Tag 919 +func (m ExecutionReport) SetDeliveryType(v int) { + m.Set(field.NewDeliveryType(v)) +} + +//SetEndAccruedInterestAmt sets EndAccruedInterestAmt, Tag 920 +func (m ExecutionReport) SetEndAccruedInterestAmt(v float64) { + m.Set(field.NewEndAccruedInterestAmt(v)) +} + +//SetStartCash sets StartCash, Tag 921 +func (m ExecutionReport) SetStartCash(v float64) { + m.Set(field.NewStartCash(v)) +} + +//SetEndCash sets EndCash, Tag 922 +func (m ExecutionReport) SetEndCash(v float64) { + m.Set(field.NewEndCash(v)) +} + +//SetTimeBracket sets TimeBracket, Tag 943 +func (m ExecutionReport) SetTimeBracket(v string) { + m.Set(field.NewTimeBracket(v)) +} + +//SetStrikeCurrency sets StrikeCurrency, Tag 947 +func (m ExecutionReport) SetStrikeCurrency(v string) { + m.Set(field.NewStrikeCurrency(v)) +} + +//SetNoStrategyParameters sets NoStrategyParameters, Tag 957 +func (m ExecutionReport) SetNoStrategyParameters(f NoStrategyParametersRepeatingGroup) { + m.SetGroup(f) +} + +//SetHostCrossID sets HostCrossID, Tag 961 +func (m ExecutionReport) SetHostCrossID(v string) { + m.Set(field.NewHostCrossID(v)) +} + +//SetSecurityStatus sets SecurityStatus, Tag 965 +func (m ExecutionReport) SetSecurityStatus(v string) { + m.Set(field.NewSecurityStatus(v)) +} + +//SetSettleOnOpenFlag sets SettleOnOpenFlag, Tag 966 +func (m ExecutionReport) SetSettleOnOpenFlag(v string) { + m.Set(field.NewSettleOnOpenFlag(v)) +} + +//SetStrikeMultiplier sets StrikeMultiplier, Tag 967 +func (m ExecutionReport) SetStrikeMultiplier(v float64) { + m.Set(field.NewStrikeMultiplier(v)) +} + +//SetStrikeValue sets StrikeValue, Tag 968 +func (m ExecutionReport) SetStrikeValue(v float64) { + m.Set(field.NewStrikeValue(v)) +} + +//SetMinPriceIncrement sets MinPriceIncrement, Tag 969 +func (m ExecutionReport) SetMinPriceIncrement(v float64) { + m.Set(field.NewMinPriceIncrement(v)) +} + +//SetPositionLimit sets PositionLimit, Tag 970 +func (m ExecutionReport) SetPositionLimit(v int) { + m.Set(field.NewPositionLimit(v)) +} + +//SetNTPositionLimit sets NTPositionLimit, Tag 971 +func (m ExecutionReport) SetNTPositionLimit(v int) { + m.Set(field.NewNTPositionLimit(v)) +} + +//SetUnitOfMeasure sets UnitOfMeasure, Tag 996 +func (m ExecutionReport) SetUnitOfMeasure(v string) { + m.Set(field.NewUnitOfMeasure(v)) +} + +//SetTimeUnit sets TimeUnit, Tag 997 +func (m ExecutionReport) SetTimeUnit(v string) { + m.Set(field.NewTimeUnit(v)) +} + +//SetNoInstrumentParties sets NoInstrumentParties, Tag 1018 +func (m ExecutionReport) SetNoInstrumentParties(f NoInstrumentPartiesRepeatingGroup) { + m.SetGroup(f) +} + +//SetManualOrderIndicator sets ManualOrderIndicator, Tag 1028 +func (m ExecutionReport) SetManualOrderIndicator(v bool) { + m.Set(field.NewManualOrderIndicator(v)) +} + +//SetCustDirectedOrder sets CustDirectedOrder, Tag 1029 +func (m ExecutionReport) SetCustDirectedOrder(v bool) { + m.Set(field.NewCustDirectedOrder(v)) +} + +//SetReceivedDeptID sets ReceivedDeptID, Tag 1030 +func (m ExecutionReport) SetReceivedDeptID(v string) { + m.Set(field.NewReceivedDeptID(v)) +} + +//SetCustOrderHandlingInst sets CustOrderHandlingInst, Tag 1031 +func (m ExecutionReport) SetCustOrderHandlingInst(v string) { + m.Set(field.NewCustOrderHandlingInst(v)) +} + +//SetOrderHandlingInstSource sets OrderHandlingInstSource, Tag 1032 +func (m ExecutionReport) SetOrderHandlingInstSource(v int) { + m.Set(field.NewOrderHandlingInstSource(v)) +} + +//SetInstrmtAssignmentMethod sets InstrmtAssignmentMethod, Tag 1049 +func (m ExecutionReport) SetInstrmtAssignmentMethod(v string) { + m.Set(field.NewInstrmtAssignmentMethod(v)) +} + +//SetCalculatedCcyLastQty sets CalculatedCcyLastQty, Tag 1056 +func (m ExecutionReport) SetCalculatedCcyLastQty(v float64) { + m.Set(field.NewCalculatedCcyLastQty(v)) +} + +//SetAggressorIndicator sets AggressorIndicator, Tag 1057 +func (m ExecutionReport) SetAggressorIndicator(v bool) { + m.Set(field.NewAggressorIndicator(v)) +} + +//SetLastSwapPoints sets LastSwapPoints, Tag 1071 +func (m ExecutionReport) SetLastSwapPoints(v float64) { + m.Set(field.NewLastSwapPoints(v)) +} + +//SetMaturityTime sets MaturityTime, Tag 1079 +func (m ExecutionReport) SetMaturityTime(v string) { + m.Set(field.NewMaturityTime(v)) +} + +//SetSecondaryDisplayQty sets SecondaryDisplayQty, Tag 1082 +func (m ExecutionReport) SetSecondaryDisplayQty(v float64) { + m.Set(field.NewSecondaryDisplayQty(v)) +} + +//SetDisplayWhen sets DisplayWhen, Tag 1083 +func (m ExecutionReport) SetDisplayWhen(v string) { + m.Set(field.NewDisplayWhen(v)) +} + +//SetDisplayMethod sets DisplayMethod, Tag 1084 +func (m ExecutionReport) SetDisplayMethod(v string) { + m.Set(field.NewDisplayMethod(v)) +} + +//SetDisplayLowQty sets DisplayLowQty, Tag 1085 +func (m ExecutionReport) SetDisplayLowQty(v float64) { + m.Set(field.NewDisplayLowQty(v)) +} + +//SetDisplayHighQty sets DisplayHighQty, Tag 1086 +func (m ExecutionReport) SetDisplayHighQty(v float64) { + m.Set(field.NewDisplayHighQty(v)) +} + +//SetDisplayMinIncr sets DisplayMinIncr, Tag 1087 +func (m ExecutionReport) SetDisplayMinIncr(v float64) { + m.Set(field.NewDisplayMinIncr(v)) +} + +//SetRefreshQty sets RefreshQty, Tag 1088 +func (m ExecutionReport) SetRefreshQty(v float64) { + m.Set(field.NewRefreshQty(v)) +} + +//SetMatchIncrement sets MatchIncrement, Tag 1089 +func (m ExecutionReport) SetMatchIncrement(v float64) { + m.Set(field.NewMatchIncrement(v)) +} + +//SetMaxPriceLevels sets MaxPriceLevels, Tag 1090 +func (m ExecutionReport) SetMaxPriceLevels(v int) { + m.Set(field.NewMaxPriceLevels(v)) +} + +//SetPreTradeAnonymity sets PreTradeAnonymity, Tag 1091 +func (m ExecutionReport) SetPreTradeAnonymity(v bool) { + m.Set(field.NewPreTradeAnonymity(v)) +} + +//SetPriceProtectionScope sets PriceProtectionScope, Tag 1092 +func (m ExecutionReport) SetPriceProtectionScope(v string) { + m.Set(field.NewPriceProtectionScope(v)) +} + +//SetLotType sets LotType, Tag 1093 +func (m ExecutionReport) SetLotType(v string) { + m.Set(field.NewLotType(v)) +} + +//SetPegPriceType sets PegPriceType, Tag 1094 +func (m ExecutionReport) SetPegPriceType(v int) { + m.Set(field.NewPegPriceType(v)) +} + +//SetPeggedRefPrice sets PeggedRefPrice, Tag 1095 +func (m ExecutionReport) SetPeggedRefPrice(v float64) { + m.Set(field.NewPeggedRefPrice(v)) +} + +//SetPegSecurityIDSource sets PegSecurityIDSource, Tag 1096 +func (m ExecutionReport) SetPegSecurityIDSource(v string) { + m.Set(field.NewPegSecurityIDSource(v)) +} + +//SetPegSecurityID sets PegSecurityID, Tag 1097 +func (m ExecutionReport) SetPegSecurityID(v string) { + m.Set(field.NewPegSecurityID(v)) +} + +//SetPegSymbol sets PegSymbol, Tag 1098 +func (m ExecutionReport) SetPegSymbol(v string) { + m.Set(field.NewPegSymbol(v)) +} + +//SetPegSecurityDesc sets PegSecurityDesc, Tag 1099 +func (m ExecutionReport) SetPegSecurityDesc(v string) { + m.Set(field.NewPegSecurityDesc(v)) +} + +//SetTriggerType sets TriggerType, Tag 1100 +func (m ExecutionReport) SetTriggerType(v string) { + m.Set(field.NewTriggerType(v)) +} + +//SetTriggerAction sets TriggerAction, Tag 1101 +func (m ExecutionReport) SetTriggerAction(v string) { + m.Set(field.NewTriggerAction(v)) +} + +//SetTriggerPrice sets TriggerPrice, Tag 1102 +func (m ExecutionReport) SetTriggerPrice(v float64) { + m.Set(field.NewTriggerPrice(v)) +} + +//SetTriggerSymbol sets TriggerSymbol, Tag 1103 +func (m ExecutionReport) SetTriggerSymbol(v string) { + m.Set(field.NewTriggerSymbol(v)) +} + +//SetTriggerSecurityID sets TriggerSecurityID, Tag 1104 +func (m ExecutionReport) SetTriggerSecurityID(v string) { + m.Set(field.NewTriggerSecurityID(v)) +} + +//SetTriggerSecurityIDSource sets TriggerSecurityIDSource, Tag 1105 +func (m ExecutionReport) SetTriggerSecurityIDSource(v string) { + m.Set(field.NewTriggerSecurityIDSource(v)) +} + +//SetTriggerSecurityDesc sets TriggerSecurityDesc, Tag 1106 +func (m ExecutionReport) SetTriggerSecurityDesc(v string) { + m.Set(field.NewTriggerSecurityDesc(v)) +} + +//SetTriggerPriceType sets TriggerPriceType, Tag 1107 +func (m ExecutionReport) SetTriggerPriceType(v string) { + m.Set(field.NewTriggerPriceType(v)) +} + +//SetTriggerPriceTypeScope sets TriggerPriceTypeScope, Tag 1108 +func (m ExecutionReport) SetTriggerPriceTypeScope(v string) { + m.Set(field.NewTriggerPriceTypeScope(v)) +} + +//SetTriggerPriceDirection sets TriggerPriceDirection, Tag 1109 +func (m ExecutionReport) SetTriggerPriceDirection(v string) { + m.Set(field.NewTriggerPriceDirection(v)) +} + +//SetTriggerNewPrice sets TriggerNewPrice, Tag 1110 +func (m ExecutionReport) SetTriggerNewPrice(v float64) { + m.Set(field.NewTriggerNewPrice(v)) +} + +//SetTriggerOrderType sets TriggerOrderType, Tag 1111 +func (m ExecutionReport) SetTriggerOrderType(v string) { + m.Set(field.NewTriggerOrderType(v)) +} + +//SetTriggerNewQty sets TriggerNewQty, Tag 1112 +func (m ExecutionReport) SetTriggerNewQty(v float64) { + m.Set(field.NewTriggerNewQty(v)) +} + +//SetTriggerTradingSessionID sets TriggerTradingSessionID, Tag 1113 +func (m ExecutionReport) SetTriggerTradingSessionID(v string) { + m.Set(field.NewTriggerTradingSessionID(v)) +} + +//SetTriggerTradingSessionSubID sets TriggerTradingSessionSubID, Tag 1114 +func (m ExecutionReport) SetTriggerTradingSessionSubID(v string) { + m.Set(field.NewTriggerTradingSessionSubID(v)) +} + +//SetOrderCategory sets OrderCategory, Tag 1115 +func (m ExecutionReport) SetOrderCategory(v string) { + m.Set(field.NewOrderCategory(v)) +} + +//SetDisplayQty sets DisplayQty, Tag 1138 +func (m ExecutionReport) SetDisplayQty(v float64) { + m.Set(field.NewDisplayQty(v)) +} + +//GetAccount gets Account, Tag 1 +func (m ExecutionReport) GetAccount() (f field.AccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAvgPx gets AvgPx, Tag 6 +func (m ExecutionReport) GetAvgPx() (f field.AvgPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdID gets ClOrdID, Tag 11 +func (m ExecutionReport) GetClOrdID() (f field.ClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommission gets Commission, Tag 12 +func (m ExecutionReport) GetCommission() (f field.CommissionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommType gets CommType, Tag 13 +func (m ExecutionReport) GetCommType() (f field.CommTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCumQty gets CumQty, Tag 14 +func (m ExecutionReport) GetCumQty() (f field.CumQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCurrency gets Currency, Tag 15 +func (m ExecutionReport) GetCurrency() (f field.CurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecID gets ExecID, Tag 17 +func (m ExecutionReport) GetExecID() (f field.ExecIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecInst gets ExecInst, Tag 18 +func (m ExecutionReport) GetExecInst() (f field.ExecInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecRefID gets ExecRefID, Tag 19 +func (m ExecutionReport) GetExecRefID() (f field.ExecRefIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetHandlInst gets HandlInst, Tag 21 +func (m ExecutionReport) GetHandlInst() (f field.HandlInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityIDSource gets SecurityIDSource, Tag 22 +func (m ExecutionReport) GetSecurityIDSource() (f field.SecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastCapacity gets LastCapacity, Tag 29 +func (m ExecutionReport) GetLastCapacity() (f field.LastCapacityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastMkt gets LastMkt, Tag 30 +func (m ExecutionReport) GetLastMkt() (f field.LastMktField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastPx gets LastPx, Tag 31 +func (m ExecutionReport) GetLastPx() (f field.LastPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastQty gets LastQty, Tag 32 +func (m ExecutionReport) GetLastQty() (f field.LastQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderID gets OrderID, Tag 37 +func (m ExecutionReport) GetOrderID() (f field.OrderIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty gets OrderQty, Tag 38 +func (m ExecutionReport) GetOrderQty() (f field.OrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdStatus gets OrdStatus, Tag 39 +func (m ExecutionReport) GetOrdStatus() (f field.OrdStatusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdType gets OrdType, Tag 40 +func (m ExecutionReport) GetOrdType() (f field.OrdTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrigClOrdID gets OrigClOrdID, Tag 41 +func (m ExecutionReport) GetOrigClOrdID() (f field.OrigClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrice gets Price, Tag 44 +func (m ExecutionReport) GetPrice() (f field.PriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m ExecutionReport) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSide gets Side, Tag 54 +func (m ExecutionReport) GetSide() (f field.SideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbol gets Symbol, Tag 55 +func (m ExecutionReport) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetText gets Text, Tag 58 +func (m ExecutionReport) GetText() (f field.TextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTimeInForce gets TimeInForce, Tag 59 +func (m ExecutionReport) GetTimeInForce() (f field.TimeInForceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTransactTime gets TransactTime, Tag 60 +func (m ExecutionReport) GetTransactTime() (f field.TransactTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlType gets SettlType, Tag 63 +func (m ExecutionReport) GetSettlType() (f field.SettlTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlDate gets SettlDate, Tag 64 +func (m ExecutionReport) GetSettlDate() (f field.SettlDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m ExecutionReport) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetListID gets ListID, Tag 66 +func (m ExecutionReport) GetListID() (f field.ListIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradeDate gets TradeDate, Tag 75 +func (m ExecutionReport) GetTradeDate() (f field.TradeDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPositionEffect gets PositionEffect, Tag 77 +func (m ExecutionReport) GetPositionEffect() (f field.PositionEffectField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStopPx gets StopPx, Tag 99 +func (m ExecutionReport) GetStopPx() (f field.StopPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdRejReason gets OrdRejReason, Tag 103 +func (m ExecutionReport) GetOrdRejReason() (f field.OrdRejReasonField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m ExecutionReport) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m ExecutionReport) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMinQty gets MinQty, Tag 110 +func (m ExecutionReport) GetMinQty() (f field.MinQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxFloor gets MaxFloor, Tag 111 +func (m ExecutionReport) GetMaxFloor() (f field.MaxFloorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetReportToExch gets ReportToExch, Tag 113 +func (m ExecutionReport) GetReportToExch() (f field.ReportToExchField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNetMoney gets NetMoney, Tag 118 +func (m ExecutionReport) GetNetMoney() (f field.NetMoneyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrAmt gets SettlCurrAmt, Tag 119 +func (m ExecutionReport) GetSettlCurrAmt() (f field.SettlCurrAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrency gets SettlCurrency, Tag 120 +func (m ExecutionReport) GetSettlCurrency() (f field.SettlCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireTime gets ExpireTime, Tag 126 +func (m ExecutionReport) GetExpireTime() (f field.ExpireTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoMiscFees gets NoMiscFees, Tag 136 +func (m ExecutionReport) GetNoMiscFees() (NoMiscFeesRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoMiscFeesRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetExecType gets ExecType, Tag 150 +func (m ExecutionReport) GetExecType() (f field.ExecTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLeavesQty gets LeavesQty, Tag 151 +func (m ExecutionReport) GetLeavesQty() (f field.LeavesQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashOrderQty gets CashOrderQty, Tag 152 +func (m ExecutionReport) GetCashOrderQty() (f field.CashOrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrFxRate gets SettlCurrFxRate, Tag 155 +func (m ExecutionReport) GetSettlCurrFxRate() (f field.SettlCurrFxRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrFxRateCalc gets SettlCurrFxRateCalc, Tag 156 +func (m ExecutionReport) GetSettlCurrFxRateCalc() (f field.SettlCurrFxRateCalcField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNumDaysInterest gets NumDaysInterest, Tag 157 +func (m ExecutionReport) GetNumDaysInterest() (f field.NumDaysInterestField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAccruedInterestRate gets AccruedInterestRate, Tag 158 +func (m ExecutionReport) GetAccruedInterestRate() (f field.AccruedInterestRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAccruedInterestAmt gets AccruedInterestAmt, Tag 159 +func (m ExecutionReport) GetAccruedInterestAmt() (f field.AccruedInterestAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityType gets SecurityType, Tag 167 +func (m ExecutionReport) GetSecurityType() (f field.SecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEffectiveTime gets EffectiveTime, Tag 168 +func (m ExecutionReport) GetEffectiveTime() (f field.EffectiveTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty2 gets OrderQty2, Tag 192 +func (m ExecutionReport) GetOrderQty2() (f field.OrderQty2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlDate2 gets SettlDate2, Tag 193 +func (m ExecutionReport) GetSettlDate2() (f field.SettlDate2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastSpotRate gets LastSpotRate, Tag 194 +func (m ExecutionReport) GetLastSpotRate() (f field.LastSpotRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastForwardPoints gets LastForwardPoints, Tag 195 +func (m ExecutionReport) GetLastForwardPoints() (f field.LastForwardPointsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecondaryOrderID gets SecondaryOrderID, Tag 198 +func (m ExecutionReport) GetSecondaryOrderID() (f field.SecondaryOrderIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityMonthYear gets MaturityMonthYear, Tag 200 +func (m ExecutionReport) GetMaturityMonthYear() (f field.MaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikePrice gets StrikePrice, Tag 202 +func (m ExecutionReport) GetStrikePrice() (f field.StrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOptAttribute gets OptAttribute, Tag 206 +func (m ExecutionReport) GetOptAttribute() (f field.OptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityExchange gets SecurityExchange, Tag 207 +func (m ExecutionReport) GetSecurityExchange() (f field.SecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxShow gets MaxShow, Tag 210 +func (m ExecutionReport) GetMaxShow() (f field.MaxShowField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegOffsetValue gets PegOffsetValue, Tag 211 +func (m ExecutionReport) GetPegOffsetValue() (f field.PegOffsetValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSpread gets Spread, Tag 218 +func (m ExecutionReport) GetSpread() (f field.SpreadField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkCurveCurrency gets BenchmarkCurveCurrency, Tag 220 +func (m ExecutionReport) GetBenchmarkCurveCurrency() (f field.BenchmarkCurveCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkCurveName gets BenchmarkCurveName, Tag 221 +func (m ExecutionReport) GetBenchmarkCurveName() (f field.BenchmarkCurveNameField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkCurvePoint gets BenchmarkCurvePoint, Tag 222 +func (m ExecutionReport) GetBenchmarkCurvePoint() (f field.BenchmarkCurvePointField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponRate gets CouponRate, Tag 223 +func (m ExecutionReport) GetCouponRate() (f field.CouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponPaymentDate gets CouponPaymentDate, Tag 224 +func (m ExecutionReport) GetCouponPaymentDate() (f field.CouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssueDate gets IssueDate, Tag 225 +func (m ExecutionReport) GetIssueDate() (f field.IssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseTerm gets RepurchaseTerm, Tag 226 +func (m ExecutionReport) GetRepurchaseTerm() (f field.RepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseRate gets RepurchaseRate, Tag 227 +func (m ExecutionReport) GetRepurchaseRate() (f field.RepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFactor gets Factor, Tag 228 +func (m ExecutionReport) GetFactor() (f field.FactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradeOriginationDate gets TradeOriginationDate, Tag 229 +func (m ExecutionReport) GetTradeOriginationDate() (f field.TradeOriginationDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExDate gets ExDate, Tag 230 +func (m ExecutionReport) GetExDate() (f field.ExDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractMultiplier gets ContractMultiplier, Tag 231 +func (m ExecutionReport) GetContractMultiplier() (f field.ContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoStipulations gets NoStipulations, Tag 232 +func (m ExecutionReport) GetNoStipulations() (NoStipulationsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoStipulationsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetYieldType gets YieldType, Tag 235 +func (m ExecutionReport) GetYieldType() (f field.YieldTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYield gets Yield, Tag 236 +func (m ExecutionReport) GetYield() (f field.YieldField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTotalTakedown gets TotalTakedown, Tag 237 +func (m ExecutionReport) GetTotalTakedown() (f field.TotalTakedownField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetConcession gets Concession, Tag 238 +func (m ExecutionReport) GetConcession() (f field.ConcessionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepoCollateralSecurityType gets RepoCollateralSecurityType, Tag 239 +func (m ExecutionReport) GetRepoCollateralSecurityType() (f field.RepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRedemptionDate gets RedemptionDate, Tag 240 +func (m ExecutionReport) GetRedemptionDate() (f field.RedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCreditRating gets CreditRating, Tag 255 +func (m ExecutionReport) GetCreditRating() (f field.CreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradedFlatSwitch gets TradedFlatSwitch, Tag 258 +func (m ExecutionReport) GetTradedFlatSwitch() (f field.TradedFlatSwitchField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBasisFeatureDate gets BasisFeatureDate, Tag 259 +func (m ExecutionReport) GetBasisFeatureDate() (f field.BasisFeatureDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBasisFeaturePrice gets BasisFeaturePrice, Tag 260 +func (m ExecutionReport) GetBasisFeaturePrice() (f field.BasisFeaturePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradingSessionID gets TradingSessionID, Tag 336 +func (m ExecutionReport) GetTradingSessionID() (f field.TradingSessionIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuerLen gets EncodedIssuerLen, Tag 348 +func (m ExecutionReport) GetEncodedIssuerLen() (f field.EncodedIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuer gets EncodedIssuer, Tag 349 +func (m ExecutionReport) GetEncodedIssuer() (f field.EncodedIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDescLen gets EncodedSecurityDescLen, Tag 350 +func (m ExecutionReport) GetEncodedSecurityDescLen() (f field.EncodedSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDesc gets EncodedSecurityDesc, Tag 351 +func (m ExecutionReport) GetEncodedSecurityDesc() (f field.EncodedSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedTextLen gets EncodedTextLen, Tag 354 +func (m ExecutionReport) GetEncodedTextLen() (f field.EncodedTextLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedText gets EncodedText, Tag 355 +func (m ExecutionReport) GetEncodedText() (f field.EncodedTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetComplianceID gets ComplianceID, Tag 376 +func (m ExecutionReport) GetComplianceID() (f field.ComplianceIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSolicitedFlag gets SolicitedFlag, Tag 377 +func (m ExecutionReport) GetSolicitedFlag() (f field.SolicitedFlagField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecRestatementReason gets ExecRestatementReason, Tag 378 +func (m ExecutionReport) GetExecRestatementReason() (f field.ExecRestatementReasonField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetGrossTradeAmt gets GrossTradeAmt, Tag 381 +func (m ExecutionReport) GetGrossTradeAmt() (f field.GrossTradeAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoContraBrokers gets NoContraBrokers, Tag 382 +func (m ExecutionReport) GetNoContraBrokers() (NoContraBrokersRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoContraBrokersRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetDiscretionInst gets DiscretionInst, Tag 388 +func (m ExecutionReport) GetDiscretionInst() (f field.DiscretionInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionOffsetValue gets DiscretionOffsetValue, Tag 389 +func (m ExecutionReport) GetDiscretionOffsetValue() (f field.DiscretionOffsetValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPriceType gets PriceType, Tag 423 +func (m ExecutionReport) GetPriceType() (f field.PriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDayOrderQty gets DayOrderQty, Tag 424 +func (m ExecutionReport) GetDayOrderQty() (f field.DayOrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDayCumQty gets DayCumQty, Tag 425 +func (m ExecutionReport) GetDayCumQty() (f field.DayCumQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDayAvgPx gets DayAvgPx, Tag 426 +func (m ExecutionReport) GetDayAvgPx() (f field.DayAvgPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetGTBookingInst gets GTBookingInst, Tag 427 +func (m ExecutionReport) GetGTBookingInst() (f field.GTBookingInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireDate gets ExpireDate, Tag 432 +func (m ExecutionReport) GetExpireDate() (f field.ExpireDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMultiLegReportingType gets MultiLegReportingType, Tag 442 +func (m ExecutionReport) GetMultiLegReportingType() (f field.MultiLegReportingTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoPartyIDs gets NoPartyIDs, Tag 453 +func (m ExecutionReport) GetNoPartyIDs() (NoPartyIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoPartyIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetNoSecurityAltID gets NoSecurityAltID, Tag 454 +func (m ExecutionReport) GetNoSecurityAltID() (NoSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetProduct gets Product, Tag 460 +func (m ExecutionReport) GetProduct() (f field.ProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCFICode gets CFICode, Tag 461 +func (m ExecutionReport) GetCFICode() (f field.CFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRoundingDirection gets RoundingDirection, Tag 468 +func (m ExecutionReport) GetRoundingDirection() (f field.RoundingDirectionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRoundingModulus gets RoundingModulus, Tag 469 +func (m ExecutionReport) GetRoundingModulus() (f field.RoundingModulusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCountryOfIssue gets CountryOfIssue, Tag 470 +func (m ExecutionReport) GetCountryOfIssue() (f field.CountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStateOrProvinceOfIssue gets StateOrProvinceOfIssue, Tag 471 +func (m ExecutionReport) GetStateOrProvinceOfIssue() (f field.StateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLocaleOfIssue gets LocaleOfIssue, Tag 472 +func (m ExecutionReport) GetLocaleOfIssue() (f field.LocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommCurrency gets CommCurrency, Tag 479 +func (m ExecutionReport) GetCommCurrency() (f field.CommCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCancellationRights gets CancellationRights, Tag 480 +func (m ExecutionReport) GetCancellationRights() (f field.CancellationRightsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMoneyLaunderingStatus gets MoneyLaunderingStatus, Tag 481 +func (m ExecutionReport) GetMoneyLaunderingStatus() (f field.MoneyLaunderingStatusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTransBkdTime gets TransBkdTime, Tag 483 +func (m ExecutionReport) GetTransBkdTime() (f field.TransBkdTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecPriceType gets ExecPriceType, Tag 484 +func (m ExecutionReport) GetExecPriceType() (f field.ExecPriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecPriceAdjustment gets ExecPriceAdjustment, Tag 485 +func (m ExecutionReport) GetExecPriceAdjustment() (f field.ExecPriceAdjustmentField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDesignation gets Designation, Tag 494 +func (m ExecutionReport) GetDesignation() (f field.DesignationField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFundRenewWaiv gets FundRenewWaiv, Tag 497 +func (m ExecutionReport) GetFundRenewWaiv() (f field.FundRenewWaivField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRegistID gets RegistID, Tag 513 +func (m ExecutionReport) GetRegistID() (f field.RegistIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecValuationPoint gets ExecValuationPoint, Tag 515 +func (m ExecutionReport) GetExecValuationPoint() (f field.ExecValuationPointField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderPercent gets OrderPercent, Tag 516 +func (m ExecutionReport) GetOrderPercent() (f field.OrderPercentField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoContAmts gets NoContAmts, Tag 518 +func (m ExecutionReport) GetNoContAmts() (NoContAmtsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoContAmtsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetSecondaryClOrdID gets SecondaryClOrdID, Tag 526 +func (m ExecutionReport) GetSecondaryClOrdID() (f field.SecondaryClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecondaryExecID gets SecondaryExecID, Tag 527 +func (m ExecutionReport) GetSecondaryExecID() (f field.SecondaryExecIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderCapacity gets OrderCapacity, Tag 528 +func (m ExecutionReport) GetOrderCapacity() (f field.OrderCapacityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderRestrictions gets OrderRestrictions, Tag 529 +func (m ExecutionReport) GetOrderRestrictions() (f field.OrderRestrictionsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityDate gets MaturityDate, Tag 541 +func (m ExecutionReport) GetMaturityDate() (f field.MaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrRegistry gets InstrRegistry, Tag 543 +func (m ExecutionReport) GetInstrRegistry() (f field.InstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashMargin gets CashMargin, Tag 544 +func (m ExecutionReport) GetCashMargin() (f field.CashMarginField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCrossID gets CrossID, Tag 548 +func (m ExecutionReport) GetCrossID() (f field.CrossIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCrossType gets CrossType, Tag 549 +func (m ExecutionReport) GetCrossType() (f field.CrossTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrigCrossID gets OrigCrossID, Tag 551 +func (m ExecutionReport) GetOrigCrossID() (f field.OrigCrossIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoLegs gets NoLegs, Tag 555 +func (m ExecutionReport) GetNoLegs() (NoLegsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoLegsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetMatchType gets MatchType, Tag 574 +func (m ExecutionReport) GetMatchType() (f field.MatchTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAccountType gets AccountType, Tag 581 +func (m ExecutionReport) GetAccountType() (f field.AccountTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCustOrderCapacity gets CustOrderCapacity, Tag 582 +func (m ExecutionReport) GetCustOrderCapacity() (f field.CustOrderCapacityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdLinkID gets ClOrdLinkID, Tag 583 +func (m ExecutionReport) GetClOrdLinkID() (f field.ClOrdLinkIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMassStatusReqID gets MassStatusReqID, Tag 584 +func (m ExecutionReport) GetMassStatusReqID() (f field.MassStatusReqIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDayBookingInst gets DayBookingInst, Tag 589 +func (m ExecutionReport) GetDayBookingInst() (f field.DayBookingInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBookingUnit gets BookingUnit, Tag 590 +func (m ExecutionReport) GetBookingUnit() (f field.BookingUnitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPreallocMethod gets PreallocMethod, Tag 591 +func (m ExecutionReport) GetPreallocMethod() (f field.PreallocMethodField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradingSessionSubID gets TradingSessionSubID, Tag 625 +func (m ExecutionReport) GetTradingSessionSubID() (f field.TradingSessionSubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClearingFeeIndicator gets ClearingFeeIndicator, Tag 635 +func (m ExecutionReport) GetClearingFeeIndicator() (f field.ClearingFeeIndicatorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetWorkingIndicator gets WorkingIndicator, Tag 636 +func (m ExecutionReport) GetWorkingIndicator() (f field.WorkingIndicatorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPriorityIndicator gets PriorityIndicator, Tag 638 +func (m ExecutionReport) GetPriorityIndicator() (f field.PriorityIndicatorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPriceImprovement gets PriceImprovement, Tag 639 +func (m ExecutionReport) GetPriceImprovement() (f field.PriceImprovementField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastForwardPoints2 gets LastForwardPoints2, Tag 641 +func (m ExecutionReport) GetLastForwardPoints2() (f field.LastForwardPoints2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingLastPx gets UnderlyingLastPx, Tag 651 +func (m ExecutionReport) GetUnderlyingLastPx() (f field.UnderlyingLastPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingLastQty gets UnderlyingLastQty, Tag 652 +func (m ExecutionReport) GetUnderlyingLastQty() (f field.UnderlyingLastQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAcctIDSource gets AcctIDSource, Tag 660 +func (m ExecutionReport) GetAcctIDSource() (f field.AcctIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkPrice gets BenchmarkPrice, Tag 662 +func (m ExecutionReport) GetBenchmarkPrice() (f field.BenchmarkPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkPriceType gets BenchmarkPriceType, Tag 663 +func (m ExecutionReport) GetBenchmarkPriceType() (f field.BenchmarkPriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractSettlMonth gets ContractSettlMonth, Tag 667 +func (m ExecutionReport) GetContractSettlMonth() (f field.ContractSettlMonthField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastParPx gets LastParPx, Tag 669 +func (m ExecutionReport) GetLastParPx() (f field.LastParPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPool gets Pool, Tag 691 +func (m ExecutionReport) GetPool() (f field.PoolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetQuoteRespID gets QuoteRespID, Tag 693 +func (m ExecutionReport) GetQuoteRespID() (f field.QuoteRespIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYieldRedemptionDate gets YieldRedemptionDate, Tag 696 +func (m ExecutionReport) GetYieldRedemptionDate() (f field.YieldRedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYieldRedemptionPrice gets YieldRedemptionPrice, Tag 697 +func (m ExecutionReport) GetYieldRedemptionPrice() (f field.YieldRedemptionPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYieldRedemptionPriceType gets YieldRedemptionPriceType, Tag 698 +func (m ExecutionReport) GetYieldRedemptionPriceType() (f field.YieldRedemptionPriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkSecurityID gets BenchmarkSecurityID, Tag 699 +func (m ExecutionReport) GetBenchmarkSecurityID() (f field.BenchmarkSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYieldCalcDate gets YieldCalcDate, Tag 701 +func (m ExecutionReport) GetYieldCalcDate() (f field.YieldCalcDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyings gets NoUnderlyings, Tag 711 +func (m ExecutionReport) GetNoUnderlyings() (NoUnderlyingsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetInterestAtMaturity gets InterestAtMaturity, Tag 738 +func (m ExecutionReport) GetInterestAtMaturity() (f field.InterestAtMaturityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkSecurityIDSource gets BenchmarkSecurityIDSource, Tag 761 +func (m ExecutionReport) GetBenchmarkSecurityIDSource() (f field.BenchmarkSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecuritySubType gets SecuritySubType, Tag 762 +func (m ExecutionReport) GetSecuritySubType() (f field.SecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoTrdRegTimestamps gets NoTrdRegTimestamps, Tag 768 +func (m ExecutionReport) GetNoTrdRegTimestamps() (NoTrdRegTimestampsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoTrdRegTimestampsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetBookingType gets BookingType, Tag 775 +func (m ExecutionReport) GetBookingType() (f field.BookingTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTerminationType gets TerminationType, Tag 788 +func (m ExecutionReport) GetTerminationType() (f field.TerminationTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdStatusReqID gets OrdStatusReqID, Tag 790 +func (m ExecutionReport) GetOrdStatusReqID() (f field.OrdStatusReqIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCopyMsgIndicator gets CopyMsgIndicator, Tag 797 +func (m ExecutionReport) GetCopyMsgIndicator() (f field.CopyMsgIndicatorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegMoveType gets PegMoveType, Tag 835 +func (m ExecutionReport) GetPegMoveType() (f field.PegMoveTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegOffsetType gets PegOffsetType, Tag 836 +func (m ExecutionReport) GetPegOffsetType() (f field.PegOffsetTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegLimitType gets PegLimitType, Tag 837 +func (m ExecutionReport) GetPegLimitType() (f field.PegLimitTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegRoundDirection gets PegRoundDirection, Tag 838 +func (m ExecutionReport) GetPegRoundDirection() (f field.PegRoundDirectionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPeggedPrice gets PeggedPrice, Tag 839 +func (m ExecutionReport) GetPeggedPrice() (f field.PeggedPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegScope gets PegScope, Tag 840 +func (m ExecutionReport) GetPegScope() (f field.PegScopeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionMoveType gets DiscretionMoveType, Tag 841 +func (m ExecutionReport) GetDiscretionMoveType() (f field.DiscretionMoveTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionOffsetType gets DiscretionOffsetType, Tag 842 +func (m ExecutionReport) GetDiscretionOffsetType() (f field.DiscretionOffsetTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionLimitType gets DiscretionLimitType, Tag 843 +func (m ExecutionReport) GetDiscretionLimitType() (f field.DiscretionLimitTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionRoundDirection gets DiscretionRoundDirection, Tag 844 +func (m ExecutionReport) GetDiscretionRoundDirection() (f field.DiscretionRoundDirectionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionPrice gets DiscretionPrice, Tag 845 +func (m ExecutionReport) GetDiscretionPrice() (f field.DiscretionPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionScope gets DiscretionScope, Tag 846 +func (m ExecutionReport) GetDiscretionScope() (f field.DiscretionScopeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTargetStrategy gets TargetStrategy, Tag 847 +func (m ExecutionReport) GetTargetStrategy() (f field.TargetStrategyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTargetStrategyParameters gets TargetStrategyParameters, Tag 848 +func (m ExecutionReport) GetTargetStrategyParameters() (f field.TargetStrategyParametersField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetParticipationRate gets ParticipationRate, Tag 849 +func (m ExecutionReport) GetParticipationRate() (f field.ParticipationRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTargetStrategyPerformance gets TargetStrategyPerformance, Tag 850 +func (m ExecutionReport) GetTargetStrategyPerformance() (f field.TargetStrategyPerformanceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastLiquidityInd gets LastLiquidityInd, Tag 851 +func (m ExecutionReport) GetLastLiquidityInd() (f field.LastLiquidityIndField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetQtyType gets QtyType, Tag 854 +func (m ExecutionReport) GetQtyType() (f field.QtyTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoEvents gets NoEvents, Tag 864 +func (m ExecutionReport) GetNoEvents() (NoEventsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoEventsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetDatedDate gets DatedDate, Tag 873 +func (m ExecutionReport) GetDatedDate() (f field.DatedDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInterestAccrualDate gets InterestAccrualDate, Tag 874 +func (m ExecutionReport) GetInterestAccrualDate() (f field.InterestAccrualDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCPProgram gets CPProgram, Tag 875 +func (m ExecutionReport) GetCPProgram() (f field.CPProgramField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCPRegType gets CPRegType, Tag 876 +func (m ExecutionReport) GetCPRegType() (f field.CPRegTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMarginRatio gets MarginRatio, Tag 898 +func (m ExecutionReport) GetMarginRatio() (f field.MarginRatioField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTotNumReports gets TotNumReports, Tag 911 +func (m ExecutionReport) GetTotNumReports() (f field.TotNumReportsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastRptRequested gets LastRptRequested, Tag 912 +func (m ExecutionReport) GetLastRptRequested() (f field.LastRptRequestedField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementDesc gets AgreementDesc, Tag 913 +func (m ExecutionReport) GetAgreementDesc() (f field.AgreementDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementID gets AgreementID, Tag 914 +func (m ExecutionReport) GetAgreementID() (f field.AgreementIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementDate gets AgreementDate, Tag 915 +func (m ExecutionReport) GetAgreementDate() (f field.AgreementDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStartDate gets StartDate, Tag 916 +func (m ExecutionReport) GetStartDate() (f field.StartDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEndDate gets EndDate, Tag 917 +func (m ExecutionReport) GetEndDate() (f field.EndDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementCurrency gets AgreementCurrency, Tag 918 +func (m ExecutionReport) GetAgreementCurrency() (f field.AgreementCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDeliveryType gets DeliveryType, Tag 919 +func (m ExecutionReport) GetDeliveryType() (f field.DeliveryTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEndAccruedInterestAmt gets EndAccruedInterestAmt, Tag 920 +func (m ExecutionReport) GetEndAccruedInterestAmt() (f field.EndAccruedInterestAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStartCash gets StartCash, Tag 921 +func (m ExecutionReport) GetStartCash() (f field.StartCashField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEndCash gets EndCash, Tag 922 +func (m ExecutionReport) GetEndCash() (f field.EndCashField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTimeBracket gets TimeBracket, Tag 943 +func (m ExecutionReport) GetTimeBracket() (f field.TimeBracketField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikeCurrency gets StrikeCurrency, Tag 947 +func (m ExecutionReport) GetStrikeCurrency() (f field.StrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoStrategyParameters gets NoStrategyParameters, Tag 957 +func (m ExecutionReport) GetNoStrategyParameters() (NoStrategyParametersRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoStrategyParametersRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetHostCrossID gets HostCrossID, Tag 961 +func (m ExecutionReport) GetHostCrossID() (f field.HostCrossIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityStatus gets SecurityStatus, Tag 965 +func (m ExecutionReport) GetSecurityStatus() (f field.SecurityStatusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettleOnOpenFlag gets SettleOnOpenFlag, Tag 966 +func (m ExecutionReport) GetSettleOnOpenFlag() (f field.SettleOnOpenFlagField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikeMultiplier gets StrikeMultiplier, Tag 967 +func (m ExecutionReport) GetStrikeMultiplier() (f field.StrikeMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikeValue gets StrikeValue, Tag 968 +func (m ExecutionReport) GetStrikeValue() (f field.StrikeValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMinPriceIncrement gets MinPriceIncrement, Tag 969 +func (m ExecutionReport) GetMinPriceIncrement() (f field.MinPriceIncrementField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPositionLimit gets PositionLimit, Tag 970 +func (m ExecutionReport) GetPositionLimit() (f field.PositionLimitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNTPositionLimit gets NTPositionLimit, Tag 971 +func (m ExecutionReport) GetNTPositionLimit() (f field.NTPositionLimitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnitOfMeasure gets UnitOfMeasure, Tag 996 +func (m ExecutionReport) GetUnitOfMeasure() (f field.UnitOfMeasureField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTimeUnit gets TimeUnit, Tag 997 +func (m ExecutionReport) GetTimeUnit() (f field.TimeUnitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoInstrumentParties gets NoInstrumentParties, Tag 1018 +func (m ExecutionReport) GetNoInstrumentParties() (NoInstrumentPartiesRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoInstrumentPartiesRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetManualOrderIndicator gets ManualOrderIndicator, Tag 1028 +func (m ExecutionReport) GetManualOrderIndicator() (f field.ManualOrderIndicatorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCustDirectedOrder gets CustDirectedOrder, Tag 1029 +func (m ExecutionReport) GetCustDirectedOrder() (f field.CustDirectedOrderField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetReceivedDeptID gets ReceivedDeptID, Tag 1030 +func (m ExecutionReport) GetReceivedDeptID() (f field.ReceivedDeptIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCustOrderHandlingInst gets CustOrderHandlingInst, Tag 1031 +func (m ExecutionReport) GetCustOrderHandlingInst() (f field.CustOrderHandlingInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderHandlingInstSource gets OrderHandlingInstSource, Tag 1032 +func (m ExecutionReport) GetOrderHandlingInstSource() (f field.OrderHandlingInstSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrmtAssignmentMethod gets InstrmtAssignmentMethod, Tag 1049 +func (m ExecutionReport) GetInstrmtAssignmentMethod() (f field.InstrmtAssignmentMethodField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCalculatedCcyLastQty gets CalculatedCcyLastQty, Tag 1056 +func (m ExecutionReport) GetCalculatedCcyLastQty() (f field.CalculatedCcyLastQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAggressorIndicator gets AggressorIndicator, Tag 1057 +func (m ExecutionReport) GetAggressorIndicator() (f field.AggressorIndicatorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLastSwapPoints gets LastSwapPoints, Tag 1071 +func (m ExecutionReport) GetLastSwapPoints() (f field.LastSwapPointsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityTime gets MaturityTime, Tag 1079 +func (m ExecutionReport) GetMaturityTime() (f field.MaturityTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecondaryDisplayQty gets SecondaryDisplayQty, Tag 1082 +func (m ExecutionReport) GetSecondaryDisplayQty() (f field.SecondaryDisplayQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDisplayWhen gets DisplayWhen, Tag 1083 +func (m ExecutionReport) GetDisplayWhen() (f field.DisplayWhenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDisplayMethod gets DisplayMethod, Tag 1084 +func (m ExecutionReport) GetDisplayMethod() (f field.DisplayMethodField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDisplayLowQty gets DisplayLowQty, Tag 1085 +func (m ExecutionReport) GetDisplayLowQty() (f field.DisplayLowQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDisplayHighQty gets DisplayHighQty, Tag 1086 +func (m ExecutionReport) GetDisplayHighQty() (f field.DisplayHighQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDisplayMinIncr gets DisplayMinIncr, Tag 1087 +func (m ExecutionReport) GetDisplayMinIncr() (f field.DisplayMinIncrField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRefreshQty gets RefreshQty, Tag 1088 +func (m ExecutionReport) GetRefreshQty() (f field.RefreshQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMatchIncrement gets MatchIncrement, Tag 1089 +func (m ExecutionReport) GetMatchIncrement() (f field.MatchIncrementField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxPriceLevels gets MaxPriceLevels, Tag 1090 +func (m ExecutionReport) GetMaxPriceLevels() (f field.MaxPriceLevelsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPreTradeAnonymity gets PreTradeAnonymity, Tag 1091 +func (m ExecutionReport) GetPreTradeAnonymity() (f field.PreTradeAnonymityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPriceProtectionScope gets PriceProtectionScope, Tag 1092 +func (m ExecutionReport) GetPriceProtectionScope() (f field.PriceProtectionScopeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLotType gets LotType, Tag 1093 +func (m ExecutionReport) GetLotType() (f field.LotTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegPriceType gets PegPriceType, Tag 1094 +func (m ExecutionReport) GetPegPriceType() (f field.PegPriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPeggedRefPrice gets PeggedRefPrice, Tag 1095 +func (m ExecutionReport) GetPeggedRefPrice() (f field.PeggedRefPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegSecurityIDSource gets PegSecurityIDSource, Tag 1096 +func (m ExecutionReport) GetPegSecurityIDSource() (f field.PegSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegSecurityID gets PegSecurityID, Tag 1097 +func (m ExecutionReport) GetPegSecurityID() (f field.PegSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegSymbol gets PegSymbol, Tag 1098 +func (m ExecutionReport) GetPegSymbol() (f field.PegSymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegSecurityDesc gets PegSecurityDesc, Tag 1099 +func (m ExecutionReport) GetPegSecurityDesc() (f field.PegSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerType gets TriggerType, Tag 1100 +func (m ExecutionReport) GetTriggerType() (f field.TriggerTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerAction gets TriggerAction, Tag 1101 +func (m ExecutionReport) GetTriggerAction() (f field.TriggerActionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerPrice gets TriggerPrice, Tag 1102 +func (m ExecutionReport) GetTriggerPrice() (f field.TriggerPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerSymbol gets TriggerSymbol, Tag 1103 +func (m ExecutionReport) GetTriggerSymbol() (f field.TriggerSymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerSecurityID gets TriggerSecurityID, Tag 1104 +func (m ExecutionReport) GetTriggerSecurityID() (f field.TriggerSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerSecurityIDSource gets TriggerSecurityIDSource, Tag 1105 +func (m ExecutionReport) GetTriggerSecurityIDSource() (f field.TriggerSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerSecurityDesc gets TriggerSecurityDesc, Tag 1106 +func (m ExecutionReport) GetTriggerSecurityDesc() (f field.TriggerSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerPriceType gets TriggerPriceType, Tag 1107 +func (m ExecutionReport) GetTriggerPriceType() (f field.TriggerPriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerPriceTypeScope gets TriggerPriceTypeScope, Tag 1108 +func (m ExecutionReport) GetTriggerPriceTypeScope() (f field.TriggerPriceTypeScopeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerPriceDirection gets TriggerPriceDirection, Tag 1109 +func (m ExecutionReport) GetTriggerPriceDirection() (f field.TriggerPriceDirectionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerNewPrice gets TriggerNewPrice, Tag 1110 +func (m ExecutionReport) GetTriggerNewPrice() (f field.TriggerNewPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerOrderType gets TriggerOrderType, Tag 1111 +func (m ExecutionReport) GetTriggerOrderType() (f field.TriggerOrderTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerNewQty gets TriggerNewQty, Tag 1112 +func (m ExecutionReport) GetTriggerNewQty() (f field.TriggerNewQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerTradingSessionID gets TriggerTradingSessionID, Tag 1113 +func (m ExecutionReport) GetTriggerTradingSessionID() (f field.TriggerTradingSessionIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerTradingSessionSubID gets TriggerTradingSessionSubID, Tag 1114 +func (m ExecutionReport) GetTriggerTradingSessionSubID() (f field.TriggerTradingSessionSubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderCategory gets OrderCategory, Tag 1115 +func (m ExecutionReport) GetOrderCategory() (f field.OrderCategoryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDisplayQty gets DisplayQty, Tag 1138 +func (m ExecutionReport) GetDisplayQty() (f field.DisplayQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasAccount returns true if Account is present, Tag 1 +func (m ExecutionReport) HasAccount() bool { + return m.Has(tag.Account) +} + +//HasAvgPx returns true if AvgPx is present, Tag 6 +func (m ExecutionReport) HasAvgPx() bool { + return m.Has(tag.AvgPx) +} + +//HasClOrdID returns true if ClOrdID is present, Tag 11 +func (m ExecutionReport) HasClOrdID() bool { + return m.Has(tag.ClOrdID) +} + +//HasCommission returns true if Commission is present, Tag 12 +func (m ExecutionReport) HasCommission() bool { + return m.Has(tag.Commission) +} + +//HasCommType returns true if CommType is present, Tag 13 +func (m ExecutionReport) HasCommType() bool { + return m.Has(tag.CommType) +} + +//HasCumQty returns true if CumQty is present, Tag 14 +func (m ExecutionReport) HasCumQty() bool { + return m.Has(tag.CumQty) +} + +//HasCurrency returns true if Currency is present, Tag 15 +func (m ExecutionReport) HasCurrency() bool { + return m.Has(tag.Currency) +} + +//HasExecID returns true if ExecID is present, Tag 17 +func (m ExecutionReport) HasExecID() bool { + return m.Has(tag.ExecID) +} + +//HasExecInst returns true if ExecInst is present, Tag 18 +func (m ExecutionReport) HasExecInst() bool { + return m.Has(tag.ExecInst) +} + +//HasExecRefID returns true if ExecRefID is present, Tag 19 +func (m ExecutionReport) HasExecRefID() bool { + return m.Has(tag.ExecRefID) +} + +//HasHandlInst returns true if HandlInst is present, Tag 21 +func (m ExecutionReport) HasHandlInst() bool { + return m.Has(tag.HandlInst) +} + +//HasSecurityIDSource returns true if SecurityIDSource is present, Tag 22 +func (m ExecutionReport) HasSecurityIDSource() bool { + return m.Has(tag.SecurityIDSource) +} + +//HasLastCapacity returns true if LastCapacity is present, Tag 29 +func (m ExecutionReport) HasLastCapacity() bool { + return m.Has(tag.LastCapacity) +} + +//HasLastMkt returns true if LastMkt is present, Tag 30 +func (m ExecutionReport) HasLastMkt() bool { + return m.Has(tag.LastMkt) +} + +//HasLastPx returns true if LastPx is present, Tag 31 +func (m ExecutionReport) HasLastPx() bool { + return m.Has(tag.LastPx) +} + +//HasLastQty returns true if LastQty is present, Tag 32 +func (m ExecutionReport) HasLastQty() bool { + return m.Has(tag.LastQty) +} + +//HasOrderID returns true if OrderID is present, Tag 37 +func (m ExecutionReport) HasOrderID() bool { + return m.Has(tag.OrderID) +} + +//HasOrderQty returns true if OrderQty is present, Tag 38 +func (m ExecutionReport) HasOrderQty() bool { + return m.Has(tag.OrderQty) +} + +//HasOrdStatus returns true if OrdStatus is present, Tag 39 +func (m ExecutionReport) HasOrdStatus() bool { + return m.Has(tag.OrdStatus) +} + +//HasOrdType returns true if OrdType is present, Tag 40 +func (m ExecutionReport) HasOrdType() bool { + return m.Has(tag.OrdType) +} + +//HasOrigClOrdID returns true if OrigClOrdID is present, Tag 41 +func (m ExecutionReport) HasOrigClOrdID() bool { + return m.Has(tag.OrigClOrdID) +} + +//HasPrice returns true if Price is present, Tag 44 +func (m ExecutionReport) HasPrice() bool { + return m.Has(tag.Price) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m ExecutionReport) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSide returns true if Side is present, Tag 54 +func (m ExecutionReport) HasSide() bool { + return m.Has(tag.Side) +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m ExecutionReport) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasText returns true if Text is present, Tag 58 +func (m ExecutionReport) HasText() bool { + return m.Has(tag.Text) +} + +//HasTimeInForce returns true if TimeInForce is present, Tag 59 +func (m ExecutionReport) HasTimeInForce() bool { + return m.Has(tag.TimeInForce) +} + +//HasTransactTime returns true if TransactTime is present, Tag 60 +func (m ExecutionReport) HasTransactTime() bool { + return m.Has(tag.TransactTime) +} + +//HasSettlType returns true if SettlType is present, Tag 63 +func (m ExecutionReport) HasSettlType() bool { + return m.Has(tag.SettlType) +} + +//HasSettlDate returns true if SettlDate is present, Tag 64 +func (m ExecutionReport) HasSettlDate() bool { + return m.Has(tag.SettlDate) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m ExecutionReport) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasListID returns true if ListID is present, Tag 66 +func (m ExecutionReport) HasListID() bool { + return m.Has(tag.ListID) +} + +//HasTradeDate returns true if TradeDate is present, Tag 75 +func (m ExecutionReport) HasTradeDate() bool { + return m.Has(tag.TradeDate) +} + +//HasPositionEffect returns true if PositionEffect is present, Tag 77 +func (m ExecutionReport) HasPositionEffect() bool { + return m.Has(tag.PositionEffect) +} + +//HasStopPx returns true if StopPx is present, Tag 99 +func (m ExecutionReport) HasStopPx() bool { + return m.Has(tag.StopPx) +} + +//HasOrdRejReason returns true if OrdRejReason is present, Tag 103 +func (m ExecutionReport) HasOrdRejReason() bool { + return m.Has(tag.OrdRejReason) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m ExecutionReport) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m ExecutionReport) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasMinQty returns true if MinQty is present, Tag 110 +func (m ExecutionReport) HasMinQty() bool { + return m.Has(tag.MinQty) +} + +//HasMaxFloor returns true if MaxFloor is present, Tag 111 +func (m ExecutionReport) HasMaxFloor() bool { + return m.Has(tag.MaxFloor) +} + +//HasReportToExch returns true if ReportToExch is present, Tag 113 +func (m ExecutionReport) HasReportToExch() bool { + return m.Has(tag.ReportToExch) +} + +//HasNetMoney returns true if NetMoney is present, Tag 118 +func (m ExecutionReport) HasNetMoney() bool { + return m.Has(tag.NetMoney) +} + +//HasSettlCurrAmt returns true if SettlCurrAmt is present, Tag 119 +func (m ExecutionReport) HasSettlCurrAmt() bool { + return m.Has(tag.SettlCurrAmt) +} + +//HasSettlCurrency returns true if SettlCurrency is present, Tag 120 +func (m ExecutionReport) HasSettlCurrency() bool { + return m.Has(tag.SettlCurrency) +} + +//HasExpireTime returns true if ExpireTime is present, Tag 126 +func (m ExecutionReport) HasExpireTime() bool { + return m.Has(tag.ExpireTime) +} + +//HasNoMiscFees returns true if NoMiscFees is present, Tag 136 +func (m ExecutionReport) HasNoMiscFees() bool { + return m.Has(tag.NoMiscFees) +} + +//HasExecType returns true if ExecType is present, Tag 150 +func (m ExecutionReport) HasExecType() bool { + return m.Has(tag.ExecType) +} + +//HasLeavesQty returns true if LeavesQty is present, Tag 151 +func (m ExecutionReport) HasLeavesQty() bool { + return m.Has(tag.LeavesQty) +} + +//HasCashOrderQty returns true if CashOrderQty is present, Tag 152 +func (m ExecutionReport) HasCashOrderQty() bool { + return m.Has(tag.CashOrderQty) +} + +//HasSettlCurrFxRate returns true if SettlCurrFxRate is present, Tag 155 +func (m ExecutionReport) HasSettlCurrFxRate() bool { + return m.Has(tag.SettlCurrFxRate) +} + +//HasSettlCurrFxRateCalc returns true if SettlCurrFxRateCalc is present, Tag 156 +func (m ExecutionReport) HasSettlCurrFxRateCalc() bool { + return m.Has(tag.SettlCurrFxRateCalc) +} + +//HasNumDaysInterest returns true if NumDaysInterest is present, Tag 157 +func (m ExecutionReport) HasNumDaysInterest() bool { + return m.Has(tag.NumDaysInterest) +} + +//HasAccruedInterestRate returns true if AccruedInterestRate is present, Tag 158 +func (m ExecutionReport) HasAccruedInterestRate() bool { + return m.Has(tag.AccruedInterestRate) +} + +//HasAccruedInterestAmt returns true if AccruedInterestAmt is present, Tag 159 +func (m ExecutionReport) HasAccruedInterestAmt() bool { + return m.Has(tag.AccruedInterestAmt) +} + +//HasSecurityType returns true if SecurityType is present, Tag 167 +func (m ExecutionReport) HasSecurityType() bool { + return m.Has(tag.SecurityType) +} + +//HasEffectiveTime returns true if EffectiveTime is present, Tag 168 +func (m ExecutionReport) HasEffectiveTime() bool { + return m.Has(tag.EffectiveTime) +} + +//HasOrderQty2 returns true if OrderQty2 is present, Tag 192 +func (m ExecutionReport) HasOrderQty2() bool { + return m.Has(tag.OrderQty2) +} + +//HasSettlDate2 returns true if SettlDate2 is present, Tag 193 +func (m ExecutionReport) HasSettlDate2() bool { + return m.Has(tag.SettlDate2) +} + +//HasLastSpotRate returns true if LastSpotRate is present, Tag 194 +func (m ExecutionReport) HasLastSpotRate() bool { + return m.Has(tag.LastSpotRate) +} + +//HasLastForwardPoints returns true if LastForwardPoints is present, Tag 195 +func (m ExecutionReport) HasLastForwardPoints() bool { + return m.Has(tag.LastForwardPoints) +} + +//HasSecondaryOrderID returns true if SecondaryOrderID is present, Tag 198 +func (m ExecutionReport) HasSecondaryOrderID() bool { + return m.Has(tag.SecondaryOrderID) +} + +//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200 +func (m ExecutionReport) HasMaturityMonthYear() bool { + return m.Has(tag.MaturityMonthYear) +} + +//HasStrikePrice returns true if StrikePrice is present, Tag 202 +func (m ExecutionReport) HasStrikePrice() bool { + return m.Has(tag.StrikePrice) +} + +//HasOptAttribute returns true if OptAttribute is present, Tag 206 +func (m ExecutionReport) HasOptAttribute() bool { + return m.Has(tag.OptAttribute) +} + +//HasSecurityExchange returns true if SecurityExchange is present, Tag 207 +func (m ExecutionReport) HasSecurityExchange() bool { + return m.Has(tag.SecurityExchange) +} + +//HasMaxShow returns true if MaxShow is present, Tag 210 +func (m ExecutionReport) HasMaxShow() bool { + return m.Has(tag.MaxShow) +} + +//HasPegOffsetValue returns true if PegOffsetValue is present, Tag 211 +func (m ExecutionReport) HasPegOffsetValue() bool { + return m.Has(tag.PegOffsetValue) +} + +//HasSpread returns true if Spread is present, Tag 218 +func (m ExecutionReport) HasSpread() bool { + return m.Has(tag.Spread) +} + +//HasBenchmarkCurveCurrency returns true if BenchmarkCurveCurrency is present, Tag 220 +func (m ExecutionReport) HasBenchmarkCurveCurrency() bool { + return m.Has(tag.BenchmarkCurveCurrency) +} + +//HasBenchmarkCurveName returns true if BenchmarkCurveName is present, Tag 221 +func (m ExecutionReport) HasBenchmarkCurveName() bool { + return m.Has(tag.BenchmarkCurveName) +} + +//HasBenchmarkCurvePoint returns true if BenchmarkCurvePoint is present, Tag 222 +func (m ExecutionReport) HasBenchmarkCurvePoint() bool { + return m.Has(tag.BenchmarkCurvePoint) +} + +//HasCouponRate returns true if CouponRate is present, Tag 223 +func (m ExecutionReport) HasCouponRate() bool { + return m.Has(tag.CouponRate) +} + +//HasCouponPaymentDate returns true if CouponPaymentDate is present, Tag 224 +func (m ExecutionReport) HasCouponPaymentDate() bool { + return m.Has(tag.CouponPaymentDate) +} + +//HasIssueDate returns true if IssueDate is present, Tag 225 +func (m ExecutionReport) HasIssueDate() bool { + return m.Has(tag.IssueDate) +} + +//HasRepurchaseTerm returns true if RepurchaseTerm is present, Tag 226 +func (m ExecutionReport) HasRepurchaseTerm() bool { + return m.Has(tag.RepurchaseTerm) +} + +//HasRepurchaseRate returns true if RepurchaseRate is present, Tag 227 +func (m ExecutionReport) HasRepurchaseRate() bool { + return m.Has(tag.RepurchaseRate) +} + +//HasFactor returns true if Factor is present, Tag 228 +func (m ExecutionReport) HasFactor() bool { + return m.Has(tag.Factor) +} + +//HasTradeOriginationDate returns true if TradeOriginationDate is present, Tag 229 +func (m ExecutionReport) HasTradeOriginationDate() bool { + return m.Has(tag.TradeOriginationDate) +} + +//HasExDate returns true if ExDate is present, Tag 230 +func (m ExecutionReport) HasExDate() bool { + return m.Has(tag.ExDate) +} + +//HasContractMultiplier returns true if ContractMultiplier is present, Tag 231 +func (m ExecutionReport) HasContractMultiplier() bool { + return m.Has(tag.ContractMultiplier) +} + +//HasNoStipulations returns true if NoStipulations is present, Tag 232 +func (m ExecutionReport) HasNoStipulations() bool { + return m.Has(tag.NoStipulations) +} + +//HasYieldType returns true if YieldType is present, Tag 235 +func (m ExecutionReport) HasYieldType() bool { + return m.Has(tag.YieldType) +} + +//HasYield returns true if Yield is present, Tag 236 +func (m ExecutionReport) HasYield() bool { + return m.Has(tag.Yield) +} + +//HasTotalTakedown returns true if TotalTakedown is present, Tag 237 +func (m ExecutionReport) HasTotalTakedown() bool { + return m.Has(tag.TotalTakedown) +} + +//HasConcession returns true if Concession is present, Tag 238 +func (m ExecutionReport) HasConcession() bool { + return m.Has(tag.Concession) +} + +//HasRepoCollateralSecurityType returns true if RepoCollateralSecurityType is present, Tag 239 +func (m ExecutionReport) HasRepoCollateralSecurityType() bool { + return m.Has(tag.RepoCollateralSecurityType) +} + +//HasRedemptionDate returns true if RedemptionDate is present, Tag 240 +func (m ExecutionReport) HasRedemptionDate() bool { + return m.Has(tag.RedemptionDate) +} + +//HasCreditRating returns true if CreditRating is present, Tag 255 +func (m ExecutionReport) HasCreditRating() bool { + return m.Has(tag.CreditRating) +} + +//HasTradedFlatSwitch returns true if TradedFlatSwitch is present, Tag 258 +func (m ExecutionReport) HasTradedFlatSwitch() bool { + return m.Has(tag.TradedFlatSwitch) +} + +//HasBasisFeatureDate returns true if BasisFeatureDate is present, Tag 259 +func (m ExecutionReport) HasBasisFeatureDate() bool { + return m.Has(tag.BasisFeatureDate) +} + +//HasBasisFeaturePrice returns true if BasisFeaturePrice is present, Tag 260 +func (m ExecutionReport) HasBasisFeaturePrice() bool { + return m.Has(tag.BasisFeaturePrice) +} + +//HasTradingSessionID returns true if TradingSessionID is present, Tag 336 +func (m ExecutionReport) HasTradingSessionID() bool { + return m.Has(tag.TradingSessionID) +} + +//HasEncodedIssuerLen returns true if EncodedIssuerLen is present, Tag 348 +func (m ExecutionReport) HasEncodedIssuerLen() bool { + return m.Has(tag.EncodedIssuerLen) +} + +//HasEncodedIssuer returns true if EncodedIssuer is present, Tag 349 +func (m ExecutionReport) HasEncodedIssuer() bool { + return m.Has(tag.EncodedIssuer) +} + +//HasEncodedSecurityDescLen returns true if EncodedSecurityDescLen is present, Tag 350 +func (m ExecutionReport) HasEncodedSecurityDescLen() bool { + return m.Has(tag.EncodedSecurityDescLen) +} + +//HasEncodedSecurityDesc returns true if EncodedSecurityDesc is present, Tag 351 +func (m ExecutionReport) HasEncodedSecurityDesc() bool { + return m.Has(tag.EncodedSecurityDesc) +} + +//HasEncodedTextLen returns true if EncodedTextLen is present, Tag 354 +func (m ExecutionReport) HasEncodedTextLen() bool { + return m.Has(tag.EncodedTextLen) +} + +//HasEncodedText returns true if EncodedText is present, Tag 355 +func (m ExecutionReport) HasEncodedText() bool { + return m.Has(tag.EncodedText) +} + +//HasComplianceID returns true if ComplianceID is present, Tag 376 +func (m ExecutionReport) HasComplianceID() bool { + return m.Has(tag.ComplianceID) +} + +//HasSolicitedFlag returns true if SolicitedFlag is present, Tag 377 +func (m ExecutionReport) HasSolicitedFlag() bool { + return m.Has(tag.SolicitedFlag) +} + +//HasExecRestatementReason returns true if ExecRestatementReason is present, Tag 378 +func (m ExecutionReport) HasExecRestatementReason() bool { + return m.Has(tag.ExecRestatementReason) +} + +//HasGrossTradeAmt returns true if GrossTradeAmt is present, Tag 381 +func (m ExecutionReport) HasGrossTradeAmt() bool { + return m.Has(tag.GrossTradeAmt) +} + +//HasNoContraBrokers returns true if NoContraBrokers is present, Tag 382 +func (m ExecutionReport) HasNoContraBrokers() bool { + return m.Has(tag.NoContraBrokers) +} + +//HasDiscretionInst returns true if DiscretionInst is present, Tag 388 +func (m ExecutionReport) HasDiscretionInst() bool { + return m.Has(tag.DiscretionInst) +} + +//HasDiscretionOffsetValue returns true if DiscretionOffsetValue is present, Tag 389 +func (m ExecutionReport) HasDiscretionOffsetValue() bool { + return m.Has(tag.DiscretionOffsetValue) +} + +//HasPriceType returns true if PriceType is present, Tag 423 +func (m ExecutionReport) HasPriceType() bool { + return m.Has(tag.PriceType) +} + +//HasDayOrderQty returns true if DayOrderQty is present, Tag 424 +func (m ExecutionReport) HasDayOrderQty() bool { + return m.Has(tag.DayOrderQty) +} + +//HasDayCumQty returns true if DayCumQty is present, Tag 425 +func (m ExecutionReport) HasDayCumQty() bool { + return m.Has(tag.DayCumQty) +} + +//HasDayAvgPx returns true if DayAvgPx is present, Tag 426 +func (m ExecutionReport) HasDayAvgPx() bool { + return m.Has(tag.DayAvgPx) +} + +//HasGTBookingInst returns true if GTBookingInst is present, Tag 427 +func (m ExecutionReport) HasGTBookingInst() bool { + return m.Has(tag.GTBookingInst) +} + +//HasExpireDate returns true if ExpireDate is present, Tag 432 +func (m ExecutionReport) HasExpireDate() bool { + return m.Has(tag.ExpireDate) +} + +//HasMultiLegReportingType returns true if MultiLegReportingType is present, Tag 442 +func (m ExecutionReport) HasMultiLegReportingType() bool { + return m.Has(tag.MultiLegReportingType) +} + +//HasNoPartyIDs returns true if NoPartyIDs is present, Tag 453 +func (m ExecutionReport) HasNoPartyIDs() bool { + return m.Has(tag.NoPartyIDs) +} + +//HasNoSecurityAltID returns true if NoSecurityAltID is present, Tag 454 +func (m ExecutionReport) HasNoSecurityAltID() bool { + return m.Has(tag.NoSecurityAltID) +} + +//HasProduct returns true if Product is present, Tag 460 +func (m ExecutionReport) HasProduct() bool { + return m.Has(tag.Product) +} + +//HasCFICode returns true if CFICode is present, Tag 461 +func (m ExecutionReport) HasCFICode() bool { + return m.Has(tag.CFICode) +} + +//HasRoundingDirection returns true if RoundingDirection is present, Tag 468 +func (m ExecutionReport) HasRoundingDirection() bool { + return m.Has(tag.RoundingDirection) +} + +//HasRoundingModulus returns true if RoundingModulus is present, Tag 469 +func (m ExecutionReport) HasRoundingModulus() bool { + return m.Has(tag.RoundingModulus) +} + +//HasCountryOfIssue returns true if CountryOfIssue is present, Tag 470 +func (m ExecutionReport) HasCountryOfIssue() bool { + return m.Has(tag.CountryOfIssue) +} + +//HasStateOrProvinceOfIssue returns true if StateOrProvinceOfIssue is present, Tag 471 +func (m ExecutionReport) HasStateOrProvinceOfIssue() bool { + return m.Has(tag.StateOrProvinceOfIssue) +} + +//HasLocaleOfIssue returns true if LocaleOfIssue is present, Tag 472 +func (m ExecutionReport) HasLocaleOfIssue() bool { + return m.Has(tag.LocaleOfIssue) +} + +//HasCommCurrency returns true if CommCurrency is present, Tag 479 +func (m ExecutionReport) HasCommCurrency() bool { + return m.Has(tag.CommCurrency) +} + +//HasCancellationRights returns true if CancellationRights is present, Tag 480 +func (m ExecutionReport) HasCancellationRights() bool { + return m.Has(tag.CancellationRights) +} + +//HasMoneyLaunderingStatus returns true if MoneyLaunderingStatus is present, Tag 481 +func (m ExecutionReport) HasMoneyLaunderingStatus() bool { + return m.Has(tag.MoneyLaunderingStatus) +} + +//HasTransBkdTime returns true if TransBkdTime is present, Tag 483 +func (m ExecutionReport) HasTransBkdTime() bool { + return m.Has(tag.TransBkdTime) +} + +//HasExecPriceType returns true if ExecPriceType is present, Tag 484 +func (m ExecutionReport) HasExecPriceType() bool { + return m.Has(tag.ExecPriceType) +} + +//HasExecPriceAdjustment returns true if ExecPriceAdjustment is present, Tag 485 +func (m ExecutionReport) HasExecPriceAdjustment() bool { + return m.Has(tag.ExecPriceAdjustment) +} + +//HasDesignation returns true if Designation is present, Tag 494 +func (m ExecutionReport) HasDesignation() bool { + return m.Has(tag.Designation) +} + +//HasFundRenewWaiv returns true if FundRenewWaiv is present, Tag 497 +func (m ExecutionReport) HasFundRenewWaiv() bool { + return m.Has(tag.FundRenewWaiv) +} + +//HasRegistID returns true if RegistID is present, Tag 513 +func (m ExecutionReport) HasRegistID() bool { + return m.Has(tag.RegistID) +} + +//HasExecValuationPoint returns true if ExecValuationPoint is present, Tag 515 +func (m ExecutionReport) HasExecValuationPoint() bool { + return m.Has(tag.ExecValuationPoint) +} + +//HasOrderPercent returns true if OrderPercent is present, Tag 516 +func (m ExecutionReport) HasOrderPercent() bool { + return m.Has(tag.OrderPercent) +} + +//HasNoContAmts returns true if NoContAmts is present, Tag 518 +func (m ExecutionReport) HasNoContAmts() bool { + return m.Has(tag.NoContAmts) +} + +//HasSecondaryClOrdID returns true if SecondaryClOrdID is present, Tag 526 +func (m ExecutionReport) HasSecondaryClOrdID() bool { + return m.Has(tag.SecondaryClOrdID) +} + +//HasSecondaryExecID returns true if SecondaryExecID is present, Tag 527 +func (m ExecutionReport) HasSecondaryExecID() bool { + return m.Has(tag.SecondaryExecID) +} + +//HasOrderCapacity returns true if OrderCapacity is present, Tag 528 +func (m ExecutionReport) HasOrderCapacity() bool { + return m.Has(tag.OrderCapacity) +} + +//HasOrderRestrictions returns true if OrderRestrictions is present, Tag 529 +func (m ExecutionReport) HasOrderRestrictions() bool { + return m.Has(tag.OrderRestrictions) +} + +//HasMaturityDate returns true if MaturityDate is present, Tag 541 +func (m ExecutionReport) HasMaturityDate() bool { + return m.Has(tag.MaturityDate) +} + +//HasInstrRegistry returns true if InstrRegistry is present, Tag 543 +func (m ExecutionReport) HasInstrRegistry() bool { + return m.Has(tag.InstrRegistry) +} + +//HasCashMargin returns true if CashMargin is present, Tag 544 +func (m ExecutionReport) HasCashMargin() bool { + return m.Has(tag.CashMargin) +} + +//HasCrossID returns true if CrossID is present, Tag 548 +func (m ExecutionReport) HasCrossID() bool { + return m.Has(tag.CrossID) +} + +//HasCrossType returns true if CrossType is present, Tag 549 +func (m ExecutionReport) HasCrossType() bool { + return m.Has(tag.CrossType) +} + +//HasOrigCrossID returns true if OrigCrossID is present, Tag 551 +func (m ExecutionReport) HasOrigCrossID() bool { + return m.Has(tag.OrigCrossID) +} + +//HasNoLegs returns true if NoLegs is present, Tag 555 +func (m ExecutionReport) HasNoLegs() bool { + return m.Has(tag.NoLegs) +} + +//HasMatchType returns true if MatchType is present, Tag 574 +func (m ExecutionReport) HasMatchType() bool { + return m.Has(tag.MatchType) +} + +//HasAccountType returns true if AccountType is present, Tag 581 +func (m ExecutionReport) HasAccountType() bool { + return m.Has(tag.AccountType) +} + +//HasCustOrderCapacity returns true if CustOrderCapacity is present, Tag 582 +func (m ExecutionReport) HasCustOrderCapacity() bool { + return m.Has(tag.CustOrderCapacity) +} + +//HasClOrdLinkID returns true if ClOrdLinkID is present, Tag 583 +func (m ExecutionReport) HasClOrdLinkID() bool { + return m.Has(tag.ClOrdLinkID) +} + +//HasMassStatusReqID returns true if MassStatusReqID is present, Tag 584 +func (m ExecutionReport) HasMassStatusReqID() bool { + return m.Has(tag.MassStatusReqID) +} + +//HasDayBookingInst returns true if DayBookingInst is present, Tag 589 +func (m ExecutionReport) HasDayBookingInst() bool { + return m.Has(tag.DayBookingInst) +} + +//HasBookingUnit returns true if BookingUnit is present, Tag 590 +func (m ExecutionReport) HasBookingUnit() bool { + return m.Has(tag.BookingUnit) +} + +//HasPreallocMethod returns true if PreallocMethod is present, Tag 591 +func (m ExecutionReport) HasPreallocMethod() bool { + return m.Has(tag.PreallocMethod) +} + +//HasTradingSessionSubID returns true if TradingSessionSubID is present, Tag 625 +func (m ExecutionReport) HasTradingSessionSubID() bool { + return m.Has(tag.TradingSessionSubID) +} + +//HasClearingFeeIndicator returns true if ClearingFeeIndicator is present, Tag 635 +func (m ExecutionReport) HasClearingFeeIndicator() bool { + return m.Has(tag.ClearingFeeIndicator) +} + +//HasWorkingIndicator returns true if WorkingIndicator is present, Tag 636 +func (m ExecutionReport) HasWorkingIndicator() bool { + return m.Has(tag.WorkingIndicator) +} + +//HasPriorityIndicator returns true if PriorityIndicator is present, Tag 638 +func (m ExecutionReport) HasPriorityIndicator() bool { + return m.Has(tag.PriorityIndicator) +} + +//HasPriceImprovement returns true if PriceImprovement is present, Tag 639 +func (m ExecutionReport) HasPriceImprovement() bool { + return m.Has(tag.PriceImprovement) +} + +//HasLastForwardPoints2 returns true if LastForwardPoints2 is present, Tag 641 +func (m ExecutionReport) HasLastForwardPoints2() bool { + return m.Has(tag.LastForwardPoints2) +} + +//HasUnderlyingLastPx returns true if UnderlyingLastPx is present, Tag 651 +func (m ExecutionReport) HasUnderlyingLastPx() bool { + return m.Has(tag.UnderlyingLastPx) +} + +//HasUnderlyingLastQty returns true if UnderlyingLastQty is present, Tag 652 +func (m ExecutionReport) HasUnderlyingLastQty() bool { + return m.Has(tag.UnderlyingLastQty) +} + +//HasAcctIDSource returns true if AcctIDSource is present, Tag 660 +func (m ExecutionReport) HasAcctIDSource() bool { + return m.Has(tag.AcctIDSource) +} + +//HasBenchmarkPrice returns true if BenchmarkPrice is present, Tag 662 +func (m ExecutionReport) HasBenchmarkPrice() bool { + return m.Has(tag.BenchmarkPrice) +} + +//HasBenchmarkPriceType returns true if BenchmarkPriceType is present, Tag 663 +func (m ExecutionReport) HasBenchmarkPriceType() bool { + return m.Has(tag.BenchmarkPriceType) +} + +//HasContractSettlMonth returns true if ContractSettlMonth is present, Tag 667 +func (m ExecutionReport) HasContractSettlMonth() bool { + return m.Has(tag.ContractSettlMonth) +} + +//HasLastParPx returns true if LastParPx is present, Tag 669 +func (m ExecutionReport) HasLastParPx() bool { + return m.Has(tag.LastParPx) +} + +//HasPool returns true if Pool is present, Tag 691 +func (m ExecutionReport) HasPool() bool { + return m.Has(tag.Pool) +} + +//HasQuoteRespID returns true if QuoteRespID is present, Tag 693 +func (m ExecutionReport) HasQuoteRespID() bool { + return m.Has(tag.QuoteRespID) +} + +//HasYieldRedemptionDate returns true if YieldRedemptionDate is present, Tag 696 +func (m ExecutionReport) HasYieldRedemptionDate() bool { + return m.Has(tag.YieldRedemptionDate) +} + +//HasYieldRedemptionPrice returns true if YieldRedemptionPrice is present, Tag 697 +func (m ExecutionReport) HasYieldRedemptionPrice() bool { + return m.Has(tag.YieldRedemptionPrice) +} + +//HasYieldRedemptionPriceType returns true if YieldRedemptionPriceType is present, Tag 698 +func (m ExecutionReport) HasYieldRedemptionPriceType() bool { + return m.Has(tag.YieldRedemptionPriceType) +} + +//HasBenchmarkSecurityID returns true if BenchmarkSecurityID is present, Tag 699 +func (m ExecutionReport) HasBenchmarkSecurityID() bool { + return m.Has(tag.BenchmarkSecurityID) +} + +//HasYieldCalcDate returns true if YieldCalcDate is present, Tag 701 +func (m ExecutionReport) HasYieldCalcDate() bool { + return m.Has(tag.YieldCalcDate) +} + +//HasNoUnderlyings returns true if NoUnderlyings is present, Tag 711 +func (m ExecutionReport) HasNoUnderlyings() bool { + return m.Has(tag.NoUnderlyings) +} + +//HasInterestAtMaturity returns true if InterestAtMaturity is present, Tag 738 +func (m ExecutionReport) HasInterestAtMaturity() bool { + return m.Has(tag.InterestAtMaturity) +} + +//HasBenchmarkSecurityIDSource returns true if BenchmarkSecurityIDSource is present, Tag 761 +func (m ExecutionReport) HasBenchmarkSecurityIDSource() bool { + return m.Has(tag.BenchmarkSecurityIDSource) +} + +//HasSecuritySubType returns true if SecuritySubType is present, Tag 762 +func (m ExecutionReport) HasSecuritySubType() bool { + return m.Has(tag.SecuritySubType) +} + +//HasNoTrdRegTimestamps returns true if NoTrdRegTimestamps is present, Tag 768 +func (m ExecutionReport) HasNoTrdRegTimestamps() bool { + return m.Has(tag.NoTrdRegTimestamps) +} + +//HasBookingType returns true if BookingType is present, Tag 775 +func (m ExecutionReport) HasBookingType() bool { + return m.Has(tag.BookingType) +} + +//HasTerminationType returns true if TerminationType is present, Tag 788 +func (m ExecutionReport) HasTerminationType() bool { + return m.Has(tag.TerminationType) +} + +//HasOrdStatusReqID returns true if OrdStatusReqID is present, Tag 790 +func (m ExecutionReport) HasOrdStatusReqID() bool { + return m.Has(tag.OrdStatusReqID) +} + +//HasCopyMsgIndicator returns true if CopyMsgIndicator is present, Tag 797 +func (m ExecutionReport) HasCopyMsgIndicator() bool { + return m.Has(tag.CopyMsgIndicator) +} + +//HasPegMoveType returns true if PegMoveType is present, Tag 835 +func (m ExecutionReport) HasPegMoveType() bool { + return m.Has(tag.PegMoveType) +} + +//HasPegOffsetType returns true if PegOffsetType is present, Tag 836 +func (m ExecutionReport) HasPegOffsetType() bool { + return m.Has(tag.PegOffsetType) +} + +//HasPegLimitType returns true if PegLimitType is present, Tag 837 +func (m ExecutionReport) HasPegLimitType() bool { + return m.Has(tag.PegLimitType) +} + +//HasPegRoundDirection returns true if PegRoundDirection is present, Tag 838 +func (m ExecutionReport) HasPegRoundDirection() bool { + return m.Has(tag.PegRoundDirection) +} + +//HasPeggedPrice returns true if PeggedPrice is present, Tag 839 +func (m ExecutionReport) HasPeggedPrice() bool { + return m.Has(tag.PeggedPrice) +} + +//HasPegScope returns true if PegScope is present, Tag 840 +func (m ExecutionReport) HasPegScope() bool { + return m.Has(tag.PegScope) +} + +//HasDiscretionMoveType returns true if DiscretionMoveType is present, Tag 841 +func (m ExecutionReport) HasDiscretionMoveType() bool { + return m.Has(tag.DiscretionMoveType) +} + +//HasDiscretionOffsetType returns true if DiscretionOffsetType is present, Tag 842 +func (m ExecutionReport) HasDiscretionOffsetType() bool { + return m.Has(tag.DiscretionOffsetType) +} + +//HasDiscretionLimitType returns true if DiscretionLimitType is present, Tag 843 +func (m ExecutionReport) HasDiscretionLimitType() bool { + return m.Has(tag.DiscretionLimitType) +} + +//HasDiscretionRoundDirection returns true if DiscretionRoundDirection is present, Tag 844 +func (m ExecutionReport) HasDiscretionRoundDirection() bool { + return m.Has(tag.DiscretionRoundDirection) +} + +//HasDiscretionPrice returns true if DiscretionPrice is present, Tag 845 +func (m ExecutionReport) HasDiscretionPrice() bool { + return m.Has(tag.DiscretionPrice) +} + +//HasDiscretionScope returns true if DiscretionScope is present, Tag 846 +func (m ExecutionReport) HasDiscretionScope() bool { + return m.Has(tag.DiscretionScope) +} + +//HasTargetStrategy returns true if TargetStrategy is present, Tag 847 +func (m ExecutionReport) HasTargetStrategy() bool { + return m.Has(tag.TargetStrategy) +} + +//HasTargetStrategyParameters returns true if TargetStrategyParameters is present, Tag 848 +func (m ExecutionReport) HasTargetStrategyParameters() bool { + return m.Has(tag.TargetStrategyParameters) +} + +//HasParticipationRate returns true if ParticipationRate is present, Tag 849 +func (m ExecutionReport) HasParticipationRate() bool { + return m.Has(tag.ParticipationRate) +} + +//HasTargetStrategyPerformance returns true if TargetStrategyPerformance is present, Tag 850 +func (m ExecutionReport) HasTargetStrategyPerformance() bool { + return m.Has(tag.TargetStrategyPerformance) +} + +//HasLastLiquidityInd returns true if LastLiquidityInd is present, Tag 851 +func (m ExecutionReport) HasLastLiquidityInd() bool { + return m.Has(tag.LastLiquidityInd) +} + +//HasQtyType returns true if QtyType is present, Tag 854 +func (m ExecutionReport) HasQtyType() bool { + return m.Has(tag.QtyType) +} + +//HasNoEvents returns true if NoEvents is present, Tag 864 +func (m ExecutionReport) HasNoEvents() bool { + return m.Has(tag.NoEvents) +} + +//HasDatedDate returns true if DatedDate is present, Tag 873 +func (m ExecutionReport) HasDatedDate() bool { + return m.Has(tag.DatedDate) +} + +//HasInterestAccrualDate returns true if InterestAccrualDate is present, Tag 874 +func (m ExecutionReport) HasInterestAccrualDate() bool { + return m.Has(tag.InterestAccrualDate) +} + +//HasCPProgram returns true if CPProgram is present, Tag 875 +func (m ExecutionReport) HasCPProgram() bool { + return m.Has(tag.CPProgram) +} + +//HasCPRegType returns true if CPRegType is present, Tag 876 +func (m ExecutionReport) HasCPRegType() bool { + return m.Has(tag.CPRegType) +} + +//HasMarginRatio returns true if MarginRatio is present, Tag 898 +func (m ExecutionReport) HasMarginRatio() bool { + return m.Has(tag.MarginRatio) +} + +//HasTotNumReports returns true if TotNumReports is present, Tag 911 +func (m ExecutionReport) HasTotNumReports() bool { + return m.Has(tag.TotNumReports) +} + +//HasLastRptRequested returns true if LastRptRequested is present, Tag 912 +func (m ExecutionReport) HasLastRptRequested() bool { + return m.Has(tag.LastRptRequested) +} + +//HasAgreementDesc returns true if AgreementDesc is present, Tag 913 +func (m ExecutionReport) HasAgreementDesc() bool { + return m.Has(tag.AgreementDesc) +} + +//HasAgreementID returns true if AgreementID is present, Tag 914 +func (m ExecutionReport) HasAgreementID() bool { + return m.Has(tag.AgreementID) +} + +//HasAgreementDate returns true if AgreementDate is present, Tag 915 +func (m ExecutionReport) HasAgreementDate() bool { + return m.Has(tag.AgreementDate) +} + +//HasStartDate returns true if StartDate is present, Tag 916 +func (m ExecutionReport) HasStartDate() bool { + return m.Has(tag.StartDate) +} + +//HasEndDate returns true if EndDate is present, Tag 917 +func (m ExecutionReport) HasEndDate() bool { + return m.Has(tag.EndDate) +} + +//HasAgreementCurrency returns true if AgreementCurrency is present, Tag 918 +func (m ExecutionReport) HasAgreementCurrency() bool { + return m.Has(tag.AgreementCurrency) +} + +//HasDeliveryType returns true if DeliveryType is present, Tag 919 +func (m ExecutionReport) HasDeliveryType() bool { + return m.Has(tag.DeliveryType) +} + +//HasEndAccruedInterestAmt returns true if EndAccruedInterestAmt is present, Tag 920 +func (m ExecutionReport) HasEndAccruedInterestAmt() bool { + return m.Has(tag.EndAccruedInterestAmt) +} + +//HasStartCash returns true if StartCash is present, Tag 921 +func (m ExecutionReport) HasStartCash() bool { + return m.Has(tag.StartCash) +} + +//HasEndCash returns true if EndCash is present, Tag 922 +func (m ExecutionReport) HasEndCash() bool { + return m.Has(tag.EndCash) +} + +//HasTimeBracket returns true if TimeBracket is present, Tag 943 +func (m ExecutionReport) HasTimeBracket() bool { + return m.Has(tag.TimeBracket) +} + +//HasStrikeCurrency returns true if StrikeCurrency is present, Tag 947 +func (m ExecutionReport) HasStrikeCurrency() bool { + return m.Has(tag.StrikeCurrency) +} + +//HasNoStrategyParameters returns true if NoStrategyParameters is present, Tag 957 +func (m ExecutionReport) HasNoStrategyParameters() bool { + return m.Has(tag.NoStrategyParameters) +} + +//HasHostCrossID returns true if HostCrossID is present, Tag 961 +func (m ExecutionReport) HasHostCrossID() bool { + return m.Has(tag.HostCrossID) +} + +//HasSecurityStatus returns true if SecurityStatus is present, Tag 965 +func (m ExecutionReport) HasSecurityStatus() bool { + return m.Has(tag.SecurityStatus) +} + +//HasSettleOnOpenFlag returns true if SettleOnOpenFlag is present, Tag 966 +func (m ExecutionReport) HasSettleOnOpenFlag() bool { + return m.Has(tag.SettleOnOpenFlag) +} + +//HasStrikeMultiplier returns true if StrikeMultiplier is present, Tag 967 +func (m ExecutionReport) HasStrikeMultiplier() bool { + return m.Has(tag.StrikeMultiplier) +} + +//HasStrikeValue returns true if StrikeValue is present, Tag 968 +func (m ExecutionReport) HasStrikeValue() bool { + return m.Has(tag.StrikeValue) +} + +//HasMinPriceIncrement returns true if MinPriceIncrement is present, Tag 969 +func (m ExecutionReport) HasMinPriceIncrement() bool { + return m.Has(tag.MinPriceIncrement) +} + +//HasPositionLimit returns true if PositionLimit is present, Tag 970 +func (m ExecutionReport) HasPositionLimit() bool { + return m.Has(tag.PositionLimit) +} + +//HasNTPositionLimit returns true if NTPositionLimit is present, Tag 971 +func (m ExecutionReport) HasNTPositionLimit() bool { + return m.Has(tag.NTPositionLimit) +} + +//HasUnitOfMeasure returns true if UnitOfMeasure is present, Tag 996 +func (m ExecutionReport) HasUnitOfMeasure() bool { + return m.Has(tag.UnitOfMeasure) +} + +//HasTimeUnit returns true if TimeUnit is present, Tag 997 +func (m ExecutionReport) HasTimeUnit() bool { + return m.Has(tag.TimeUnit) +} + +//HasNoInstrumentParties returns true if NoInstrumentParties is present, Tag 1018 +func (m ExecutionReport) HasNoInstrumentParties() bool { + return m.Has(tag.NoInstrumentParties) +} + +//HasManualOrderIndicator returns true if ManualOrderIndicator is present, Tag 1028 +func (m ExecutionReport) HasManualOrderIndicator() bool { + return m.Has(tag.ManualOrderIndicator) +} + +//HasCustDirectedOrder returns true if CustDirectedOrder is present, Tag 1029 +func (m ExecutionReport) HasCustDirectedOrder() bool { + return m.Has(tag.CustDirectedOrder) +} + +//HasReceivedDeptID returns true if ReceivedDeptID is present, Tag 1030 +func (m ExecutionReport) HasReceivedDeptID() bool { + return m.Has(tag.ReceivedDeptID) +} + +//HasCustOrderHandlingInst returns true if CustOrderHandlingInst is present, Tag 1031 +func (m ExecutionReport) HasCustOrderHandlingInst() bool { + return m.Has(tag.CustOrderHandlingInst) +} + +//HasOrderHandlingInstSource returns true if OrderHandlingInstSource is present, Tag 1032 +func (m ExecutionReport) HasOrderHandlingInstSource() bool { + return m.Has(tag.OrderHandlingInstSource) +} + +//HasInstrmtAssignmentMethod returns true if InstrmtAssignmentMethod is present, Tag 1049 +func (m ExecutionReport) HasInstrmtAssignmentMethod() bool { + return m.Has(tag.InstrmtAssignmentMethod) +} + +//HasCalculatedCcyLastQty returns true if CalculatedCcyLastQty is present, Tag 1056 +func (m ExecutionReport) HasCalculatedCcyLastQty() bool { + return m.Has(tag.CalculatedCcyLastQty) +} + +//HasAggressorIndicator returns true if AggressorIndicator is present, Tag 1057 +func (m ExecutionReport) HasAggressorIndicator() bool { + return m.Has(tag.AggressorIndicator) +} + +//HasLastSwapPoints returns true if LastSwapPoints is present, Tag 1071 +func (m ExecutionReport) HasLastSwapPoints() bool { + return m.Has(tag.LastSwapPoints) +} + +//HasMaturityTime returns true if MaturityTime is present, Tag 1079 +func (m ExecutionReport) HasMaturityTime() bool { + return m.Has(tag.MaturityTime) +} + +//HasSecondaryDisplayQty returns true if SecondaryDisplayQty is present, Tag 1082 +func (m ExecutionReport) HasSecondaryDisplayQty() bool { + return m.Has(tag.SecondaryDisplayQty) +} + +//HasDisplayWhen returns true if DisplayWhen is present, Tag 1083 +func (m ExecutionReport) HasDisplayWhen() bool { + return m.Has(tag.DisplayWhen) +} + +//HasDisplayMethod returns true if DisplayMethod is present, Tag 1084 +func (m ExecutionReport) HasDisplayMethod() bool { + return m.Has(tag.DisplayMethod) +} + +//HasDisplayLowQty returns true if DisplayLowQty is present, Tag 1085 +func (m ExecutionReport) HasDisplayLowQty() bool { + return m.Has(tag.DisplayLowQty) +} + +//HasDisplayHighQty returns true if DisplayHighQty is present, Tag 1086 +func (m ExecutionReport) HasDisplayHighQty() bool { + return m.Has(tag.DisplayHighQty) +} + +//HasDisplayMinIncr returns true if DisplayMinIncr is present, Tag 1087 +func (m ExecutionReport) HasDisplayMinIncr() bool { + return m.Has(tag.DisplayMinIncr) +} + +//HasRefreshQty returns true if RefreshQty is present, Tag 1088 +func (m ExecutionReport) HasRefreshQty() bool { + return m.Has(tag.RefreshQty) +} + +//HasMatchIncrement returns true if MatchIncrement is present, Tag 1089 +func (m ExecutionReport) HasMatchIncrement() bool { + return m.Has(tag.MatchIncrement) +} + +//HasMaxPriceLevels returns true if MaxPriceLevels is present, Tag 1090 +func (m ExecutionReport) HasMaxPriceLevels() bool { + return m.Has(tag.MaxPriceLevels) +} + +//HasPreTradeAnonymity returns true if PreTradeAnonymity is present, Tag 1091 +func (m ExecutionReport) HasPreTradeAnonymity() bool { + return m.Has(tag.PreTradeAnonymity) +} + +//HasPriceProtectionScope returns true if PriceProtectionScope is present, Tag 1092 +func (m ExecutionReport) HasPriceProtectionScope() bool { + return m.Has(tag.PriceProtectionScope) +} + +//HasLotType returns true if LotType is present, Tag 1093 +func (m ExecutionReport) HasLotType() bool { + return m.Has(tag.LotType) +} + +//HasPegPriceType returns true if PegPriceType is present, Tag 1094 +func (m ExecutionReport) HasPegPriceType() bool { + return m.Has(tag.PegPriceType) +} + +//HasPeggedRefPrice returns true if PeggedRefPrice is present, Tag 1095 +func (m ExecutionReport) HasPeggedRefPrice() bool { + return m.Has(tag.PeggedRefPrice) +} + +//HasPegSecurityIDSource returns true if PegSecurityIDSource is present, Tag 1096 +func (m ExecutionReport) HasPegSecurityIDSource() bool { + return m.Has(tag.PegSecurityIDSource) +} + +//HasPegSecurityID returns true if PegSecurityID is present, Tag 1097 +func (m ExecutionReport) HasPegSecurityID() bool { + return m.Has(tag.PegSecurityID) +} + +//HasPegSymbol returns true if PegSymbol is present, Tag 1098 +func (m ExecutionReport) HasPegSymbol() bool { + return m.Has(tag.PegSymbol) +} + +//HasPegSecurityDesc returns true if PegSecurityDesc is present, Tag 1099 +func (m ExecutionReport) HasPegSecurityDesc() bool { + return m.Has(tag.PegSecurityDesc) +} + +//HasTriggerType returns true if TriggerType is present, Tag 1100 +func (m ExecutionReport) HasTriggerType() bool { + return m.Has(tag.TriggerType) +} + +//HasTriggerAction returns true if TriggerAction is present, Tag 1101 +func (m ExecutionReport) HasTriggerAction() bool { + return m.Has(tag.TriggerAction) +} + +//HasTriggerPrice returns true if TriggerPrice is present, Tag 1102 +func (m ExecutionReport) HasTriggerPrice() bool { + return m.Has(tag.TriggerPrice) +} + +//HasTriggerSymbol returns true if TriggerSymbol is present, Tag 1103 +func (m ExecutionReport) HasTriggerSymbol() bool { + return m.Has(tag.TriggerSymbol) +} + +//HasTriggerSecurityID returns true if TriggerSecurityID is present, Tag 1104 +func (m ExecutionReport) HasTriggerSecurityID() bool { + return m.Has(tag.TriggerSecurityID) +} + +//HasTriggerSecurityIDSource returns true if TriggerSecurityIDSource is present, Tag 1105 +func (m ExecutionReport) HasTriggerSecurityIDSource() bool { + return m.Has(tag.TriggerSecurityIDSource) +} + +//HasTriggerSecurityDesc returns true if TriggerSecurityDesc is present, Tag 1106 +func (m ExecutionReport) HasTriggerSecurityDesc() bool { + return m.Has(tag.TriggerSecurityDesc) +} + +//HasTriggerPriceType returns true if TriggerPriceType is present, Tag 1107 +func (m ExecutionReport) HasTriggerPriceType() bool { + return m.Has(tag.TriggerPriceType) +} + +//HasTriggerPriceTypeScope returns true if TriggerPriceTypeScope is present, Tag 1108 +func (m ExecutionReport) HasTriggerPriceTypeScope() bool { + return m.Has(tag.TriggerPriceTypeScope) +} + +//HasTriggerPriceDirection returns true if TriggerPriceDirection is present, Tag 1109 +func (m ExecutionReport) HasTriggerPriceDirection() bool { + return m.Has(tag.TriggerPriceDirection) +} + +//HasTriggerNewPrice returns true if TriggerNewPrice is present, Tag 1110 +func (m ExecutionReport) HasTriggerNewPrice() bool { + return m.Has(tag.TriggerNewPrice) +} + +//HasTriggerOrderType returns true if TriggerOrderType is present, Tag 1111 +func (m ExecutionReport) HasTriggerOrderType() bool { + return m.Has(tag.TriggerOrderType) +} + +//HasTriggerNewQty returns true if TriggerNewQty is present, Tag 1112 +func (m ExecutionReport) HasTriggerNewQty() bool { + return m.Has(tag.TriggerNewQty) +} + +//HasTriggerTradingSessionID returns true if TriggerTradingSessionID is present, Tag 1113 +func (m ExecutionReport) HasTriggerTradingSessionID() bool { + return m.Has(tag.TriggerTradingSessionID) +} + +//HasTriggerTradingSessionSubID returns true if TriggerTradingSessionSubID is present, Tag 1114 +func (m ExecutionReport) HasTriggerTradingSessionSubID() bool { + return m.Has(tag.TriggerTradingSessionSubID) +} + +//HasOrderCategory returns true if OrderCategory is present, Tag 1115 +func (m ExecutionReport) HasOrderCategory() bool { + return m.Has(tag.OrderCategory) +} + +//HasDisplayQty returns true if DisplayQty is present, Tag 1138 +func (m ExecutionReport) HasDisplayQty() bool { + return m.Has(tag.DisplayQty) +} + +//NoMiscFees is a repeating group element, Tag 136 +type NoMiscFees struct { + quickfix.Group +} + +//SetMiscFeeAmt sets MiscFeeAmt, Tag 137 +func (m NoMiscFees) SetMiscFeeAmt(v float64) { + m.Set(field.NewMiscFeeAmt(v)) +} + +//SetMiscFeeCurr sets MiscFeeCurr, Tag 138 +func (m NoMiscFees) SetMiscFeeCurr(v string) { + m.Set(field.NewMiscFeeCurr(v)) +} + +//SetMiscFeeType sets MiscFeeType, Tag 139 +func (m NoMiscFees) SetMiscFeeType(v string) { + m.Set(field.NewMiscFeeType(v)) +} + +//SetMiscFeeBasis sets MiscFeeBasis, Tag 891 +func (m NoMiscFees) SetMiscFeeBasis(v int) { + m.Set(field.NewMiscFeeBasis(v)) +} + +//GetMiscFeeAmt gets MiscFeeAmt, Tag 137 +func (m NoMiscFees) GetMiscFeeAmt() (f field.MiscFeeAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMiscFeeCurr gets MiscFeeCurr, Tag 138 +func (m NoMiscFees) GetMiscFeeCurr() (f field.MiscFeeCurrField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMiscFeeType gets MiscFeeType, Tag 139 +func (m NoMiscFees) GetMiscFeeType() (f field.MiscFeeTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMiscFeeBasis gets MiscFeeBasis, Tag 891 +func (m NoMiscFees) GetMiscFeeBasis() (f field.MiscFeeBasisField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasMiscFeeAmt returns true if MiscFeeAmt is present, Tag 137 +func (m NoMiscFees) HasMiscFeeAmt() bool { + return m.Has(tag.MiscFeeAmt) +} + +//HasMiscFeeCurr returns true if MiscFeeCurr is present, Tag 138 +func (m NoMiscFees) HasMiscFeeCurr() bool { + return m.Has(tag.MiscFeeCurr) +} + +//HasMiscFeeType returns true if MiscFeeType is present, Tag 139 +func (m NoMiscFees) HasMiscFeeType() bool { + return m.Has(tag.MiscFeeType) +} + +//HasMiscFeeBasis returns true if MiscFeeBasis is present, Tag 891 +func (m NoMiscFees) HasMiscFeeBasis() bool { + return m.Has(tag.MiscFeeBasis) +} + +//NoMiscFeesRepeatingGroup is a repeating group, Tag 136 +type NoMiscFeesRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoMiscFeesRepeatingGroup returns an initialized, NoMiscFeesRepeatingGroup +func NewNoMiscFeesRepeatingGroup() NoMiscFeesRepeatingGroup { + return NoMiscFeesRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoMiscFees, + quickfix.GroupTemplate{quickfix.GroupElement(tag.MiscFeeAmt), quickfix.GroupElement(tag.MiscFeeCurr), quickfix.GroupElement(tag.MiscFeeType), quickfix.GroupElement(tag.MiscFeeBasis)})} +} + +//Add create and append a new NoMiscFees to this group +func (m NoMiscFeesRepeatingGroup) Add() NoMiscFees { + g := m.RepeatingGroup.Add() + return NoMiscFees{g} +} + +//Get returns the ith NoMiscFees in the NoMiscFeesRepeatinGroup +func (m NoMiscFeesRepeatingGroup) Get(i int) NoMiscFees { + return NoMiscFees{m.RepeatingGroup.Get(i)} +} + +//NoStipulations is a repeating group element, Tag 232 +type NoStipulations struct { + quickfix.Group +} + +//SetStipulationType sets StipulationType, Tag 233 +func (m NoStipulations) SetStipulationType(v string) { + m.Set(field.NewStipulationType(v)) +} + +//SetStipulationValue sets StipulationValue, Tag 234 +func (m NoStipulations) SetStipulationValue(v string) { + m.Set(field.NewStipulationValue(v)) +} + +//GetStipulationType gets StipulationType, Tag 233 +func (m NoStipulations) GetStipulationType() (f field.StipulationTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStipulationValue gets StipulationValue, Tag 234 +func (m NoStipulations) GetStipulationValue() (f field.StipulationValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasStipulationType returns true if StipulationType is present, Tag 233 +func (m NoStipulations) HasStipulationType() bool { + return m.Has(tag.StipulationType) +} + +//HasStipulationValue returns true if StipulationValue is present, Tag 234 +func (m NoStipulations) HasStipulationValue() bool { + return m.Has(tag.StipulationValue) +} + +//NoStipulationsRepeatingGroup is a repeating group, Tag 232 +type NoStipulationsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoStipulationsRepeatingGroup returns an initialized, NoStipulationsRepeatingGroup +func NewNoStipulationsRepeatingGroup() NoStipulationsRepeatingGroup { + return NoStipulationsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoStipulations, + quickfix.GroupTemplate{quickfix.GroupElement(tag.StipulationType), quickfix.GroupElement(tag.StipulationValue)})} +} + +//Add create and append a new NoStipulations to this group +func (m NoStipulationsRepeatingGroup) Add() NoStipulations { + g := m.RepeatingGroup.Add() + return NoStipulations{g} +} + +//Get returns the ith NoStipulations in the NoStipulationsRepeatinGroup +func (m NoStipulationsRepeatingGroup) Get(i int) NoStipulations { + return NoStipulations{m.RepeatingGroup.Get(i)} +} + +//NoContraBrokers is a repeating group element, Tag 382 +type NoContraBrokers struct { + quickfix.Group +} + +//SetContraBroker sets ContraBroker, Tag 375 +func (m NoContraBrokers) SetContraBroker(v string) { + m.Set(field.NewContraBroker(v)) +} + +//SetContraTrader sets ContraTrader, Tag 337 +func (m NoContraBrokers) SetContraTrader(v string) { + m.Set(field.NewContraTrader(v)) +} + +//SetContraTradeQty sets ContraTradeQty, Tag 437 +func (m NoContraBrokers) SetContraTradeQty(v float64) { + m.Set(field.NewContraTradeQty(v)) +} + +//SetContraTradeTime sets ContraTradeTime, Tag 438 +func (m NoContraBrokers) SetContraTradeTime(v time.Time) { + m.Set(field.NewContraTradeTime(v)) +} + +//SetContraLegRefID sets ContraLegRefID, Tag 655 +func (m NoContraBrokers) SetContraLegRefID(v string) { + m.Set(field.NewContraLegRefID(v)) +} + +//GetContraBroker gets ContraBroker, Tag 375 +func (m NoContraBrokers) GetContraBroker() (f field.ContraBrokerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContraTrader gets ContraTrader, Tag 337 +func (m NoContraBrokers) GetContraTrader() (f field.ContraTraderField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContraTradeQty gets ContraTradeQty, Tag 437 +func (m NoContraBrokers) GetContraTradeQty() (f field.ContraTradeQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContraTradeTime gets ContraTradeTime, Tag 438 +func (m NoContraBrokers) GetContraTradeTime() (f field.ContraTradeTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContraLegRefID gets ContraLegRefID, Tag 655 +func (m NoContraBrokers) GetContraLegRefID() (f field.ContraLegRefIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasContraBroker returns true if ContraBroker is present, Tag 375 +func (m NoContraBrokers) HasContraBroker() bool { + return m.Has(tag.ContraBroker) +} + +//HasContraTrader returns true if ContraTrader is present, Tag 337 +func (m NoContraBrokers) HasContraTrader() bool { + return m.Has(tag.ContraTrader) +} + +//HasContraTradeQty returns true if ContraTradeQty is present, Tag 437 +func (m NoContraBrokers) HasContraTradeQty() bool { + return m.Has(tag.ContraTradeQty) +} + +//HasContraTradeTime returns true if ContraTradeTime is present, Tag 438 +func (m NoContraBrokers) HasContraTradeTime() bool { + return m.Has(tag.ContraTradeTime) +} + +//HasContraLegRefID returns true if ContraLegRefID is present, Tag 655 +func (m NoContraBrokers) HasContraLegRefID() bool { + return m.Has(tag.ContraLegRefID) +} + +//NoContraBrokersRepeatingGroup is a repeating group, Tag 382 +type NoContraBrokersRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoContraBrokersRepeatingGroup returns an initialized, NoContraBrokersRepeatingGroup +func NewNoContraBrokersRepeatingGroup() NoContraBrokersRepeatingGroup { + return NoContraBrokersRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoContraBrokers, + quickfix.GroupTemplate{quickfix.GroupElement(tag.ContraBroker), quickfix.GroupElement(tag.ContraTrader), quickfix.GroupElement(tag.ContraTradeQty), quickfix.GroupElement(tag.ContraTradeTime), quickfix.GroupElement(tag.ContraLegRefID)})} +} + +//Add create and append a new NoContraBrokers to this group +func (m NoContraBrokersRepeatingGroup) Add() NoContraBrokers { + g := m.RepeatingGroup.Add() + return NoContraBrokers{g} +} + +//Get returns the ith NoContraBrokers in the NoContraBrokersRepeatinGroup +func (m NoContraBrokersRepeatingGroup) Get(i int) NoContraBrokers { + return NoContraBrokers{m.RepeatingGroup.Get(i)} +} + +//NoPartyIDs is a repeating group element, Tag 453 +type NoPartyIDs struct { + quickfix.Group +} + +//SetPartyID sets PartyID, Tag 448 +func (m NoPartyIDs) SetPartyID(v string) { + m.Set(field.NewPartyID(v)) +} + +//SetPartyIDSource sets PartyIDSource, Tag 447 +func (m NoPartyIDs) SetPartyIDSource(v string) { + m.Set(field.NewPartyIDSource(v)) +} + +//SetPartyRole sets PartyRole, Tag 452 +func (m NoPartyIDs) SetPartyRole(v int) { + m.Set(field.NewPartyRole(v)) +} + +//SetNoPartySubIDs sets NoPartySubIDs, Tag 802 +func (m NoPartyIDs) SetNoPartySubIDs(f NoPartySubIDsRepeatingGroup) { + m.SetGroup(f) +} + +//GetPartyID gets PartyID, Tag 448 +func (m NoPartyIDs) GetPartyID() (f field.PartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartyIDSource gets PartyIDSource, Tag 447 +func (m NoPartyIDs) GetPartyIDSource() (f field.PartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartyRole gets PartyRole, Tag 452 +func (m NoPartyIDs) GetPartyRole() (f field.PartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoPartySubIDs gets NoPartySubIDs, Tag 802 +func (m NoPartyIDs) GetNoPartySubIDs() (NoPartySubIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoPartySubIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasPartyID returns true if PartyID is present, Tag 448 +func (m NoPartyIDs) HasPartyID() bool { + return m.Has(tag.PartyID) +} + +//HasPartyIDSource returns true if PartyIDSource is present, Tag 447 +func (m NoPartyIDs) HasPartyIDSource() bool { + return m.Has(tag.PartyIDSource) +} + +//HasPartyRole returns true if PartyRole is present, Tag 452 +func (m NoPartyIDs) HasPartyRole() bool { + return m.Has(tag.PartyRole) +} + +//HasNoPartySubIDs returns true if NoPartySubIDs is present, Tag 802 +func (m NoPartyIDs) HasNoPartySubIDs() bool { + return m.Has(tag.NoPartySubIDs) +} + +//NoPartySubIDs is a repeating group element, Tag 802 +type NoPartySubIDs struct { + quickfix.Group +} + +//SetPartySubID sets PartySubID, Tag 523 +func (m NoPartySubIDs) SetPartySubID(v string) { + m.Set(field.NewPartySubID(v)) +} + +//SetPartySubIDType sets PartySubIDType, Tag 803 +func (m NoPartySubIDs) SetPartySubIDType(v int) { + m.Set(field.NewPartySubIDType(v)) +} + +//GetPartySubID gets PartySubID, Tag 523 +func (m NoPartySubIDs) GetPartySubID() (f field.PartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartySubIDType gets PartySubIDType, Tag 803 +func (m NoPartySubIDs) GetPartySubIDType() (f field.PartySubIDTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasPartySubID returns true if PartySubID is present, Tag 523 +func (m NoPartySubIDs) HasPartySubID() bool { + return m.Has(tag.PartySubID) +} + +//HasPartySubIDType returns true if PartySubIDType is present, Tag 803 +func (m NoPartySubIDs) HasPartySubIDType() bool { + return m.Has(tag.PartySubIDType) +} + +//NoPartySubIDsRepeatingGroup is a repeating group, Tag 802 +type NoPartySubIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoPartySubIDsRepeatingGroup returns an initialized, NoPartySubIDsRepeatingGroup +func NewNoPartySubIDsRepeatingGroup() NoPartySubIDsRepeatingGroup { + return NoPartySubIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoPartySubIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.PartySubID), quickfix.GroupElement(tag.PartySubIDType)})} +} + +//Add create and append a new NoPartySubIDs to this group +func (m NoPartySubIDsRepeatingGroup) Add() NoPartySubIDs { + g := m.RepeatingGroup.Add() + return NoPartySubIDs{g} +} + +//Get returns the ith NoPartySubIDs in the NoPartySubIDsRepeatinGroup +func (m NoPartySubIDsRepeatingGroup) Get(i int) NoPartySubIDs { + return NoPartySubIDs{m.RepeatingGroup.Get(i)} +} + +//NoPartyIDsRepeatingGroup is a repeating group, Tag 453 +type NoPartyIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoPartyIDsRepeatingGroup returns an initialized, NoPartyIDsRepeatingGroup +func NewNoPartyIDsRepeatingGroup() NoPartyIDsRepeatingGroup { + return NoPartyIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoPartyIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.PartyID), quickfix.GroupElement(tag.PartyIDSource), quickfix.GroupElement(tag.PartyRole), NewNoPartySubIDsRepeatingGroup()})} +} + +//Add create and append a new NoPartyIDs to this group +func (m NoPartyIDsRepeatingGroup) Add() NoPartyIDs { + g := m.RepeatingGroup.Add() + return NoPartyIDs{g} +} + +//Get returns the ith NoPartyIDs in the NoPartyIDsRepeatinGroup +func (m NoPartyIDsRepeatingGroup) Get(i int) NoPartyIDs { + return NoPartyIDs{m.RepeatingGroup.Get(i)} +} + +//NoSecurityAltID is a repeating group element, Tag 454 +type NoSecurityAltID struct { + quickfix.Group +} + +//SetSecurityAltID sets SecurityAltID, Tag 455 +func (m NoSecurityAltID) SetSecurityAltID(v string) { + m.Set(field.NewSecurityAltID(v)) +} + +//SetSecurityAltIDSource sets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) SetSecurityAltIDSource(v string) { + m.Set(field.NewSecurityAltIDSource(v)) +} + +//GetSecurityAltID gets SecurityAltID, Tag 455 +func (m NoSecurityAltID) GetSecurityAltID() (f field.SecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityAltIDSource gets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) GetSecurityAltIDSource() (f field.SecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasSecurityAltID returns true if SecurityAltID is present, Tag 455 +func (m NoSecurityAltID) HasSecurityAltID() bool { + return m.Has(tag.SecurityAltID) +} + +//HasSecurityAltIDSource returns true if SecurityAltIDSource is present, Tag 456 +func (m NoSecurityAltID) HasSecurityAltIDSource() bool { + return m.Has(tag.SecurityAltIDSource) +} + +//NoSecurityAltIDRepeatingGroup is a repeating group, Tag 454 +type NoSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoSecurityAltIDRepeatingGroup returns an initialized, NoSecurityAltIDRepeatingGroup +func NewNoSecurityAltIDRepeatingGroup() NoSecurityAltIDRepeatingGroup { + return NoSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.SecurityAltID), quickfix.GroupElement(tag.SecurityAltIDSource)})} +} + +//Add create and append a new NoSecurityAltID to this group +func (m NoSecurityAltIDRepeatingGroup) Add() NoSecurityAltID { + g := m.RepeatingGroup.Add() + return NoSecurityAltID{g} +} + +//Get returns the ith NoSecurityAltID in the NoSecurityAltIDRepeatinGroup +func (m NoSecurityAltIDRepeatingGroup) Get(i int) NoSecurityAltID { + return NoSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoContAmts is a repeating group element, Tag 518 +type NoContAmts struct { + quickfix.Group +} + +//SetContAmtType sets ContAmtType, Tag 519 +func (m NoContAmts) SetContAmtType(v int) { + m.Set(field.NewContAmtType(v)) +} + +//SetContAmtValue sets ContAmtValue, Tag 520 +func (m NoContAmts) SetContAmtValue(v float64) { + m.Set(field.NewContAmtValue(v)) +} + +//SetContAmtCurr sets ContAmtCurr, Tag 521 +func (m NoContAmts) SetContAmtCurr(v string) { + m.Set(field.NewContAmtCurr(v)) +} + +//GetContAmtType gets ContAmtType, Tag 519 +func (m NoContAmts) GetContAmtType() (f field.ContAmtTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContAmtValue gets ContAmtValue, Tag 520 +func (m NoContAmts) GetContAmtValue() (f field.ContAmtValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContAmtCurr gets ContAmtCurr, Tag 521 +func (m NoContAmts) GetContAmtCurr() (f field.ContAmtCurrField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasContAmtType returns true if ContAmtType is present, Tag 519 +func (m NoContAmts) HasContAmtType() bool { + return m.Has(tag.ContAmtType) +} + +//HasContAmtValue returns true if ContAmtValue is present, Tag 520 +func (m NoContAmts) HasContAmtValue() bool { + return m.Has(tag.ContAmtValue) +} + +//HasContAmtCurr returns true if ContAmtCurr is present, Tag 521 +func (m NoContAmts) HasContAmtCurr() bool { + return m.Has(tag.ContAmtCurr) +} + +//NoContAmtsRepeatingGroup is a repeating group, Tag 518 +type NoContAmtsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoContAmtsRepeatingGroup returns an initialized, NoContAmtsRepeatingGroup +func NewNoContAmtsRepeatingGroup() NoContAmtsRepeatingGroup { + return NoContAmtsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoContAmts, + quickfix.GroupTemplate{quickfix.GroupElement(tag.ContAmtType), quickfix.GroupElement(tag.ContAmtValue), quickfix.GroupElement(tag.ContAmtCurr)})} +} + +//Add create and append a new NoContAmts to this group +func (m NoContAmtsRepeatingGroup) Add() NoContAmts { + g := m.RepeatingGroup.Add() + return NoContAmts{g} +} + +//Get returns the ith NoContAmts in the NoContAmtsRepeatinGroup +func (m NoContAmtsRepeatingGroup) Get(i int) NoContAmts { + return NoContAmts{m.RepeatingGroup.Get(i)} +} + +//NoLegs is a repeating group element, Tag 555 +type NoLegs struct { + quickfix.Group +} + +//SetLegSymbol sets LegSymbol, Tag 600 +func (m NoLegs) SetLegSymbol(v string) { + m.Set(field.NewLegSymbol(v)) +} + +//SetLegSymbolSfx sets LegSymbolSfx, Tag 601 +func (m NoLegs) SetLegSymbolSfx(v string) { + m.Set(field.NewLegSymbolSfx(v)) +} + +//SetLegSecurityID sets LegSecurityID, Tag 602 +func (m NoLegs) SetLegSecurityID(v string) { + m.Set(field.NewLegSecurityID(v)) +} + +//SetLegSecurityIDSource sets LegSecurityIDSource, Tag 603 +func (m NoLegs) SetLegSecurityIDSource(v string) { + m.Set(field.NewLegSecurityIDSource(v)) +} + +//SetNoLegSecurityAltID sets NoLegSecurityAltID, Tag 604 +func (m NoLegs) SetNoLegSecurityAltID(f NoLegSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetLegProduct sets LegProduct, Tag 607 +func (m NoLegs) SetLegProduct(v int) { + m.Set(field.NewLegProduct(v)) +} + +//SetLegCFICode sets LegCFICode, Tag 608 +func (m NoLegs) SetLegCFICode(v string) { + m.Set(field.NewLegCFICode(v)) +} + +//SetLegSecurityType sets LegSecurityType, Tag 609 +func (m NoLegs) SetLegSecurityType(v string) { + m.Set(field.NewLegSecurityType(v)) +} + +//SetLegSecuritySubType sets LegSecuritySubType, Tag 764 +func (m NoLegs) SetLegSecuritySubType(v string) { + m.Set(field.NewLegSecuritySubType(v)) +} + +//SetLegMaturityMonthYear sets LegMaturityMonthYear, Tag 610 +func (m NoLegs) SetLegMaturityMonthYear(v string) { + m.Set(field.NewLegMaturityMonthYear(v)) +} + +//SetLegMaturityDate sets LegMaturityDate, Tag 611 +func (m NoLegs) SetLegMaturityDate(v string) { + m.Set(field.NewLegMaturityDate(v)) +} + +//SetLegCouponPaymentDate sets LegCouponPaymentDate, Tag 248 +func (m NoLegs) SetLegCouponPaymentDate(v string) { + m.Set(field.NewLegCouponPaymentDate(v)) +} + +//SetLegIssueDate sets LegIssueDate, Tag 249 +func (m NoLegs) SetLegIssueDate(v string) { + m.Set(field.NewLegIssueDate(v)) +} + +//SetLegRepoCollateralSecurityType sets LegRepoCollateralSecurityType, Tag 250 +func (m NoLegs) SetLegRepoCollateralSecurityType(v int) { + m.Set(field.NewLegRepoCollateralSecurityType(v)) +} + +//SetLegRepurchaseTerm sets LegRepurchaseTerm, Tag 251 +func (m NoLegs) SetLegRepurchaseTerm(v int) { + m.Set(field.NewLegRepurchaseTerm(v)) +} + +//SetLegRepurchaseRate sets LegRepurchaseRate, Tag 252 +func (m NoLegs) SetLegRepurchaseRate(v float64) { + m.Set(field.NewLegRepurchaseRate(v)) +} + +//SetLegFactor sets LegFactor, Tag 253 +func (m NoLegs) SetLegFactor(v float64) { + m.Set(field.NewLegFactor(v)) +} + +//SetLegCreditRating sets LegCreditRating, Tag 257 +func (m NoLegs) SetLegCreditRating(v string) { + m.Set(field.NewLegCreditRating(v)) +} + +//SetLegInstrRegistry sets LegInstrRegistry, Tag 599 +func (m NoLegs) SetLegInstrRegistry(v string) { + m.Set(field.NewLegInstrRegistry(v)) +} + +//SetLegCountryOfIssue sets LegCountryOfIssue, Tag 596 +func (m NoLegs) SetLegCountryOfIssue(v string) { + m.Set(field.NewLegCountryOfIssue(v)) +} + +//SetLegStateOrProvinceOfIssue sets LegStateOrProvinceOfIssue, Tag 597 +func (m NoLegs) SetLegStateOrProvinceOfIssue(v string) { + m.Set(field.NewLegStateOrProvinceOfIssue(v)) +} + +//SetLegLocaleOfIssue sets LegLocaleOfIssue, Tag 598 +func (m NoLegs) SetLegLocaleOfIssue(v string) { + m.Set(field.NewLegLocaleOfIssue(v)) +} + +//SetLegRedemptionDate sets LegRedemptionDate, Tag 254 +func (m NoLegs) SetLegRedemptionDate(v string) { + m.Set(field.NewLegRedemptionDate(v)) +} + +//SetLegStrikePrice sets LegStrikePrice, Tag 612 +func (m NoLegs) SetLegStrikePrice(v float64) { + m.Set(field.NewLegStrikePrice(v)) +} + +//SetLegStrikeCurrency sets LegStrikeCurrency, Tag 942 +func (m NoLegs) SetLegStrikeCurrency(v string) { + m.Set(field.NewLegStrikeCurrency(v)) +} + +//SetLegOptAttribute sets LegOptAttribute, Tag 613 +func (m NoLegs) SetLegOptAttribute(v string) { + m.Set(field.NewLegOptAttribute(v)) +} + +//SetLegContractMultiplier sets LegContractMultiplier, Tag 614 +func (m NoLegs) SetLegContractMultiplier(v float64) { + m.Set(field.NewLegContractMultiplier(v)) +} + +//SetLegCouponRate sets LegCouponRate, Tag 615 +func (m NoLegs) SetLegCouponRate(v float64) { + m.Set(field.NewLegCouponRate(v)) +} + +//SetLegSecurityExchange sets LegSecurityExchange, Tag 616 +func (m NoLegs) SetLegSecurityExchange(v string) { + m.Set(field.NewLegSecurityExchange(v)) +} + +//SetLegIssuer sets LegIssuer, Tag 617 +func (m NoLegs) SetLegIssuer(v string) { + m.Set(field.NewLegIssuer(v)) +} + +//SetEncodedLegIssuerLen sets EncodedLegIssuerLen, Tag 618 +func (m NoLegs) SetEncodedLegIssuerLen(v int) { + m.Set(field.NewEncodedLegIssuerLen(v)) +} + +//SetEncodedLegIssuer sets EncodedLegIssuer, Tag 619 +func (m NoLegs) SetEncodedLegIssuer(v string) { + m.Set(field.NewEncodedLegIssuer(v)) +} + +//SetLegSecurityDesc sets LegSecurityDesc, Tag 620 +func (m NoLegs) SetLegSecurityDesc(v string) { + m.Set(field.NewLegSecurityDesc(v)) +} + +//SetEncodedLegSecurityDescLen sets EncodedLegSecurityDescLen, Tag 621 +func (m NoLegs) SetEncodedLegSecurityDescLen(v int) { + m.Set(field.NewEncodedLegSecurityDescLen(v)) +} + +//SetEncodedLegSecurityDesc sets EncodedLegSecurityDesc, Tag 622 +func (m NoLegs) SetEncodedLegSecurityDesc(v string) { + m.Set(field.NewEncodedLegSecurityDesc(v)) +} + +//SetLegRatioQty sets LegRatioQty, Tag 623 +func (m NoLegs) SetLegRatioQty(v float64) { + m.Set(field.NewLegRatioQty(v)) +} + +//SetLegSide sets LegSide, Tag 624 +func (m NoLegs) SetLegSide(v string) { + m.Set(field.NewLegSide(v)) +} + +//SetLegCurrency sets LegCurrency, Tag 556 +func (m NoLegs) SetLegCurrency(v string) { + m.Set(field.NewLegCurrency(v)) +} + +//SetLegPool sets LegPool, Tag 740 +func (m NoLegs) SetLegPool(v string) { + m.Set(field.NewLegPool(v)) +} + +//SetLegDatedDate sets LegDatedDate, Tag 739 +func (m NoLegs) SetLegDatedDate(v string) { + m.Set(field.NewLegDatedDate(v)) +} + +//SetLegContractSettlMonth sets LegContractSettlMonth, Tag 955 +func (m NoLegs) SetLegContractSettlMonth(v string) { + m.Set(field.NewLegContractSettlMonth(v)) +} + +//SetLegInterestAccrualDate sets LegInterestAccrualDate, Tag 956 +func (m NoLegs) SetLegInterestAccrualDate(v string) { + m.Set(field.NewLegInterestAccrualDate(v)) +} + +//SetLegUnitOfMeasure sets LegUnitOfMeasure, Tag 999 +func (m NoLegs) SetLegUnitOfMeasure(v string) { + m.Set(field.NewLegUnitOfMeasure(v)) +} + +//SetLegTimeUnit sets LegTimeUnit, Tag 1001 +func (m NoLegs) SetLegTimeUnit(v string) { + m.Set(field.NewLegTimeUnit(v)) +} + +//SetLegQty sets LegQty, Tag 687 +func (m NoLegs) SetLegQty(v float64) { + m.Set(field.NewLegQty(v)) +} + +//SetLegSwapType sets LegSwapType, Tag 690 +func (m NoLegs) SetLegSwapType(v int) { + m.Set(field.NewLegSwapType(v)) +} + +//SetNoLegStipulations sets NoLegStipulations, Tag 683 +func (m NoLegs) SetNoLegStipulations(f NoLegStipulationsRepeatingGroup) { + m.SetGroup(f) +} + +//SetLegPositionEffect sets LegPositionEffect, Tag 564 +func (m NoLegs) SetLegPositionEffect(v string) { + m.Set(field.NewLegPositionEffect(v)) +} + +//SetLegCoveredOrUncovered sets LegCoveredOrUncovered, Tag 565 +func (m NoLegs) SetLegCoveredOrUncovered(v int) { + m.Set(field.NewLegCoveredOrUncovered(v)) +} + +//SetNoNestedPartyIDs sets NoNestedPartyIDs, Tag 539 +func (m NoLegs) SetNoNestedPartyIDs(f NoNestedPartyIDsRepeatingGroup) { + m.SetGroup(f) +} + +//SetLegRefID sets LegRefID, Tag 654 +func (m NoLegs) SetLegRefID(v string) { + m.Set(field.NewLegRefID(v)) +} + +//SetLegPrice sets LegPrice, Tag 566 +func (m NoLegs) SetLegPrice(v float64) { + m.Set(field.NewLegPrice(v)) +} + +//SetLegSettlType sets LegSettlType, Tag 587 +func (m NoLegs) SetLegSettlType(v string) { + m.Set(field.NewLegSettlType(v)) +} + +//SetLegSettlDate sets LegSettlDate, Tag 588 +func (m NoLegs) SetLegSettlDate(v string) { + m.Set(field.NewLegSettlDate(v)) +} + +//SetLegLastPx sets LegLastPx, Tag 637 +func (m NoLegs) SetLegLastPx(v float64) { + m.Set(field.NewLegLastPx(v)) +} + +//SetLegOrderQty sets LegOrderQty, Tag 685 +func (m NoLegs) SetLegOrderQty(v float64) { + m.Set(field.NewLegOrderQty(v)) +} + +//SetLegSettlCurrency sets LegSettlCurrency, Tag 675 +func (m NoLegs) SetLegSettlCurrency(v string) { + m.Set(field.NewLegSettlCurrency(v)) +} + +//SetLegLastForwardPoints sets LegLastForwardPoints, Tag 1073 +func (m NoLegs) SetLegLastForwardPoints(v float64) { + m.Set(field.NewLegLastForwardPoints(v)) +} + +//SetLegCalculatedCcyLastQty sets LegCalculatedCcyLastQty, Tag 1074 +func (m NoLegs) SetLegCalculatedCcyLastQty(v float64) { + m.Set(field.NewLegCalculatedCcyLastQty(v)) +} + +//SetLegGrossTradeAmt sets LegGrossTradeAmt, Tag 1075 +func (m NoLegs) SetLegGrossTradeAmt(v float64) { + m.Set(field.NewLegGrossTradeAmt(v)) +} + +//GetLegSymbol gets LegSymbol, Tag 600 +func (m NoLegs) GetLegSymbol() (f field.LegSymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSymbolSfx gets LegSymbolSfx, Tag 601 +func (m NoLegs) GetLegSymbolSfx() (f field.LegSymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityID gets LegSecurityID, Tag 602 +func (m NoLegs) GetLegSecurityID() (f field.LegSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityIDSource gets LegSecurityIDSource, Tag 603 +func (m NoLegs) GetLegSecurityIDSource() (f field.LegSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoLegSecurityAltID gets NoLegSecurityAltID, Tag 604 +func (m NoLegs) GetNoLegSecurityAltID() (NoLegSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoLegSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetLegProduct gets LegProduct, Tag 607 +func (m NoLegs) GetLegProduct() (f field.LegProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCFICode gets LegCFICode, Tag 608 +func (m NoLegs) GetLegCFICode() (f field.LegCFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityType gets LegSecurityType, Tag 609 +func (m NoLegs) GetLegSecurityType() (f field.LegSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecuritySubType gets LegSecuritySubType, Tag 764 +func (m NoLegs) GetLegSecuritySubType() (f field.LegSecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegMaturityMonthYear gets LegMaturityMonthYear, Tag 610 +func (m NoLegs) GetLegMaturityMonthYear() (f field.LegMaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegMaturityDate gets LegMaturityDate, Tag 611 +func (m NoLegs) GetLegMaturityDate() (f field.LegMaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCouponPaymentDate gets LegCouponPaymentDate, Tag 248 +func (m NoLegs) GetLegCouponPaymentDate() (f field.LegCouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegIssueDate gets LegIssueDate, Tag 249 +func (m NoLegs) GetLegIssueDate() (f field.LegIssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRepoCollateralSecurityType gets LegRepoCollateralSecurityType, Tag 250 +func (m NoLegs) GetLegRepoCollateralSecurityType() (f field.LegRepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRepurchaseTerm gets LegRepurchaseTerm, Tag 251 +func (m NoLegs) GetLegRepurchaseTerm() (f field.LegRepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRepurchaseRate gets LegRepurchaseRate, Tag 252 +func (m NoLegs) GetLegRepurchaseRate() (f field.LegRepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegFactor gets LegFactor, Tag 253 +func (m NoLegs) GetLegFactor() (f field.LegFactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCreditRating gets LegCreditRating, Tag 257 +func (m NoLegs) GetLegCreditRating() (f field.LegCreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegInstrRegistry gets LegInstrRegistry, Tag 599 +func (m NoLegs) GetLegInstrRegistry() (f field.LegInstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCountryOfIssue gets LegCountryOfIssue, Tag 596 +func (m NoLegs) GetLegCountryOfIssue() (f field.LegCountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegStateOrProvinceOfIssue gets LegStateOrProvinceOfIssue, Tag 597 +func (m NoLegs) GetLegStateOrProvinceOfIssue() (f field.LegStateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegLocaleOfIssue gets LegLocaleOfIssue, Tag 598 +func (m NoLegs) GetLegLocaleOfIssue() (f field.LegLocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRedemptionDate gets LegRedemptionDate, Tag 254 +func (m NoLegs) GetLegRedemptionDate() (f field.LegRedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegStrikePrice gets LegStrikePrice, Tag 612 +func (m NoLegs) GetLegStrikePrice() (f field.LegStrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegStrikeCurrency gets LegStrikeCurrency, Tag 942 +func (m NoLegs) GetLegStrikeCurrency() (f field.LegStrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegOptAttribute gets LegOptAttribute, Tag 613 +func (m NoLegs) GetLegOptAttribute() (f field.LegOptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegContractMultiplier gets LegContractMultiplier, Tag 614 +func (m NoLegs) GetLegContractMultiplier() (f field.LegContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCouponRate gets LegCouponRate, Tag 615 +func (m NoLegs) GetLegCouponRate() (f field.LegCouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityExchange gets LegSecurityExchange, Tag 616 +func (m NoLegs) GetLegSecurityExchange() (f field.LegSecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegIssuer gets LegIssuer, Tag 617 +func (m NoLegs) GetLegIssuer() (f field.LegIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegIssuerLen gets EncodedLegIssuerLen, Tag 618 +func (m NoLegs) GetEncodedLegIssuerLen() (f field.EncodedLegIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegIssuer gets EncodedLegIssuer, Tag 619 +func (m NoLegs) GetEncodedLegIssuer() (f field.EncodedLegIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityDesc gets LegSecurityDesc, Tag 620 +func (m NoLegs) GetLegSecurityDesc() (f field.LegSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegSecurityDescLen gets EncodedLegSecurityDescLen, Tag 621 +func (m NoLegs) GetEncodedLegSecurityDescLen() (f field.EncodedLegSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegSecurityDesc gets EncodedLegSecurityDesc, Tag 622 +func (m NoLegs) GetEncodedLegSecurityDesc() (f field.EncodedLegSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRatioQty gets LegRatioQty, Tag 623 +func (m NoLegs) GetLegRatioQty() (f field.LegRatioQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSide gets LegSide, Tag 624 +func (m NoLegs) GetLegSide() (f field.LegSideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCurrency gets LegCurrency, Tag 556 +func (m NoLegs) GetLegCurrency() (f field.LegCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegPool gets LegPool, Tag 740 +func (m NoLegs) GetLegPool() (f field.LegPoolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegDatedDate gets LegDatedDate, Tag 739 +func (m NoLegs) GetLegDatedDate() (f field.LegDatedDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegContractSettlMonth gets LegContractSettlMonth, Tag 955 +func (m NoLegs) GetLegContractSettlMonth() (f field.LegContractSettlMonthField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegInterestAccrualDate gets LegInterestAccrualDate, Tag 956 +func (m NoLegs) GetLegInterestAccrualDate() (f field.LegInterestAccrualDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegUnitOfMeasure gets LegUnitOfMeasure, Tag 999 +func (m NoLegs) GetLegUnitOfMeasure() (f field.LegUnitOfMeasureField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegTimeUnit gets LegTimeUnit, Tag 1001 +func (m NoLegs) GetLegTimeUnit() (f field.LegTimeUnitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegQty gets LegQty, Tag 687 +func (m NoLegs) GetLegQty() (f field.LegQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSwapType gets LegSwapType, Tag 690 +func (m NoLegs) GetLegSwapType() (f field.LegSwapTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoLegStipulations gets NoLegStipulations, Tag 683 +func (m NoLegs) GetNoLegStipulations() (NoLegStipulationsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoLegStipulationsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetLegPositionEffect gets LegPositionEffect, Tag 564 +func (m NoLegs) GetLegPositionEffect() (f field.LegPositionEffectField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCoveredOrUncovered gets LegCoveredOrUncovered, Tag 565 +func (m NoLegs) GetLegCoveredOrUncovered() (f field.LegCoveredOrUncoveredField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoNestedPartyIDs gets NoNestedPartyIDs, Tag 539 +func (m NoLegs) GetNoNestedPartyIDs() (NoNestedPartyIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoNestedPartyIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetLegRefID gets LegRefID, Tag 654 +func (m NoLegs) GetLegRefID() (f field.LegRefIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegPrice gets LegPrice, Tag 566 +func (m NoLegs) GetLegPrice() (f field.LegPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSettlType gets LegSettlType, Tag 587 +func (m NoLegs) GetLegSettlType() (f field.LegSettlTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSettlDate gets LegSettlDate, Tag 588 +func (m NoLegs) GetLegSettlDate() (f field.LegSettlDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegLastPx gets LegLastPx, Tag 637 +func (m NoLegs) GetLegLastPx() (f field.LegLastPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegOrderQty gets LegOrderQty, Tag 685 +func (m NoLegs) GetLegOrderQty() (f field.LegOrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSettlCurrency gets LegSettlCurrency, Tag 675 +func (m NoLegs) GetLegSettlCurrency() (f field.LegSettlCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegLastForwardPoints gets LegLastForwardPoints, Tag 1073 +func (m NoLegs) GetLegLastForwardPoints() (f field.LegLastForwardPointsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCalculatedCcyLastQty gets LegCalculatedCcyLastQty, Tag 1074 +func (m NoLegs) GetLegCalculatedCcyLastQty() (f field.LegCalculatedCcyLastQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegGrossTradeAmt gets LegGrossTradeAmt, Tag 1075 +func (m NoLegs) GetLegGrossTradeAmt() (f field.LegGrossTradeAmtField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasLegSymbol returns true if LegSymbol is present, Tag 600 +func (m NoLegs) HasLegSymbol() bool { + return m.Has(tag.LegSymbol) +} + +//HasLegSymbolSfx returns true if LegSymbolSfx is present, Tag 601 +func (m NoLegs) HasLegSymbolSfx() bool { + return m.Has(tag.LegSymbolSfx) +} + +//HasLegSecurityID returns true if LegSecurityID is present, Tag 602 +func (m NoLegs) HasLegSecurityID() bool { + return m.Has(tag.LegSecurityID) +} + +//HasLegSecurityIDSource returns true if LegSecurityIDSource is present, Tag 603 +func (m NoLegs) HasLegSecurityIDSource() bool { + return m.Has(tag.LegSecurityIDSource) +} + +//HasNoLegSecurityAltID returns true if NoLegSecurityAltID is present, Tag 604 +func (m NoLegs) HasNoLegSecurityAltID() bool { + return m.Has(tag.NoLegSecurityAltID) +} + +//HasLegProduct returns true if LegProduct is present, Tag 607 +func (m NoLegs) HasLegProduct() bool { + return m.Has(tag.LegProduct) +} + +//HasLegCFICode returns true if LegCFICode is present, Tag 608 +func (m NoLegs) HasLegCFICode() bool { + return m.Has(tag.LegCFICode) +} + +//HasLegSecurityType returns true if LegSecurityType is present, Tag 609 +func (m NoLegs) HasLegSecurityType() bool { + return m.Has(tag.LegSecurityType) +} + +//HasLegSecuritySubType returns true if LegSecuritySubType is present, Tag 764 +func (m NoLegs) HasLegSecuritySubType() bool { + return m.Has(tag.LegSecuritySubType) +} + +//HasLegMaturityMonthYear returns true if LegMaturityMonthYear is present, Tag 610 +func (m NoLegs) HasLegMaturityMonthYear() bool { + return m.Has(tag.LegMaturityMonthYear) +} + +//HasLegMaturityDate returns true if LegMaturityDate is present, Tag 611 +func (m NoLegs) HasLegMaturityDate() bool { + return m.Has(tag.LegMaturityDate) +} + +//HasLegCouponPaymentDate returns true if LegCouponPaymentDate is present, Tag 248 +func (m NoLegs) HasLegCouponPaymentDate() bool { + return m.Has(tag.LegCouponPaymentDate) +} + +//HasLegIssueDate returns true if LegIssueDate is present, Tag 249 +func (m NoLegs) HasLegIssueDate() bool { + return m.Has(tag.LegIssueDate) +} + +//HasLegRepoCollateralSecurityType returns true if LegRepoCollateralSecurityType is present, Tag 250 +func (m NoLegs) HasLegRepoCollateralSecurityType() bool { + return m.Has(tag.LegRepoCollateralSecurityType) +} + +//HasLegRepurchaseTerm returns true if LegRepurchaseTerm is present, Tag 251 +func (m NoLegs) HasLegRepurchaseTerm() bool { + return m.Has(tag.LegRepurchaseTerm) +} + +//HasLegRepurchaseRate returns true if LegRepurchaseRate is present, Tag 252 +func (m NoLegs) HasLegRepurchaseRate() bool { + return m.Has(tag.LegRepurchaseRate) +} + +//HasLegFactor returns true if LegFactor is present, Tag 253 +func (m NoLegs) HasLegFactor() bool { + return m.Has(tag.LegFactor) +} + +//HasLegCreditRating returns true if LegCreditRating is present, Tag 257 +func (m NoLegs) HasLegCreditRating() bool { + return m.Has(tag.LegCreditRating) +} + +//HasLegInstrRegistry returns true if LegInstrRegistry is present, Tag 599 +func (m NoLegs) HasLegInstrRegistry() bool { + return m.Has(tag.LegInstrRegistry) +} + +//HasLegCountryOfIssue returns true if LegCountryOfIssue is present, Tag 596 +func (m NoLegs) HasLegCountryOfIssue() bool { + return m.Has(tag.LegCountryOfIssue) +} + +//HasLegStateOrProvinceOfIssue returns true if LegStateOrProvinceOfIssue is present, Tag 597 +func (m NoLegs) HasLegStateOrProvinceOfIssue() bool { + return m.Has(tag.LegStateOrProvinceOfIssue) +} + +//HasLegLocaleOfIssue returns true if LegLocaleOfIssue is present, Tag 598 +func (m NoLegs) HasLegLocaleOfIssue() bool { + return m.Has(tag.LegLocaleOfIssue) +} + +//HasLegRedemptionDate returns true if LegRedemptionDate is present, Tag 254 +func (m NoLegs) HasLegRedemptionDate() bool { + return m.Has(tag.LegRedemptionDate) +} + +//HasLegStrikePrice returns true if LegStrikePrice is present, Tag 612 +func (m NoLegs) HasLegStrikePrice() bool { + return m.Has(tag.LegStrikePrice) +} + +//HasLegStrikeCurrency returns true if LegStrikeCurrency is present, Tag 942 +func (m NoLegs) HasLegStrikeCurrency() bool { + return m.Has(tag.LegStrikeCurrency) +} + +//HasLegOptAttribute returns true if LegOptAttribute is present, Tag 613 +func (m NoLegs) HasLegOptAttribute() bool { + return m.Has(tag.LegOptAttribute) +} + +//HasLegContractMultiplier returns true if LegContractMultiplier is present, Tag 614 +func (m NoLegs) HasLegContractMultiplier() bool { + return m.Has(tag.LegContractMultiplier) +} + +//HasLegCouponRate returns true if LegCouponRate is present, Tag 615 +func (m NoLegs) HasLegCouponRate() bool { + return m.Has(tag.LegCouponRate) +} + +//HasLegSecurityExchange returns true if LegSecurityExchange is present, Tag 616 +func (m NoLegs) HasLegSecurityExchange() bool { + return m.Has(tag.LegSecurityExchange) +} + +//HasLegIssuer returns true if LegIssuer is present, Tag 617 +func (m NoLegs) HasLegIssuer() bool { + return m.Has(tag.LegIssuer) +} + +//HasEncodedLegIssuerLen returns true if EncodedLegIssuerLen is present, Tag 618 +func (m NoLegs) HasEncodedLegIssuerLen() bool { + return m.Has(tag.EncodedLegIssuerLen) +} + +//HasEncodedLegIssuer returns true if EncodedLegIssuer is present, Tag 619 +func (m NoLegs) HasEncodedLegIssuer() bool { + return m.Has(tag.EncodedLegIssuer) +} + +//HasLegSecurityDesc returns true if LegSecurityDesc is present, Tag 620 +func (m NoLegs) HasLegSecurityDesc() bool { + return m.Has(tag.LegSecurityDesc) +} + +//HasEncodedLegSecurityDescLen returns true if EncodedLegSecurityDescLen is present, Tag 621 +func (m NoLegs) HasEncodedLegSecurityDescLen() bool { + return m.Has(tag.EncodedLegSecurityDescLen) +} + +//HasEncodedLegSecurityDesc returns true if EncodedLegSecurityDesc is present, Tag 622 +func (m NoLegs) HasEncodedLegSecurityDesc() bool { + return m.Has(tag.EncodedLegSecurityDesc) +} + +//HasLegRatioQty returns true if LegRatioQty is present, Tag 623 +func (m NoLegs) HasLegRatioQty() bool { + return m.Has(tag.LegRatioQty) +} + +//HasLegSide returns true if LegSide is present, Tag 624 +func (m NoLegs) HasLegSide() bool { + return m.Has(tag.LegSide) +} + +//HasLegCurrency returns true if LegCurrency is present, Tag 556 +func (m NoLegs) HasLegCurrency() bool { + return m.Has(tag.LegCurrency) +} + +//HasLegPool returns true if LegPool is present, Tag 740 +func (m NoLegs) HasLegPool() bool { + return m.Has(tag.LegPool) +} + +//HasLegDatedDate returns true if LegDatedDate is present, Tag 739 +func (m NoLegs) HasLegDatedDate() bool { + return m.Has(tag.LegDatedDate) +} + +//HasLegContractSettlMonth returns true if LegContractSettlMonth is present, Tag 955 +func (m NoLegs) HasLegContractSettlMonth() bool { + return m.Has(tag.LegContractSettlMonth) +} + +//HasLegInterestAccrualDate returns true if LegInterestAccrualDate is present, Tag 956 +func (m NoLegs) HasLegInterestAccrualDate() bool { + return m.Has(tag.LegInterestAccrualDate) +} + +//HasLegUnitOfMeasure returns true if LegUnitOfMeasure is present, Tag 999 +func (m NoLegs) HasLegUnitOfMeasure() bool { + return m.Has(tag.LegUnitOfMeasure) +} + +//HasLegTimeUnit returns true if LegTimeUnit is present, Tag 1001 +func (m NoLegs) HasLegTimeUnit() bool { + return m.Has(tag.LegTimeUnit) +} + +//HasLegQty returns true if LegQty is present, Tag 687 +func (m NoLegs) HasLegQty() bool { + return m.Has(tag.LegQty) +} + +//HasLegSwapType returns true if LegSwapType is present, Tag 690 +func (m NoLegs) HasLegSwapType() bool { + return m.Has(tag.LegSwapType) +} + +//HasNoLegStipulations returns true if NoLegStipulations is present, Tag 683 +func (m NoLegs) HasNoLegStipulations() bool { + return m.Has(tag.NoLegStipulations) +} + +//HasLegPositionEffect returns true if LegPositionEffect is present, Tag 564 +func (m NoLegs) HasLegPositionEffect() bool { + return m.Has(tag.LegPositionEffect) +} + +//HasLegCoveredOrUncovered returns true if LegCoveredOrUncovered is present, Tag 565 +func (m NoLegs) HasLegCoveredOrUncovered() bool { + return m.Has(tag.LegCoveredOrUncovered) +} + +//HasNoNestedPartyIDs returns true if NoNestedPartyIDs is present, Tag 539 +func (m NoLegs) HasNoNestedPartyIDs() bool { + return m.Has(tag.NoNestedPartyIDs) +} + +//HasLegRefID returns true if LegRefID is present, Tag 654 +func (m NoLegs) HasLegRefID() bool { + return m.Has(tag.LegRefID) +} + +//HasLegPrice returns true if LegPrice is present, Tag 566 +func (m NoLegs) HasLegPrice() bool { + return m.Has(tag.LegPrice) +} + +//HasLegSettlType returns true if LegSettlType is present, Tag 587 +func (m NoLegs) HasLegSettlType() bool { + return m.Has(tag.LegSettlType) +} + +//HasLegSettlDate returns true if LegSettlDate is present, Tag 588 +func (m NoLegs) HasLegSettlDate() bool { + return m.Has(tag.LegSettlDate) +} + +//HasLegLastPx returns true if LegLastPx is present, Tag 637 +func (m NoLegs) HasLegLastPx() bool { + return m.Has(tag.LegLastPx) +} + +//HasLegOrderQty returns true if LegOrderQty is present, Tag 685 +func (m NoLegs) HasLegOrderQty() bool { + return m.Has(tag.LegOrderQty) +} + +//HasLegSettlCurrency returns true if LegSettlCurrency is present, Tag 675 +func (m NoLegs) HasLegSettlCurrency() bool { + return m.Has(tag.LegSettlCurrency) +} + +//HasLegLastForwardPoints returns true if LegLastForwardPoints is present, Tag 1073 +func (m NoLegs) HasLegLastForwardPoints() bool { + return m.Has(tag.LegLastForwardPoints) +} + +//HasLegCalculatedCcyLastQty returns true if LegCalculatedCcyLastQty is present, Tag 1074 +func (m NoLegs) HasLegCalculatedCcyLastQty() bool { + return m.Has(tag.LegCalculatedCcyLastQty) +} + +//HasLegGrossTradeAmt returns true if LegGrossTradeAmt is present, Tag 1075 +func (m NoLegs) HasLegGrossTradeAmt() bool { + return m.Has(tag.LegGrossTradeAmt) +} + +//NoLegSecurityAltID is a repeating group element, Tag 604 +type NoLegSecurityAltID struct { + quickfix.Group +} + +//SetLegSecurityAltID sets LegSecurityAltID, Tag 605 +func (m NoLegSecurityAltID) SetLegSecurityAltID(v string) { + m.Set(field.NewLegSecurityAltID(v)) +} + +//SetLegSecurityAltIDSource sets LegSecurityAltIDSource, Tag 606 +func (m NoLegSecurityAltID) SetLegSecurityAltIDSource(v string) { + m.Set(field.NewLegSecurityAltIDSource(v)) +} + +//GetLegSecurityAltID gets LegSecurityAltID, Tag 605 +func (m NoLegSecurityAltID) GetLegSecurityAltID() (f field.LegSecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityAltIDSource gets LegSecurityAltIDSource, Tag 606 +func (m NoLegSecurityAltID) GetLegSecurityAltIDSource() (f field.LegSecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasLegSecurityAltID returns true if LegSecurityAltID is present, Tag 605 +func (m NoLegSecurityAltID) HasLegSecurityAltID() bool { + return m.Has(tag.LegSecurityAltID) +} + +//HasLegSecurityAltIDSource returns true if LegSecurityAltIDSource is present, Tag 606 +func (m NoLegSecurityAltID) HasLegSecurityAltIDSource() bool { + return m.Has(tag.LegSecurityAltIDSource) +} + +//NoLegSecurityAltIDRepeatingGroup is a repeating group, Tag 604 +type NoLegSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoLegSecurityAltIDRepeatingGroup returns an initialized, NoLegSecurityAltIDRepeatingGroup +func NewNoLegSecurityAltIDRepeatingGroup() NoLegSecurityAltIDRepeatingGroup { + return NoLegSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoLegSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.LegSecurityAltID), quickfix.GroupElement(tag.LegSecurityAltIDSource)})} +} + +//Add create and append a new NoLegSecurityAltID to this group +func (m NoLegSecurityAltIDRepeatingGroup) Add() NoLegSecurityAltID { + g := m.RepeatingGroup.Add() + return NoLegSecurityAltID{g} +} + +//Get returns the ith NoLegSecurityAltID in the NoLegSecurityAltIDRepeatinGroup +func (m NoLegSecurityAltIDRepeatingGroup) Get(i int) NoLegSecurityAltID { + return NoLegSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoLegStipulations is a repeating group element, Tag 683 +type NoLegStipulations struct { + quickfix.Group +} + +//SetLegStipulationType sets LegStipulationType, Tag 688 +func (m NoLegStipulations) SetLegStipulationType(v string) { + m.Set(field.NewLegStipulationType(v)) +} + +//SetLegStipulationValue sets LegStipulationValue, Tag 689 +func (m NoLegStipulations) SetLegStipulationValue(v string) { + m.Set(field.NewLegStipulationValue(v)) +} + +//GetLegStipulationType gets LegStipulationType, Tag 688 +func (m NoLegStipulations) GetLegStipulationType() (f field.LegStipulationTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegStipulationValue gets LegStipulationValue, Tag 689 +func (m NoLegStipulations) GetLegStipulationValue() (f field.LegStipulationValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasLegStipulationType returns true if LegStipulationType is present, Tag 688 +func (m NoLegStipulations) HasLegStipulationType() bool { + return m.Has(tag.LegStipulationType) +} + +//HasLegStipulationValue returns true if LegStipulationValue is present, Tag 689 +func (m NoLegStipulations) HasLegStipulationValue() bool { + return m.Has(tag.LegStipulationValue) +} + +//NoLegStipulationsRepeatingGroup is a repeating group, Tag 683 +type NoLegStipulationsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoLegStipulationsRepeatingGroup returns an initialized, NoLegStipulationsRepeatingGroup +func NewNoLegStipulationsRepeatingGroup() NoLegStipulationsRepeatingGroup { + return NoLegStipulationsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoLegStipulations, + quickfix.GroupTemplate{quickfix.GroupElement(tag.LegStipulationType), quickfix.GroupElement(tag.LegStipulationValue)})} +} + +//Add create and append a new NoLegStipulations to this group +func (m NoLegStipulationsRepeatingGroup) Add() NoLegStipulations { + g := m.RepeatingGroup.Add() + return NoLegStipulations{g} +} + +//Get returns the ith NoLegStipulations in the NoLegStipulationsRepeatinGroup +func (m NoLegStipulationsRepeatingGroup) Get(i int) NoLegStipulations { + return NoLegStipulations{m.RepeatingGroup.Get(i)} +} + +//NoNestedPartyIDs is a repeating group element, Tag 539 +type NoNestedPartyIDs struct { + quickfix.Group +} + +//SetNestedPartyID sets NestedPartyID, Tag 524 +func (m NoNestedPartyIDs) SetNestedPartyID(v string) { + m.Set(field.NewNestedPartyID(v)) +} + +//SetNestedPartyIDSource sets NestedPartyIDSource, Tag 525 +func (m NoNestedPartyIDs) SetNestedPartyIDSource(v string) { + m.Set(field.NewNestedPartyIDSource(v)) +} + +//SetNestedPartyRole sets NestedPartyRole, Tag 538 +func (m NoNestedPartyIDs) SetNestedPartyRole(v int) { + m.Set(field.NewNestedPartyRole(v)) +} + +//SetNoNestedPartySubIDs sets NoNestedPartySubIDs, Tag 804 +func (m NoNestedPartyIDs) SetNoNestedPartySubIDs(f NoNestedPartySubIDsRepeatingGroup) { + m.SetGroup(f) +} + +//GetNestedPartyID gets NestedPartyID, Tag 524 +func (m NoNestedPartyIDs) GetNestedPartyID() (f field.NestedPartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNestedPartyIDSource gets NestedPartyIDSource, Tag 525 +func (m NoNestedPartyIDs) GetNestedPartyIDSource() (f field.NestedPartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNestedPartyRole gets NestedPartyRole, Tag 538 +func (m NoNestedPartyIDs) GetNestedPartyRole() (f field.NestedPartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoNestedPartySubIDs gets NoNestedPartySubIDs, Tag 804 +func (m NoNestedPartyIDs) GetNoNestedPartySubIDs() (NoNestedPartySubIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoNestedPartySubIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasNestedPartyID returns true if NestedPartyID is present, Tag 524 +func (m NoNestedPartyIDs) HasNestedPartyID() bool { + return m.Has(tag.NestedPartyID) +} + +//HasNestedPartyIDSource returns true if NestedPartyIDSource is present, Tag 525 +func (m NoNestedPartyIDs) HasNestedPartyIDSource() bool { + return m.Has(tag.NestedPartyIDSource) +} + +//HasNestedPartyRole returns true if NestedPartyRole is present, Tag 538 +func (m NoNestedPartyIDs) HasNestedPartyRole() bool { + return m.Has(tag.NestedPartyRole) +} + +//HasNoNestedPartySubIDs returns true if NoNestedPartySubIDs is present, Tag 804 +func (m NoNestedPartyIDs) HasNoNestedPartySubIDs() bool { + return m.Has(tag.NoNestedPartySubIDs) +} + +//NoNestedPartySubIDs is a repeating group element, Tag 804 +type NoNestedPartySubIDs struct { + quickfix.Group +} + +//SetNestedPartySubID sets NestedPartySubID, Tag 545 +func (m NoNestedPartySubIDs) SetNestedPartySubID(v string) { + m.Set(field.NewNestedPartySubID(v)) +} + +//SetNestedPartySubIDType sets NestedPartySubIDType, Tag 805 +func (m NoNestedPartySubIDs) SetNestedPartySubIDType(v int) { + m.Set(field.NewNestedPartySubIDType(v)) +} + +//GetNestedPartySubID gets NestedPartySubID, Tag 545 +func (m NoNestedPartySubIDs) GetNestedPartySubID() (f field.NestedPartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNestedPartySubIDType gets NestedPartySubIDType, Tag 805 +func (m NoNestedPartySubIDs) GetNestedPartySubIDType() (f field.NestedPartySubIDTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasNestedPartySubID returns true if NestedPartySubID is present, Tag 545 +func (m NoNestedPartySubIDs) HasNestedPartySubID() bool { + return m.Has(tag.NestedPartySubID) +} + +//HasNestedPartySubIDType returns true if NestedPartySubIDType is present, Tag 805 +func (m NoNestedPartySubIDs) HasNestedPartySubIDType() bool { + return m.Has(tag.NestedPartySubIDType) +} + +//NoNestedPartySubIDsRepeatingGroup is a repeating group, Tag 804 +type NoNestedPartySubIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoNestedPartySubIDsRepeatingGroup returns an initialized, NoNestedPartySubIDsRepeatingGroup +func NewNoNestedPartySubIDsRepeatingGroup() NoNestedPartySubIDsRepeatingGroup { + return NoNestedPartySubIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoNestedPartySubIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.NestedPartySubID), quickfix.GroupElement(tag.NestedPartySubIDType)})} +} + +//Add create and append a new NoNestedPartySubIDs to this group +func (m NoNestedPartySubIDsRepeatingGroup) Add() NoNestedPartySubIDs { + g := m.RepeatingGroup.Add() + return NoNestedPartySubIDs{g} +} + +//Get returns the ith NoNestedPartySubIDs in the NoNestedPartySubIDsRepeatinGroup +func (m NoNestedPartySubIDsRepeatingGroup) Get(i int) NoNestedPartySubIDs { + return NoNestedPartySubIDs{m.RepeatingGroup.Get(i)} +} + +//NoNestedPartyIDsRepeatingGroup is a repeating group, Tag 539 +type NoNestedPartyIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoNestedPartyIDsRepeatingGroup returns an initialized, NoNestedPartyIDsRepeatingGroup +func NewNoNestedPartyIDsRepeatingGroup() NoNestedPartyIDsRepeatingGroup { + return NoNestedPartyIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoNestedPartyIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.NestedPartyID), quickfix.GroupElement(tag.NestedPartyIDSource), quickfix.GroupElement(tag.NestedPartyRole), NewNoNestedPartySubIDsRepeatingGroup()})} +} + +//Add create and append a new NoNestedPartyIDs to this group +func (m NoNestedPartyIDsRepeatingGroup) Add() NoNestedPartyIDs { + g := m.RepeatingGroup.Add() + return NoNestedPartyIDs{g} +} + +//Get returns the ith NoNestedPartyIDs in the NoNestedPartyIDsRepeatinGroup +func (m NoNestedPartyIDsRepeatingGroup) Get(i int) NoNestedPartyIDs { + return NoNestedPartyIDs{m.RepeatingGroup.Get(i)} +} + +//NoLegsRepeatingGroup is a repeating group, Tag 555 +type NoLegsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoLegsRepeatingGroup returns an initialized, NoLegsRepeatingGroup +func NewNoLegsRepeatingGroup() NoLegsRepeatingGroup { + return NoLegsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoLegs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.LegSymbol), quickfix.GroupElement(tag.LegSymbolSfx), quickfix.GroupElement(tag.LegSecurityID), quickfix.GroupElement(tag.LegSecurityIDSource), NewNoLegSecurityAltIDRepeatingGroup(), quickfix.GroupElement(tag.LegProduct), quickfix.GroupElement(tag.LegCFICode), quickfix.GroupElement(tag.LegSecurityType), quickfix.GroupElement(tag.LegSecuritySubType), quickfix.GroupElement(tag.LegMaturityMonthYear), quickfix.GroupElement(tag.LegMaturityDate), quickfix.GroupElement(tag.LegCouponPaymentDate), quickfix.GroupElement(tag.LegIssueDate), quickfix.GroupElement(tag.LegRepoCollateralSecurityType), quickfix.GroupElement(tag.LegRepurchaseTerm), quickfix.GroupElement(tag.LegRepurchaseRate), quickfix.GroupElement(tag.LegFactor), quickfix.GroupElement(tag.LegCreditRating), quickfix.GroupElement(tag.LegInstrRegistry), quickfix.GroupElement(tag.LegCountryOfIssue), quickfix.GroupElement(tag.LegStateOrProvinceOfIssue), quickfix.GroupElement(tag.LegLocaleOfIssue), quickfix.GroupElement(tag.LegRedemptionDate), quickfix.GroupElement(tag.LegStrikePrice), quickfix.GroupElement(tag.LegStrikeCurrency), quickfix.GroupElement(tag.LegOptAttribute), quickfix.GroupElement(tag.LegContractMultiplier), quickfix.GroupElement(tag.LegCouponRate), quickfix.GroupElement(tag.LegSecurityExchange), quickfix.GroupElement(tag.LegIssuer), quickfix.GroupElement(tag.EncodedLegIssuerLen), quickfix.GroupElement(tag.EncodedLegIssuer), quickfix.GroupElement(tag.LegSecurityDesc), quickfix.GroupElement(tag.EncodedLegSecurityDescLen), quickfix.GroupElement(tag.EncodedLegSecurityDesc), quickfix.GroupElement(tag.LegRatioQty), quickfix.GroupElement(tag.LegSide), quickfix.GroupElement(tag.LegCurrency), quickfix.GroupElement(tag.LegPool), quickfix.GroupElement(tag.LegDatedDate), quickfix.GroupElement(tag.LegContractSettlMonth), quickfix.GroupElement(tag.LegInterestAccrualDate), quickfix.GroupElement(tag.LegUnitOfMeasure), quickfix.GroupElement(tag.LegTimeUnit), quickfix.GroupElement(tag.LegQty), quickfix.GroupElement(tag.LegSwapType), NewNoLegStipulationsRepeatingGroup(), quickfix.GroupElement(tag.LegPositionEffect), quickfix.GroupElement(tag.LegCoveredOrUncovered), NewNoNestedPartyIDsRepeatingGroup(), quickfix.GroupElement(tag.LegRefID), quickfix.GroupElement(tag.LegPrice), quickfix.GroupElement(tag.LegSettlType), quickfix.GroupElement(tag.LegSettlDate), quickfix.GroupElement(tag.LegLastPx), quickfix.GroupElement(tag.LegOrderQty), quickfix.GroupElement(tag.LegSettlCurrency), quickfix.GroupElement(tag.LegLastForwardPoints), quickfix.GroupElement(tag.LegCalculatedCcyLastQty), quickfix.GroupElement(tag.LegGrossTradeAmt)})} +} + +//Add create and append a new NoLegs to this group +func (m NoLegsRepeatingGroup) Add() NoLegs { + g := m.RepeatingGroup.Add() + return NoLegs{g} +} + +//Get returns the ith NoLegs in the NoLegsRepeatinGroup +func (m NoLegsRepeatingGroup) Get(i int) NoLegs { + return NoLegs{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyings is a repeating group element, Tag 711 +type NoUnderlyings struct { + quickfix.Group +} + +//SetUnderlyingSymbol sets UnderlyingSymbol, Tag 311 +func (m NoUnderlyings) SetUnderlyingSymbol(v string) { + m.Set(field.NewUnderlyingSymbol(v)) +} + +//SetUnderlyingSymbolSfx sets UnderlyingSymbolSfx, Tag 312 +func (m NoUnderlyings) SetUnderlyingSymbolSfx(v string) { + m.Set(field.NewUnderlyingSymbolSfx(v)) +} + +//SetUnderlyingSecurityID sets UnderlyingSecurityID, Tag 309 +func (m NoUnderlyings) SetUnderlyingSecurityID(v string) { + m.Set(field.NewUnderlyingSecurityID(v)) +} + +//SetUnderlyingSecurityIDSource sets UnderlyingSecurityIDSource, Tag 305 +func (m NoUnderlyings) SetUnderlyingSecurityIDSource(v string) { + m.Set(field.NewUnderlyingSecurityIDSource(v)) +} + +//SetNoUnderlyingSecurityAltID sets NoUnderlyingSecurityAltID, Tag 457 +func (m NoUnderlyings) SetNoUnderlyingSecurityAltID(f NoUnderlyingSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetUnderlyingProduct sets UnderlyingProduct, Tag 462 +func (m NoUnderlyings) SetUnderlyingProduct(v int) { + m.Set(field.NewUnderlyingProduct(v)) +} + +//SetUnderlyingCFICode sets UnderlyingCFICode, Tag 463 +func (m NoUnderlyings) SetUnderlyingCFICode(v string) { + m.Set(field.NewUnderlyingCFICode(v)) +} + +//SetUnderlyingSecurityType sets UnderlyingSecurityType, Tag 310 +func (m NoUnderlyings) SetUnderlyingSecurityType(v string) { + m.Set(field.NewUnderlyingSecurityType(v)) +} + +//SetUnderlyingSecuritySubType sets UnderlyingSecuritySubType, Tag 763 +func (m NoUnderlyings) SetUnderlyingSecuritySubType(v string) { + m.Set(field.NewUnderlyingSecuritySubType(v)) +} + +//SetUnderlyingMaturityMonthYear sets UnderlyingMaturityMonthYear, Tag 313 +func (m NoUnderlyings) SetUnderlyingMaturityMonthYear(v string) { + m.Set(field.NewUnderlyingMaturityMonthYear(v)) +} + +//SetUnderlyingMaturityDate sets UnderlyingMaturityDate, Tag 542 +func (m NoUnderlyings) SetUnderlyingMaturityDate(v string) { + m.Set(field.NewUnderlyingMaturityDate(v)) +} + +//SetUnderlyingCouponPaymentDate sets UnderlyingCouponPaymentDate, Tag 241 +func (m NoUnderlyings) SetUnderlyingCouponPaymentDate(v string) { + m.Set(field.NewUnderlyingCouponPaymentDate(v)) +} + +//SetUnderlyingIssueDate sets UnderlyingIssueDate, Tag 242 +func (m NoUnderlyings) SetUnderlyingIssueDate(v string) { + m.Set(field.NewUnderlyingIssueDate(v)) +} + +//SetUnderlyingRepoCollateralSecurityType sets UnderlyingRepoCollateralSecurityType, Tag 243 +func (m NoUnderlyings) SetUnderlyingRepoCollateralSecurityType(v int) { + m.Set(field.NewUnderlyingRepoCollateralSecurityType(v)) +} + +//SetUnderlyingRepurchaseTerm sets UnderlyingRepurchaseTerm, Tag 244 +func (m NoUnderlyings) SetUnderlyingRepurchaseTerm(v int) { + m.Set(field.NewUnderlyingRepurchaseTerm(v)) +} + +//SetUnderlyingRepurchaseRate sets UnderlyingRepurchaseRate, Tag 245 +func (m NoUnderlyings) SetUnderlyingRepurchaseRate(v float64) { + m.Set(field.NewUnderlyingRepurchaseRate(v)) +} + +//SetUnderlyingFactor sets UnderlyingFactor, Tag 246 +func (m NoUnderlyings) SetUnderlyingFactor(v float64) { + m.Set(field.NewUnderlyingFactor(v)) +} + +//SetUnderlyingCreditRating sets UnderlyingCreditRating, Tag 256 +func (m NoUnderlyings) SetUnderlyingCreditRating(v string) { + m.Set(field.NewUnderlyingCreditRating(v)) +} + +//SetUnderlyingInstrRegistry sets UnderlyingInstrRegistry, Tag 595 +func (m NoUnderlyings) SetUnderlyingInstrRegistry(v string) { + m.Set(field.NewUnderlyingInstrRegistry(v)) +} + +//SetUnderlyingCountryOfIssue sets UnderlyingCountryOfIssue, Tag 592 +func (m NoUnderlyings) SetUnderlyingCountryOfIssue(v string) { + m.Set(field.NewUnderlyingCountryOfIssue(v)) +} + +//SetUnderlyingStateOrProvinceOfIssue sets UnderlyingStateOrProvinceOfIssue, Tag 593 +func (m NoUnderlyings) SetUnderlyingStateOrProvinceOfIssue(v string) { + m.Set(field.NewUnderlyingStateOrProvinceOfIssue(v)) +} + +//SetUnderlyingLocaleOfIssue sets UnderlyingLocaleOfIssue, Tag 594 +func (m NoUnderlyings) SetUnderlyingLocaleOfIssue(v string) { + m.Set(field.NewUnderlyingLocaleOfIssue(v)) +} + +//SetUnderlyingRedemptionDate sets UnderlyingRedemptionDate, Tag 247 +func (m NoUnderlyings) SetUnderlyingRedemptionDate(v string) { + m.Set(field.NewUnderlyingRedemptionDate(v)) +} + +//SetUnderlyingStrikePrice sets UnderlyingStrikePrice, Tag 316 +func (m NoUnderlyings) SetUnderlyingStrikePrice(v float64) { + m.Set(field.NewUnderlyingStrikePrice(v)) +} + +//SetUnderlyingStrikeCurrency sets UnderlyingStrikeCurrency, Tag 941 +func (m NoUnderlyings) SetUnderlyingStrikeCurrency(v string) { + m.Set(field.NewUnderlyingStrikeCurrency(v)) +} + +//SetUnderlyingOptAttribute sets UnderlyingOptAttribute, Tag 317 +func (m NoUnderlyings) SetUnderlyingOptAttribute(v string) { + m.Set(field.NewUnderlyingOptAttribute(v)) +} + +//SetUnderlyingContractMultiplier sets UnderlyingContractMultiplier, Tag 436 +func (m NoUnderlyings) SetUnderlyingContractMultiplier(v float64) { + m.Set(field.NewUnderlyingContractMultiplier(v)) +} + +//SetUnderlyingCouponRate sets UnderlyingCouponRate, Tag 435 +func (m NoUnderlyings) SetUnderlyingCouponRate(v float64) { + m.Set(field.NewUnderlyingCouponRate(v)) +} + +//SetUnderlyingSecurityExchange sets UnderlyingSecurityExchange, Tag 308 +func (m NoUnderlyings) SetUnderlyingSecurityExchange(v string) { + m.Set(field.NewUnderlyingSecurityExchange(v)) +} + +//SetUnderlyingIssuer sets UnderlyingIssuer, Tag 306 +func (m NoUnderlyings) SetUnderlyingIssuer(v string) { + m.Set(field.NewUnderlyingIssuer(v)) +} + +//SetEncodedUnderlyingIssuerLen sets EncodedUnderlyingIssuerLen, Tag 362 +func (m NoUnderlyings) SetEncodedUnderlyingIssuerLen(v int) { + m.Set(field.NewEncodedUnderlyingIssuerLen(v)) +} + +//SetEncodedUnderlyingIssuer sets EncodedUnderlyingIssuer, Tag 363 +func (m NoUnderlyings) SetEncodedUnderlyingIssuer(v string) { + m.Set(field.NewEncodedUnderlyingIssuer(v)) +} + +//SetUnderlyingSecurityDesc sets UnderlyingSecurityDesc, Tag 307 +func (m NoUnderlyings) SetUnderlyingSecurityDesc(v string) { + m.Set(field.NewUnderlyingSecurityDesc(v)) +} + +//SetEncodedUnderlyingSecurityDescLen sets EncodedUnderlyingSecurityDescLen, Tag 364 +func (m NoUnderlyings) SetEncodedUnderlyingSecurityDescLen(v int) { + m.Set(field.NewEncodedUnderlyingSecurityDescLen(v)) +} + +//SetEncodedUnderlyingSecurityDesc sets EncodedUnderlyingSecurityDesc, Tag 365 +func (m NoUnderlyings) SetEncodedUnderlyingSecurityDesc(v string) { + m.Set(field.NewEncodedUnderlyingSecurityDesc(v)) +} + +//SetUnderlyingCPProgram sets UnderlyingCPProgram, Tag 877 +func (m NoUnderlyings) SetUnderlyingCPProgram(v string) { + m.Set(field.NewUnderlyingCPProgram(v)) +} + +//SetUnderlyingCPRegType sets UnderlyingCPRegType, Tag 878 +func (m NoUnderlyings) SetUnderlyingCPRegType(v string) { + m.Set(field.NewUnderlyingCPRegType(v)) +} + +//SetUnderlyingCurrency sets UnderlyingCurrency, Tag 318 +func (m NoUnderlyings) SetUnderlyingCurrency(v string) { + m.Set(field.NewUnderlyingCurrency(v)) +} + +//SetUnderlyingQty sets UnderlyingQty, Tag 879 +func (m NoUnderlyings) SetUnderlyingQty(v float64) { + m.Set(field.NewUnderlyingQty(v)) +} + +//SetUnderlyingPx sets UnderlyingPx, Tag 810 +func (m NoUnderlyings) SetUnderlyingPx(v float64) { + m.Set(field.NewUnderlyingPx(v)) +} + +//SetUnderlyingDirtyPrice sets UnderlyingDirtyPrice, Tag 882 +func (m NoUnderlyings) SetUnderlyingDirtyPrice(v float64) { + m.Set(field.NewUnderlyingDirtyPrice(v)) +} + +//SetUnderlyingEndPrice sets UnderlyingEndPrice, Tag 883 +func (m NoUnderlyings) SetUnderlyingEndPrice(v float64) { + m.Set(field.NewUnderlyingEndPrice(v)) +} + +//SetUnderlyingStartValue sets UnderlyingStartValue, Tag 884 +func (m NoUnderlyings) SetUnderlyingStartValue(v float64) { + m.Set(field.NewUnderlyingStartValue(v)) +} + +//SetUnderlyingCurrentValue sets UnderlyingCurrentValue, Tag 885 +func (m NoUnderlyings) SetUnderlyingCurrentValue(v float64) { + m.Set(field.NewUnderlyingCurrentValue(v)) +} + +//SetUnderlyingEndValue sets UnderlyingEndValue, Tag 886 +func (m NoUnderlyings) SetUnderlyingEndValue(v float64) { + m.Set(field.NewUnderlyingEndValue(v)) +} + +//SetNoUnderlyingStips sets NoUnderlyingStips, Tag 887 +func (m NoUnderlyings) SetNoUnderlyingStips(f NoUnderlyingStipsRepeatingGroup) { + m.SetGroup(f) +} + +//SetUnderlyingAllocationPercent sets UnderlyingAllocationPercent, Tag 972 +func (m NoUnderlyings) SetUnderlyingAllocationPercent(v float64) { + m.Set(field.NewUnderlyingAllocationPercent(v)) +} + +//SetUnderlyingSettlementType sets UnderlyingSettlementType, Tag 975 +func (m NoUnderlyings) SetUnderlyingSettlementType(v int) { + m.Set(field.NewUnderlyingSettlementType(v)) +} + +//SetUnderlyingCashAmount sets UnderlyingCashAmount, Tag 973 +func (m NoUnderlyings) SetUnderlyingCashAmount(v float64) { + m.Set(field.NewUnderlyingCashAmount(v)) +} + +//SetUnderlyingCashType sets UnderlyingCashType, Tag 974 +func (m NoUnderlyings) SetUnderlyingCashType(v string) { + m.Set(field.NewUnderlyingCashType(v)) +} + +//SetUnderlyingUnitOfMeasure sets UnderlyingUnitOfMeasure, Tag 998 +func (m NoUnderlyings) SetUnderlyingUnitOfMeasure(v string) { + m.Set(field.NewUnderlyingUnitOfMeasure(v)) +} + +//SetUnderlyingTimeUnit sets UnderlyingTimeUnit, Tag 1000 +func (m NoUnderlyings) SetUnderlyingTimeUnit(v string) { + m.Set(field.NewUnderlyingTimeUnit(v)) +} + +//SetUnderlyingCapValue sets UnderlyingCapValue, Tag 1038 +func (m NoUnderlyings) SetUnderlyingCapValue(v float64) { + m.Set(field.NewUnderlyingCapValue(v)) +} + +//SetNoUndlyInstrumentParties sets NoUndlyInstrumentParties, Tag 1058 +func (m NoUnderlyings) SetNoUndlyInstrumentParties(f NoUndlyInstrumentPartiesRepeatingGroup) { + m.SetGroup(f) +} + +//SetUnderlyingSettlMethod sets UnderlyingSettlMethod, Tag 1039 +func (m NoUnderlyings) SetUnderlyingSettlMethod(v string) { + m.Set(field.NewUnderlyingSettlMethod(v)) +} + +//SetUnderlyingAdjustedQuantity sets UnderlyingAdjustedQuantity, Tag 1044 +func (m NoUnderlyings) SetUnderlyingAdjustedQuantity(v float64) { + m.Set(field.NewUnderlyingAdjustedQuantity(v)) +} + +//SetUnderlyingFXRate sets UnderlyingFXRate, Tag 1045 +func (m NoUnderlyings) SetUnderlyingFXRate(v float64) { + m.Set(field.NewUnderlyingFXRate(v)) +} + +//SetUnderlyingFXRateCalc sets UnderlyingFXRateCalc, Tag 1046 +func (m NoUnderlyings) SetUnderlyingFXRateCalc(v string) { + m.Set(field.NewUnderlyingFXRateCalc(v)) +} + +//GetUnderlyingSymbol gets UnderlyingSymbol, Tag 311 +func (m NoUnderlyings) GetUnderlyingSymbol() (f field.UnderlyingSymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSymbolSfx gets UnderlyingSymbolSfx, Tag 312 +func (m NoUnderlyings) GetUnderlyingSymbolSfx() (f field.UnderlyingSymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityID gets UnderlyingSecurityID, Tag 309 +func (m NoUnderlyings) GetUnderlyingSecurityID() (f field.UnderlyingSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityIDSource gets UnderlyingSecurityIDSource, Tag 305 +func (m NoUnderlyings) GetUnderlyingSecurityIDSource() (f field.UnderlyingSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyingSecurityAltID gets NoUnderlyingSecurityAltID, Tag 457 +func (m NoUnderlyings) GetNoUnderlyingSecurityAltID() (NoUnderlyingSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetUnderlyingProduct gets UnderlyingProduct, Tag 462 +func (m NoUnderlyings) GetUnderlyingProduct() (f field.UnderlyingProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCFICode gets UnderlyingCFICode, Tag 463 +func (m NoUnderlyings) GetUnderlyingCFICode() (f field.UnderlyingCFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityType gets UnderlyingSecurityType, Tag 310 +func (m NoUnderlyings) GetUnderlyingSecurityType() (f field.UnderlyingSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecuritySubType gets UnderlyingSecuritySubType, Tag 763 +func (m NoUnderlyings) GetUnderlyingSecuritySubType() (f field.UnderlyingSecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingMaturityMonthYear gets UnderlyingMaturityMonthYear, Tag 313 +func (m NoUnderlyings) GetUnderlyingMaturityMonthYear() (f field.UnderlyingMaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingMaturityDate gets UnderlyingMaturityDate, Tag 542 +func (m NoUnderlyings) GetUnderlyingMaturityDate() (f field.UnderlyingMaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCouponPaymentDate gets UnderlyingCouponPaymentDate, Tag 241 +func (m NoUnderlyings) GetUnderlyingCouponPaymentDate() (f field.UnderlyingCouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingIssueDate gets UnderlyingIssueDate, Tag 242 +func (m NoUnderlyings) GetUnderlyingIssueDate() (f field.UnderlyingIssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepoCollateralSecurityType gets UnderlyingRepoCollateralSecurityType, Tag 243 +func (m NoUnderlyings) GetUnderlyingRepoCollateralSecurityType() (f field.UnderlyingRepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepurchaseTerm gets UnderlyingRepurchaseTerm, Tag 244 +func (m NoUnderlyings) GetUnderlyingRepurchaseTerm() (f field.UnderlyingRepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepurchaseRate gets UnderlyingRepurchaseRate, Tag 245 +func (m NoUnderlyings) GetUnderlyingRepurchaseRate() (f field.UnderlyingRepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingFactor gets UnderlyingFactor, Tag 246 +func (m NoUnderlyings) GetUnderlyingFactor() (f field.UnderlyingFactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCreditRating gets UnderlyingCreditRating, Tag 256 +func (m NoUnderlyings) GetUnderlyingCreditRating() (f field.UnderlyingCreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingInstrRegistry gets UnderlyingInstrRegistry, Tag 595 +func (m NoUnderlyings) GetUnderlyingInstrRegistry() (f field.UnderlyingInstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCountryOfIssue gets UnderlyingCountryOfIssue, Tag 592 +func (m NoUnderlyings) GetUnderlyingCountryOfIssue() (f field.UnderlyingCountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStateOrProvinceOfIssue gets UnderlyingStateOrProvinceOfIssue, Tag 593 +func (m NoUnderlyings) GetUnderlyingStateOrProvinceOfIssue() (f field.UnderlyingStateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingLocaleOfIssue gets UnderlyingLocaleOfIssue, Tag 594 +func (m NoUnderlyings) GetUnderlyingLocaleOfIssue() (f field.UnderlyingLocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRedemptionDate gets UnderlyingRedemptionDate, Tag 247 +func (m NoUnderlyings) GetUnderlyingRedemptionDate() (f field.UnderlyingRedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStrikePrice gets UnderlyingStrikePrice, Tag 316 +func (m NoUnderlyings) GetUnderlyingStrikePrice() (f field.UnderlyingStrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStrikeCurrency gets UnderlyingStrikeCurrency, Tag 941 +func (m NoUnderlyings) GetUnderlyingStrikeCurrency() (f field.UnderlyingStrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingOptAttribute gets UnderlyingOptAttribute, Tag 317 +func (m NoUnderlyings) GetUnderlyingOptAttribute() (f field.UnderlyingOptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingContractMultiplier gets UnderlyingContractMultiplier, Tag 436 +func (m NoUnderlyings) GetUnderlyingContractMultiplier() (f field.UnderlyingContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCouponRate gets UnderlyingCouponRate, Tag 435 +func (m NoUnderlyings) GetUnderlyingCouponRate() (f field.UnderlyingCouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityExchange gets UnderlyingSecurityExchange, Tag 308 +func (m NoUnderlyings) GetUnderlyingSecurityExchange() (f field.UnderlyingSecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingIssuer gets UnderlyingIssuer, Tag 306 +func (m NoUnderlyings) GetUnderlyingIssuer() (f field.UnderlyingIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingIssuerLen gets EncodedUnderlyingIssuerLen, Tag 362 +func (m NoUnderlyings) GetEncodedUnderlyingIssuerLen() (f field.EncodedUnderlyingIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingIssuer gets EncodedUnderlyingIssuer, Tag 363 +func (m NoUnderlyings) GetEncodedUnderlyingIssuer() (f field.EncodedUnderlyingIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityDesc gets UnderlyingSecurityDesc, Tag 307 +func (m NoUnderlyings) GetUnderlyingSecurityDesc() (f field.UnderlyingSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingSecurityDescLen gets EncodedUnderlyingSecurityDescLen, Tag 364 +func (m NoUnderlyings) GetEncodedUnderlyingSecurityDescLen() (f field.EncodedUnderlyingSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingSecurityDesc gets EncodedUnderlyingSecurityDesc, Tag 365 +func (m NoUnderlyings) GetEncodedUnderlyingSecurityDesc() (f field.EncodedUnderlyingSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCPProgram gets UnderlyingCPProgram, Tag 877 +func (m NoUnderlyings) GetUnderlyingCPProgram() (f field.UnderlyingCPProgramField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCPRegType gets UnderlyingCPRegType, Tag 878 +func (m NoUnderlyings) GetUnderlyingCPRegType() (f field.UnderlyingCPRegTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCurrency gets UnderlyingCurrency, Tag 318 +func (m NoUnderlyings) GetUnderlyingCurrency() (f field.UnderlyingCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingQty gets UnderlyingQty, Tag 879 +func (m NoUnderlyings) GetUnderlyingQty() (f field.UnderlyingQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingPx gets UnderlyingPx, Tag 810 +func (m NoUnderlyings) GetUnderlyingPx() (f field.UnderlyingPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingDirtyPrice gets UnderlyingDirtyPrice, Tag 882 +func (m NoUnderlyings) GetUnderlyingDirtyPrice() (f field.UnderlyingDirtyPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingEndPrice gets UnderlyingEndPrice, Tag 883 +func (m NoUnderlyings) GetUnderlyingEndPrice() (f field.UnderlyingEndPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStartValue gets UnderlyingStartValue, Tag 884 +func (m NoUnderlyings) GetUnderlyingStartValue() (f field.UnderlyingStartValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCurrentValue gets UnderlyingCurrentValue, Tag 885 +func (m NoUnderlyings) GetUnderlyingCurrentValue() (f field.UnderlyingCurrentValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingEndValue gets UnderlyingEndValue, Tag 886 +func (m NoUnderlyings) GetUnderlyingEndValue() (f field.UnderlyingEndValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyingStips gets NoUnderlyingStips, Tag 887 +func (m NoUnderlyings) GetNoUnderlyingStips() (NoUnderlyingStipsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingStipsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetUnderlyingAllocationPercent gets UnderlyingAllocationPercent, Tag 972 +func (m NoUnderlyings) GetUnderlyingAllocationPercent() (f field.UnderlyingAllocationPercentField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSettlementType gets UnderlyingSettlementType, Tag 975 +func (m NoUnderlyings) GetUnderlyingSettlementType() (f field.UnderlyingSettlementTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCashAmount gets UnderlyingCashAmount, Tag 973 +func (m NoUnderlyings) GetUnderlyingCashAmount() (f field.UnderlyingCashAmountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCashType gets UnderlyingCashType, Tag 974 +func (m NoUnderlyings) GetUnderlyingCashType() (f field.UnderlyingCashTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingUnitOfMeasure gets UnderlyingUnitOfMeasure, Tag 998 +func (m NoUnderlyings) GetUnderlyingUnitOfMeasure() (f field.UnderlyingUnitOfMeasureField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingTimeUnit gets UnderlyingTimeUnit, Tag 1000 +func (m NoUnderlyings) GetUnderlyingTimeUnit() (f field.UnderlyingTimeUnitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCapValue gets UnderlyingCapValue, Tag 1038 +func (m NoUnderlyings) GetUnderlyingCapValue() (f field.UnderlyingCapValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUndlyInstrumentParties gets NoUndlyInstrumentParties, Tag 1058 +func (m NoUnderlyings) GetNoUndlyInstrumentParties() (NoUndlyInstrumentPartiesRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUndlyInstrumentPartiesRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetUnderlyingSettlMethod gets UnderlyingSettlMethod, Tag 1039 +func (m NoUnderlyings) GetUnderlyingSettlMethod() (f field.UnderlyingSettlMethodField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingAdjustedQuantity gets UnderlyingAdjustedQuantity, Tag 1044 +func (m NoUnderlyings) GetUnderlyingAdjustedQuantity() (f field.UnderlyingAdjustedQuantityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingFXRate gets UnderlyingFXRate, Tag 1045 +func (m NoUnderlyings) GetUnderlyingFXRate() (f field.UnderlyingFXRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingFXRateCalc gets UnderlyingFXRateCalc, Tag 1046 +func (m NoUnderlyings) GetUnderlyingFXRateCalc() (f field.UnderlyingFXRateCalcField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingSymbol returns true if UnderlyingSymbol is present, Tag 311 +func (m NoUnderlyings) HasUnderlyingSymbol() bool { + return m.Has(tag.UnderlyingSymbol) +} + +//HasUnderlyingSymbolSfx returns true if UnderlyingSymbolSfx is present, Tag 312 +func (m NoUnderlyings) HasUnderlyingSymbolSfx() bool { + return m.Has(tag.UnderlyingSymbolSfx) +} + +//HasUnderlyingSecurityID returns true if UnderlyingSecurityID is present, Tag 309 +func (m NoUnderlyings) HasUnderlyingSecurityID() bool { + return m.Has(tag.UnderlyingSecurityID) +} + +//HasUnderlyingSecurityIDSource returns true if UnderlyingSecurityIDSource is present, Tag 305 +func (m NoUnderlyings) HasUnderlyingSecurityIDSource() bool { + return m.Has(tag.UnderlyingSecurityIDSource) +} + +//HasNoUnderlyingSecurityAltID returns true if NoUnderlyingSecurityAltID is present, Tag 457 +func (m NoUnderlyings) HasNoUnderlyingSecurityAltID() bool { + return m.Has(tag.NoUnderlyingSecurityAltID) +} + +//HasUnderlyingProduct returns true if UnderlyingProduct is present, Tag 462 +func (m NoUnderlyings) HasUnderlyingProduct() bool { + return m.Has(tag.UnderlyingProduct) +} + +//HasUnderlyingCFICode returns true if UnderlyingCFICode is present, Tag 463 +func (m NoUnderlyings) HasUnderlyingCFICode() bool { + return m.Has(tag.UnderlyingCFICode) +} + +//HasUnderlyingSecurityType returns true if UnderlyingSecurityType is present, Tag 310 +func (m NoUnderlyings) HasUnderlyingSecurityType() bool { + return m.Has(tag.UnderlyingSecurityType) +} + +//HasUnderlyingSecuritySubType returns true if UnderlyingSecuritySubType is present, Tag 763 +func (m NoUnderlyings) HasUnderlyingSecuritySubType() bool { + return m.Has(tag.UnderlyingSecuritySubType) +} + +//HasUnderlyingMaturityMonthYear returns true if UnderlyingMaturityMonthYear is present, Tag 313 +func (m NoUnderlyings) HasUnderlyingMaturityMonthYear() bool { + return m.Has(tag.UnderlyingMaturityMonthYear) +} + +//HasUnderlyingMaturityDate returns true if UnderlyingMaturityDate is present, Tag 542 +func (m NoUnderlyings) HasUnderlyingMaturityDate() bool { + return m.Has(tag.UnderlyingMaturityDate) +} + +//HasUnderlyingCouponPaymentDate returns true if UnderlyingCouponPaymentDate is present, Tag 241 +func (m NoUnderlyings) HasUnderlyingCouponPaymentDate() bool { + return m.Has(tag.UnderlyingCouponPaymentDate) +} + +//HasUnderlyingIssueDate returns true if UnderlyingIssueDate is present, Tag 242 +func (m NoUnderlyings) HasUnderlyingIssueDate() bool { + return m.Has(tag.UnderlyingIssueDate) +} + +//HasUnderlyingRepoCollateralSecurityType returns true if UnderlyingRepoCollateralSecurityType is present, Tag 243 +func (m NoUnderlyings) HasUnderlyingRepoCollateralSecurityType() bool { + return m.Has(tag.UnderlyingRepoCollateralSecurityType) +} + +//HasUnderlyingRepurchaseTerm returns true if UnderlyingRepurchaseTerm is present, Tag 244 +func (m NoUnderlyings) HasUnderlyingRepurchaseTerm() bool { + return m.Has(tag.UnderlyingRepurchaseTerm) +} + +//HasUnderlyingRepurchaseRate returns true if UnderlyingRepurchaseRate is present, Tag 245 +func (m NoUnderlyings) HasUnderlyingRepurchaseRate() bool { + return m.Has(tag.UnderlyingRepurchaseRate) +} + +//HasUnderlyingFactor returns true if UnderlyingFactor is present, Tag 246 +func (m NoUnderlyings) HasUnderlyingFactor() bool { + return m.Has(tag.UnderlyingFactor) +} + +//HasUnderlyingCreditRating returns true if UnderlyingCreditRating is present, Tag 256 +func (m NoUnderlyings) HasUnderlyingCreditRating() bool { + return m.Has(tag.UnderlyingCreditRating) +} + +//HasUnderlyingInstrRegistry returns true if UnderlyingInstrRegistry is present, Tag 595 +func (m NoUnderlyings) HasUnderlyingInstrRegistry() bool { + return m.Has(tag.UnderlyingInstrRegistry) +} + +//HasUnderlyingCountryOfIssue returns true if UnderlyingCountryOfIssue is present, Tag 592 +func (m NoUnderlyings) HasUnderlyingCountryOfIssue() bool { + return m.Has(tag.UnderlyingCountryOfIssue) +} + +//HasUnderlyingStateOrProvinceOfIssue returns true if UnderlyingStateOrProvinceOfIssue is present, Tag 593 +func (m NoUnderlyings) HasUnderlyingStateOrProvinceOfIssue() bool { + return m.Has(tag.UnderlyingStateOrProvinceOfIssue) +} + +//HasUnderlyingLocaleOfIssue returns true if UnderlyingLocaleOfIssue is present, Tag 594 +func (m NoUnderlyings) HasUnderlyingLocaleOfIssue() bool { + return m.Has(tag.UnderlyingLocaleOfIssue) +} + +//HasUnderlyingRedemptionDate returns true if UnderlyingRedemptionDate is present, Tag 247 +func (m NoUnderlyings) HasUnderlyingRedemptionDate() bool { + return m.Has(tag.UnderlyingRedemptionDate) +} + +//HasUnderlyingStrikePrice returns true if UnderlyingStrikePrice is present, Tag 316 +func (m NoUnderlyings) HasUnderlyingStrikePrice() bool { + return m.Has(tag.UnderlyingStrikePrice) +} + +//HasUnderlyingStrikeCurrency returns true if UnderlyingStrikeCurrency is present, Tag 941 +func (m NoUnderlyings) HasUnderlyingStrikeCurrency() bool { + return m.Has(tag.UnderlyingStrikeCurrency) +} + +//HasUnderlyingOptAttribute returns true if UnderlyingOptAttribute is present, Tag 317 +func (m NoUnderlyings) HasUnderlyingOptAttribute() bool { + return m.Has(tag.UnderlyingOptAttribute) +} + +//HasUnderlyingContractMultiplier returns true if UnderlyingContractMultiplier is present, Tag 436 +func (m NoUnderlyings) HasUnderlyingContractMultiplier() bool { + return m.Has(tag.UnderlyingContractMultiplier) +} + +//HasUnderlyingCouponRate returns true if UnderlyingCouponRate is present, Tag 435 +func (m NoUnderlyings) HasUnderlyingCouponRate() bool { + return m.Has(tag.UnderlyingCouponRate) +} + +//HasUnderlyingSecurityExchange returns true if UnderlyingSecurityExchange is present, Tag 308 +func (m NoUnderlyings) HasUnderlyingSecurityExchange() bool { + return m.Has(tag.UnderlyingSecurityExchange) +} + +//HasUnderlyingIssuer returns true if UnderlyingIssuer is present, Tag 306 +func (m NoUnderlyings) HasUnderlyingIssuer() bool { + return m.Has(tag.UnderlyingIssuer) +} + +//HasEncodedUnderlyingIssuerLen returns true if EncodedUnderlyingIssuerLen is present, Tag 362 +func (m NoUnderlyings) HasEncodedUnderlyingIssuerLen() bool { + return m.Has(tag.EncodedUnderlyingIssuerLen) +} + +//HasEncodedUnderlyingIssuer returns true if EncodedUnderlyingIssuer is present, Tag 363 +func (m NoUnderlyings) HasEncodedUnderlyingIssuer() bool { + return m.Has(tag.EncodedUnderlyingIssuer) +} + +//HasUnderlyingSecurityDesc returns true if UnderlyingSecurityDesc is present, Tag 307 +func (m NoUnderlyings) HasUnderlyingSecurityDesc() bool { + return m.Has(tag.UnderlyingSecurityDesc) +} + +//HasEncodedUnderlyingSecurityDescLen returns true if EncodedUnderlyingSecurityDescLen is present, Tag 364 +func (m NoUnderlyings) HasEncodedUnderlyingSecurityDescLen() bool { + return m.Has(tag.EncodedUnderlyingSecurityDescLen) +} + +//HasEncodedUnderlyingSecurityDesc returns true if EncodedUnderlyingSecurityDesc is present, Tag 365 +func (m NoUnderlyings) HasEncodedUnderlyingSecurityDesc() bool { + return m.Has(tag.EncodedUnderlyingSecurityDesc) +} + +//HasUnderlyingCPProgram returns true if UnderlyingCPProgram is present, Tag 877 +func (m NoUnderlyings) HasUnderlyingCPProgram() bool { + return m.Has(tag.UnderlyingCPProgram) +} + +//HasUnderlyingCPRegType returns true if UnderlyingCPRegType is present, Tag 878 +func (m NoUnderlyings) HasUnderlyingCPRegType() bool { + return m.Has(tag.UnderlyingCPRegType) +} + +//HasUnderlyingCurrency returns true if UnderlyingCurrency is present, Tag 318 +func (m NoUnderlyings) HasUnderlyingCurrency() bool { + return m.Has(tag.UnderlyingCurrency) +} + +//HasUnderlyingQty returns true if UnderlyingQty is present, Tag 879 +func (m NoUnderlyings) HasUnderlyingQty() bool { + return m.Has(tag.UnderlyingQty) +} + +//HasUnderlyingPx returns true if UnderlyingPx is present, Tag 810 +func (m NoUnderlyings) HasUnderlyingPx() bool { + return m.Has(tag.UnderlyingPx) +} + +//HasUnderlyingDirtyPrice returns true if UnderlyingDirtyPrice is present, Tag 882 +func (m NoUnderlyings) HasUnderlyingDirtyPrice() bool { + return m.Has(tag.UnderlyingDirtyPrice) +} + +//HasUnderlyingEndPrice returns true if UnderlyingEndPrice is present, Tag 883 +func (m NoUnderlyings) HasUnderlyingEndPrice() bool { + return m.Has(tag.UnderlyingEndPrice) +} + +//HasUnderlyingStartValue returns true if UnderlyingStartValue is present, Tag 884 +func (m NoUnderlyings) HasUnderlyingStartValue() bool { + return m.Has(tag.UnderlyingStartValue) +} + +//HasUnderlyingCurrentValue returns true if UnderlyingCurrentValue is present, Tag 885 +func (m NoUnderlyings) HasUnderlyingCurrentValue() bool { + return m.Has(tag.UnderlyingCurrentValue) +} + +//HasUnderlyingEndValue returns true if UnderlyingEndValue is present, Tag 886 +func (m NoUnderlyings) HasUnderlyingEndValue() bool { + return m.Has(tag.UnderlyingEndValue) +} + +//HasNoUnderlyingStips returns true if NoUnderlyingStips is present, Tag 887 +func (m NoUnderlyings) HasNoUnderlyingStips() bool { + return m.Has(tag.NoUnderlyingStips) +} + +//HasUnderlyingAllocationPercent returns true if UnderlyingAllocationPercent is present, Tag 972 +func (m NoUnderlyings) HasUnderlyingAllocationPercent() bool { + return m.Has(tag.UnderlyingAllocationPercent) +} + +//HasUnderlyingSettlementType returns true if UnderlyingSettlementType is present, Tag 975 +func (m NoUnderlyings) HasUnderlyingSettlementType() bool { + return m.Has(tag.UnderlyingSettlementType) +} + +//HasUnderlyingCashAmount returns true if UnderlyingCashAmount is present, Tag 973 +func (m NoUnderlyings) HasUnderlyingCashAmount() bool { + return m.Has(tag.UnderlyingCashAmount) +} + +//HasUnderlyingCashType returns true if UnderlyingCashType is present, Tag 974 +func (m NoUnderlyings) HasUnderlyingCashType() bool { + return m.Has(tag.UnderlyingCashType) +} + +//HasUnderlyingUnitOfMeasure returns true if UnderlyingUnitOfMeasure is present, Tag 998 +func (m NoUnderlyings) HasUnderlyingUnitOfMeasure() bool { + return m.Has(tag.UnderlyingUnitOfMeasure) +} + +//HasUnderlyingTimeUnit returns true if UnderlyingTimeUnit is present, Tag 1000 +func (m NoUnderlyings) HasUnderlyingTimeUnit() bool { + return m.Has(tag.UnderlyingTimeUnit) +} + +//HasUnderlyingCapValue returns true if UnderlyingCapValue is present, Tag 1038 +func (m NoUnderlyings) HasUnderlyingCapValue() bool { + return m.Has(tag.UnderlyingCapValue) +} + +//HasNoUndlyInstrumentParties returns true if NoUndlyInstrumentParties is present, Tag 1058 +func (m NoUnderlyings) HasNoUndlyInstrumentParties() bool { + return m.Has(tag.NoUndlyInstrumentParties) +} + +//HasUnderlyingSettlMethod returns true if UnderlyingSettlMethod is present, Tag 1039 +func (m NoUnderlyings) HasUnderlyingSettlMethod() bool { + return m.Has(tag.UnderlyingSettlMethod) +} + +//HasUnderlyingAdjustedQuantity returns true if UnderlyingAdjustedQuantity is present, Tag 1044 +func (m NoUnderlyings) HasUnderlyingAdjustedQuantity() bool { + return m.Has(tag.UnderlyingAdjustedQuantity) +} + +//HasUnderlyingFXRate returns true if UnderlyingFXRate is present, Tag 1045 +func (m NoUnderlyings) HasUnderlyingFXRate() bool { + return m.Has(tag.UnderlyingFXRate) +} + +//HasUnderlyingFXRateCalc returns true if UnderlyingFXRateCalc is present, Tag 1046 +func (m NoUnderlyings) HasUnderlyingFXRateCalc() bool { + return m.Has(tag.UnderlyingFXRateCalc) +} + +//NoUnderlyingSecurityAltID is a repeating group element, Tag 457 +type NoUnderlyingSecurityAltID struct { + quickfix.Group +} + +//SetUnderlyingSecurityAltID sets UnderlyingSecurityAltID, Tag 458 +func (m NoUnderlyingSecurityAltID) SetUnderlyingSecurityAltID(v string) { + m.Set(field.NewUnderlyingSecurityAltID(v)) +} + +//SetUnderlyingSecurityAltIDSource sets UnderlyingSecurityAltIDSource, Tag 459 +func (m NoUnderlyingSecurityAltID) SetUnderlyingSecurityAltIDSource(v string) { + m.Set(field.NewUnderlyingSecurityAltIDSource(v)) +} + +//GetUnderlyingSecurityAltID gets UnderlyingSecurityAltID, Tag 458 +func (m NoUnderlyingSecurityAltID) GetUnderlyingSecurityAltID() (f field.UnderlyingSecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityAltIDSource gets UnderlyingSecurityAltIDSource, Tag 459 +func (m NoUnderlyingSecurityAltID) GetUnderlyingSecurityAltIDSource() (f field.UnderlyingSecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingSecurityAltID returns true if UnderlyingSecurityAltID is present, Tag 458 +func (m NoUnderlyingSecurityAltID) HasUnderlyingSecurityAltID() bool { + return m.Has(tag.UnderlyingSecurityAltID) +} + +//HasUnderlyingSecurityAltIDSource returns true if UnderlyingSecurityAltIDSource is present, Tag 459 +func (m NoUnderlyingSecurityAltID) HasUnderlyingSecurityAltIDSource() bool { + return m.Has(tag.UnderlyingSecurityAltIDSource) +} + +//NoUnderlyingSecurityAltIDRepeatingGroup is a repeating group, Tag 457 +type NoUnderlyingSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingSecurityAltIDRepeatingGroup returns an initialized, NoUnderlyingSecurityAltIDRepeatingGroup +func NewNoUnderlyingSecurityAltIDRepeatingGroup() NoUnderlyingSecurityAltIDRepeatingGroup { + return NoUnderlyingSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyingSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingSecurityAltID), quickfix.GroupElement(tag.UnderlyingSecurityAltIDSource)})} +} + +//Add create and append a new NoUnderlyingSecurityAltID to this group +func (m NoUnderlyingSecurityAltIDRepeatingGroup) Add() NoUnderlyingSecurityAltID { + g := m.RepeatingGroup.Add() + return NoUnderlyingSecurityAltID{g} +} + +//Get returns the ith NoUnderlyingSecurityAltID in the NoUnderlyingSecurityAltIDRepeatinGroup +func (m NoUnderlyingSecurityAltIDRepeatingGroup) Get(i int) NoUnderlyingSecurityAltID { + return NoUnderlyingSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyingStips is a repeating group element, Tag 887 +type NoUnderlyingStips struct { + quickfix.Group +} + +//SetUnderlyingStipType sets UnderlyingStipType, Tag 888 +func (m NoUnderlyingStips) SetUnderlyingStipType(v string) { + m.Set(field.NewUnderlyingStipType(v)) +} + +//SetUnderlyingStipValue sets UnderlyingStipValue, Tag 889 +func (m NoUnderlyingStips) SetUnderlyingStipValue(v string) { + m.Set(field.NewUnderlyingStipValue(v)) +} + +//GetUnderlyingStipType gets UnderlyingStipType, Tag 888 +func (m NoUnderlyingStips) GetUnderlyingStipType() (f field.UnderlyingStipTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStipValue gets UnderlyingStipValue, Tag 889 +func (m NoUnderlyingStips) GetUnderlyingStipValue() (f field.UnderlyingStipValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingStipType returns true if UnderlyingStipType is present, Tag 888 +func (m NoUnderlyingStips) HasUnderlyingStipType() bool { + return m.Has(tag.UnderlyingStipType) +} + +//HasUnderlyingStipValue returns true if UnderlyingStipValue is present, Tag 889 +func (m NoUnderlyingStips) HasUnderlyingStipValue() bool { + return m.Has(tag.UnderlyingStipValue) +} + +//NoUnderlyingStipsRepeatingGroup is a repeating group, Tag 887 +type NoUnderlyingStipsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingStipsRepeatingGroup returns an initialized, NoUnderlyingStipsRepeatingGroup +func NewNoUnderlyingStipsRepeatingGroup() NoUnderlyingStipsRepeatingGroup { + return NoUnderlyingStipsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyingStips, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingStipType), quickfix.GroupElement(tag.UnderlyingStipValue)})} +} + +//Add create and append a new NoUnderlyingStips to this group +func (m NoUnderlyingStipsRepeatingGroup) Add() NoUnderlyingStips { + g := m.RepeatingGroup.Add() + return NoUnderlyingStips{g} +} + +//Get returns the ith NoUnderlyingStips in the NoUnderlyingStipsRepeatinGroup +func (m NoUnderlyingStipsRepeatingGroup) Get(i int) NoUnderlyingStips { + return NoUnderlyingStips{m.RepeatingGroup.Get(i)} +} + +//NoUndlyInstrumentParties is a repeating group element, Tag 1058 +type NoUndlyInstrumentParties struct { + quickfix.Group +} + +//SetUndlyInstrumentPartyID sets UndlyInstrumentPartyID, Tag 1059 +func (m NoUndlyInstrumentParties) SetUndlyInstrumentPartyID(v string) { + m.Set(field.NewUndlyInstrumentPartyID(v)) +} + +//SetUndlyInstrumentPartyIDSource sets UndlyInstrumentPartyIDSource, Tag 1060 +func (m NoUndlyInstrumentParties) SetUndlyInstrumentPartyIDSource(v string) { + m.Set(field.NewUndlyInstrumentPartyIDSource(v)) +} + +//SetUndlyInstrumentPartyRole sets UndlyInstrumentPartyRole, Tag 1061 +func (m NoUndlyInstrumentParties) SetUndlyInstrumentPartyRole(v int) { + m.Set(field.NewUndlyInstrumentPartyRole(v)) +} + +//SetNoUndlyInstrumentPartySubIDs sets NoUndlyInstrumentPartySubIDs, Tag 1062 +func (m NoUndlyInstrumentParties) SetNoUndlyInstrumentPartySubIDs(f NoUndlyInstrumentPartySubIDsRepeatingGroup) { + m.SetGroup(f) +} + +//GetUndlyInstrumentPartyID gets UndlyInstrumentPartyID, Tag 1059 +func (m NoUndlyInstrumentParties) GetUndlyInstrumentPartyID() (f field.UndlyInstrumentPartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUndlyInstrumentPartyIDSource gets UndlyInstrumentPartyIDSource, Tag 1060 +func (m NoUndlyInstrumentParties) GetUndlyInstrumentPartyIDSource() (f field.UndlyInstrumentPartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUndlyInstrumentPartyRole gets UndlyInstrumentPartyRole, Tag 1061 +func (m NoUndlyInstrumentParties) GetUndlyInstrumentPartyRole() (f field.UndlyInstrumentPartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUndlyInstrumentPartySubIDs gets NoUndlyInstrumentPartySubIDs, Tag 1062 +func (m NoUndlyInstrumentParties) GetNoUndlyInstrumentPartySubIDs() (NoUndlyInstrumentPartySubIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUndlyInstrumentPartySubIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasUndlyInstrumentPartyID returns true if UndlyInstrumentPartyID is present, Tag 1059 +func (m NoUndlyInstrumentParties) HasUndlyInstrumentPartyID() bool { + return m.Has(tag.UndlyInstrumentPartyID) +} + +//HasUndlyInstrumentPartyIDSource returns true if UndlyInstrumentPartyIDSource is present, Tag 1060 +func (m NoUndlyInstrumentParties) HasUndlyInstrumentPartyIDSource() bool { + return m.Has(tag.UndlyInstrumentPartyIDSource) +} + +//HasUndlyInstrumentPartyRole returns true if UndlyInstrumentPartyRole is present, Tag 1061 +func (m NoUndlyInstrumentParties) HasUndlyInstrumentPartyRole() bool { + return m.Has(tag.UndlyInstrumentPartyRole) +} + +//HasNoUndlyInstrumentPartySubIDs returns true if NoUndlyInstrumentPartySubIDs is present, Tag 1062 +func (m NoUndlyInstrumentParties) HasNoUndlyInstrumentPartySubIDs() bool { + return m.Has(tag.NoUndlyInstrumentPartySubIDs) +} + +//NoUndlyInstrumentPartySubIDs is a repeating group element, Tag 1062 +type NoUndlyInstrumentPartySubIDs struct { + quickfix.Group +} + +//SetUndlyInstrumentPartySubID sets UndlyInstrumentPartySubID, Tag 1063 +func (m NoUndlyInstrumentPartySubIDs) SetUndlyInstrumentPartySubID(v string) { + m.Set(field.NewUndlyInstrumentPartySubID(v)) +} + +//SetUndlyInstrumentPartySubIDType sets UndlyInstrumentPartySubIDType, Tag 1064 +func (m NoUndlyInstrumentPartySubIDs) SetUndlyInstrumentPartySubIDType(v int) { + m.Set(field.NewUndlyInstrumentPartySubIDType(v)) +} + +//GetUndlyInstrumentPartySubID gets UndlyInstrumentPartySubID, Tag 1063 +func (m NoUndlyInstrumentPartySubIDs) GetUndlyInstrumentPartySubID() (f field.UndlyInstrumentPartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUndlyInstrumentPartySubIDType gets UndlyInstrumentPartySubIDType, Tag 1064 +func (m NoUndlyInstrumentPartySubIDs) GetUndlyInstrumentPartySubIDType() (f field.UndlyInstrumentPartySubIDTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUndlyInstrumentPartySubID returns true if UndlyInstrumentPartySubID is present, Tag 1063 +func (m NoUndlyInstrumentPartySubIDs) HasUndlyInstrumentPartySubID() bool { + return m.Has(tag.UndlyInstrumentPartySubID) +} + +//HasUndlyInstrumentPartySubIDType returns true if UndlyInstrumentPartySubIDType is present, Tag 1064 +func (m NoUndlyInstrumentPartySubIDs) HasUndlyInstrumentPartySubIDType() bool { + return m.Has(tag.UndlyInstrumentPartySubIDType) +} + +//NoUndlyInstrumentPartySubIDsRepeatingGroup is a repeating group, Tag 1062 +type NoUndlyInstrumentPartySubIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUndlyInstrumentPartySubIDsRepeatingGroup returns an initialized, NoUndlyInstrumentPartySubIDsRepeatingGroup +func NewNoUndlyInstrumentPartySubIDsRepeatingGroup() NoUndlyInstrumentPartySubIDsRepeatingGroup { + return NoUndlyInstrumentPartySubIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUndlyInstrumentPartySubIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UndlyInstrumentPartySubID), quickfix.GroupElement(tag.UndlyInstrumentPartySubIDType)})} +} + +//Add create and append a new NoUndlyInstrumentPartySubIDs to this group +func (m NoUndlyInstrumentPartySubIDsRepeatingGroup) Add() NoUndlyInstrumentPartySubIDs { + g := m.RepeatingGroup.Add() + return NoUndlyInstrumentPartySubIDs{g} +} + +//Get returns the ith NoUndlyInstrumentPartySubIDs in the NoUndlyInstrumentPartySubIDsRepeatinGroup +func (m NoUndlyInstrumentPartySubIDsRepeatingGroup) Get(i int) NoUndlyInstrumentPartySubIDs { + return NoUndlyInstrumentPartySubIDs{m.RepeatingGroup.Get(i)} +} + +//NoUndlyInstrumentPartiesRepeatingGroup is a repeating group, Tag 1058 +type NoUndlyInstrumentPartiesRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUndlyInstrumentPartiesRepeatingGroup returns an initialized, NoUndlyInstrumentPartiesRepeatingGroup +func NewNoUndlyInstrumentPartiesRepeatingGroup() NoUndlyInstrumentPartiesRepeatingGroup { + return NoUndlyInstrumentPartiesRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUndlyInstrumentParties, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UndlyInstrumentPartyID), quickfix.GroupElement(tag.UndlyInstrumentPartyIDSource), quickfix.GroupElement(tag.UndlyInstrumentPartyRole), NewNoUndlyInstrumentPartySubIDsRepeatingGroup()})} +} + +//Add create and append a new NoUndlyInstrumentParties to this group +func (m NoUndlyInstrumentPartiesRepeatingGroup) Add() NoUndlyInstrumentParties { + g := m.RepeatingGroup.Add() + return NoUndlyInstrumentParties{g} +} + +//Get returns the ith NoUndlyInstrumentParties in the NoUndlyInstrumentPartiesRepeatinGroup +func (m NoUndlyInstrumentPartiesRepeatingGroup) Get(i int) NoUndlyInstrumentParties { + return NoUndlyInstrumentParties{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyingsRepeatingGroup is a repeating group, Tag 711 +type NoUnderlyingsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingsRepeatingGroup returns an initialized, NoUnderlyingsRepeatingGroup +func NewNoUnderlyingsRepeatingGroup() NoUnderlyingsRepeatingGroup { + return NoUnderlyingsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyings, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingSymbol), quickfix.GroupElement(tag.UnderlyingSymbolSfx), quickfix.GroupElement(tag.UnderlyingSecurityID), quickfix.GroupElement(tag.UnderlyingSecurityIDSource), NewNoUnderlyingSecurityAltIDRepeatingGroup(), quickfix.GroupElement(tag.UnderlyingProduct), quickfix.GroupElement(tag.UnderlyingCFICode), quickfix.GroupElement(tag.UnderlyingSecurityType), quickfix.GroupElement(tag.UnderlyingSecuritySubType), quickfix.GroupElement(tag.UnderlyingMaturityMonthYear), quickfix.GroupElement(tag.UnderlyingMaturityDate), quickfix.GroupElement(tag.UnderlyingCouponPaymentDate), quickfix.GroupElement(tag.UnderlyingIssueDate), quickfix.GroupElement(tag.UnderlyingRepoCollateralSecurityType), quickfix.GroupElement(tag.UnderlyingRepurchaseTerm), quickfix.GroupElement(tag.UnderlyingRepurchaseRate), quickfix.GroupElement(tag.UnderlyingFactor), quickfix.GroupElement(tag.UnderlyingCreditRating), quickfix.GroupElement(tag.UnderlyingInstrRegistry), quickfix.GroupElement(tag.UnderlyingCountryOfIssue), quickfix.GroupElement(tag.UnderlyingStateOrProvinceOfIssue), quickfix.GroupElement(tag.UnderlyingLocaleOfIssue), quickfix.GroupElement(tag.UnderlyingRedemptionDate), quickfix.GroupElement(tag.UnderlyingStrikePrice), quickfix.GroupElement(tag.UnderlyingStrikeCurrency), quickfix.GroupElement(tag.UnderlyingOptAttribute), quickfix.GroupElement(tag.UnderlyingContractMultiplier), quickfix.GroupElement(tag.UnderlyingCouponRate), quickfix.GroupElement(tag.UnderlyingSecurityExchange), quickfix.GroupElement(tag.UnderlyingIssuer), quickfix.GroupElement(tag.EncodedUnderlyingIssuerLen), quickfix.GroupElement(tag.EncodedUnderlyingIssuer), quickfix.GroupElement(tag.UnderlyingSecurityDesc), quickfix.GroupElement(tag.EncodedUnderlyingSecurityDescLen), quickfix.GroupElement(tag.EncodedUnderlyingSecurityDesc), quickfix.GroupElement(tag.UnderlyingCPProgram), quickfix.GroupElement(tag.UnderlyingCPRegType), quickfix.GroupElement(tag.UnderlyingCurrency), quickfix.GroupElement(tag.UnderlyingQty), quickfix.GroupElement(tag.UnderlyingPx), quickfix.GroupElement(tag.UnderlyingDirtyPrice), quickfix.GroupElement(tag.UnderlyingEndPrice), quickfix.GroupElement(tag.UnderlyingStartValue), quickfix.GroupElement(tag.UnderlyingCurrentValue), quickfix.GroupElement(tag.UnderlyingEndValue), NewNoUnderlyingStipsRepeatingGroup(), quickfix.GroupElement(tag.UnderlyingAllocationPercent), quickfix.GroupElement(tag.UnderlyingSettlementType), quickfix.GroupElement(tag.UnderlyingCashAmount), quickfix.GroupElement(tag.UnderlyingCashType), quickfix.GroupElement(tag.UnderlyingUnitOfMeasure), quickfix.GroupElement(tag.UnderlyingTimeUnit), quickfix.GroupElement(tag.UnderlyingCapValue), NewNoUndlyInstrumentPartiesRepeatingGroup(), quickfix.GroupElement(tag.UnderlyingSettlMethod), quickfix.GroupElement(tag.UnderlyingAdjustedQuantity), quickfix.GroupElement(tag.UnderlyingFXRate), quickfix.GroupElement(tag.UnderlyingFXRateCalc)})} +} + +//Add create and append a new NoUnderlyings to this group +func (m NoUnderlyingsRepeatingGroup) Add() NoUnderlyings { + g := m.RepeatingGroup.Add() + return NoUnderlyings{g} +} + +//Get returns the ith NoUnderlyings in the NoUnderlyingsRepeatinGroup +func (m NoUnderlyingsRepeatingGroup) Get(i int) NoUnderlyings { + return NoUnderlyings{m.RepeatingGroup.Get(i)} +} + +//NoTrdRegTimestamps is a repeating group element, Tag 768 +type NoTrdRegTimestamps struct { + quickfix.Group +} + +//SetTrdRegTimestamp sets TrdRegTimestamp, Tag 769 +func (m NoTrdRegTimestamps) SetTrdRegTimestamp(v time.Time) { + m.Set(field.NewTrdRegTimestamp(v)) +} + +//SetTrdRegTimestampType sets TrdRegTimestampType, Tag 770 +func (m NoTrdRegTimestamps) SetTrdRegTimestampType(v int) { + m.Set(field.NewTrdRegTimestampType(v)) +} + +//SetTrdRegTimestampOrigin sets TrdRegTimestampOrigin, Tag 771 +func (m NoTrdRegTimestamps) SetTrdRegTimestampOrigin(v string) { + m.Set(field.NewTrdRegTimestampOrigin(v)) +} + +//SetDeskType sets DeskType, Tag 1033 +func (m NoTrdRegTimestamps) SetDeskType(v string) { + m.Set(field.NewDeskType(v)) +} + +//SetDeskTypeSource sets DeskTypeSource, Tag 1034 +func (m NoTrdRegTimestamps) SetDeskTypeSource(v int) { + m.Set(field.NewDeskTypeSource(v)) +} + +//SetDeskOrderHandlingInst sets DeskOrderHandlingInst, Tag 1035 +func (m NoTrdRegTimestamps) SetDeskOrderHandlingInst(v string) { + m.Set(field.NewDeskOrderHandlingInst(v)) +} + +//GetTrdRegTimestamp gets TrdRegTimestamp, Tag 769 +func (m NoTrdRegTimestamps) GetTrdRegTimestamp() (f field.TrdRegTimestampField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTrdRegTimestampType gets TrdRegTimestampType, Tag 770 +func (m NoTrdRegTimestamps) GetTrdRegTimestampType() (f field.TrdRegTimestampTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTrdRegTimestampOrigin gets TrdRegTimestampOrigin, Tag 771 +func (m NoTrdRegTimestamps) GetTrdRegTimestampOrigin() (f field.TrdRegTimestampOriginField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDeskType gets DeskType, Tag 1033 +func (m NoTrdRegTimestamps) GetDeskType() (f field.DeskTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDeskTypeSource gets DeskTypeSource, Tag 1034 +func (m NoTrdRegTimestamps) GetDeskTypeSource() (f field.DeskTypeSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDeskOrderHandlingInst gets DeskOrderHandlingInst, Tag 1035 +func (m NoTrdRegTimestamps) GetDeskOrderHandlingInst() (f field.DeskOrderHandlingInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasTrdRegTimestamp returns true if TrdRegTimestamp is present, Tag 769 +func (m NoTrdRegTimestamps) HasTrdRegTimestamp() bool { + return m.Has(tag.TrdRegTimestamp) +} + +//HasTrdRegTimestampType returns true if TrdRegTimestampType is present, Tag 770 +func (m NoTrdRegTimestamps) HasTrdRegTimestampType() bool { + return m.Has(tag.TrdRegTimestampType) +} + +//HasTrdRegTimestampOrigin returns true if TrdRegTimestampOrigin is present, Tag 771 +func (m NoTrdRegTimestamps) HasTrdRegTimestampOrigin() bool { + return m.Has(tag.TrdRegTimestampOrigin) +} + +//HasDeskType returns true if DeskType is present, Tag 1033 +func (m NoTrdRegTimestamps) HasDeskType() bool { + return m.Has(tag.DeskType) +} + +//HasDeskTypeSource returns true if DeskTypeSource is present, Tag 1034 +func (m NoTrdRegTimestamps) HasDeskTypeSource() bool { + return m.Has(tag.DeskTypeSource) +} + +//HasDeskOrderHandlingInst returns true if DeskOrderHandlingInst is present, Tag 1035 +func (m NoTrdRegTimestamps) HasDeskOrderHandlingInst() bool { + return m.Has(tag.DeskOrderHandlingInst) +} + +//NoTrdRegTimestampsRepeatingGroup is a repeating group, Tag 768 +type NoTrdRegTimestampsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoTrdRegTimestampsRepeatingGroup returns an initialized, NoTrdRegTimestampsRepeatingGroup +func NewNoTrdRegTimestampsRepeatingGroup() NoTrdRegTimestampsRepeatingGroup { + return NoTrdRegTimestampsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoTrdRegTimestamps, + quickfix.GroupTemplate{quickfix.GroupElement(tag.TrdRegTimestamp), quickfix.GroupElement(tag.TrdRegTimestampType), quickfix.GroupElement(tag.TrdRegTimestampOrigin), quickfix.GroupElement(tag.DeskType), quickfix.GroupElement(tag.DeskTypeSource), quickfix.GroupElement(tag.DeskOrderHandlingInst)})} +} + +//Add create and append a new NoTrdRegTimestamps to this group +func (m NoTrdRegTimestampsRepeatingGroup) Add() NoTrdRegTimestamps { + g := m.RepeatingGroup.Add() + return NoTrdRegTimestamps{g} +} + +//Get returns the ith NoTrdRegTimestamps in the NoTrdRegTimestampsRepeatinGroup +func (m NoTrdRegTimestampsRepeatingGroup) Get(i int) NoTrdRegTimestamps { + return NoTrdRegTimestamps{m.RepeatingGroup.Get(i)} +} + +//NoEvents is a repeating group element, Tag 864 +type NoEvents struct { + quickfix.Group +} + +//SetEventType sets EventType, Tag 865 +func (m NoEvents) SetEventType(v int) { + m.Set(field.NewEventType(v)) +} + +//SetEventDate sets EventDate, Tag 866 +func (m NoEvents) SetEventDate(v string) { + m.Set(field.NewEventDate(v)) +} + +//SetEventPx sets EventPx, Tag 867 +func (m NoEvents) SetEventPx(v float64) { + m.Set(field.NewEventPx(v)) +} + +//SetEventText sets EventText, Tag 868 +func (m NoEvents) SetEventText(v string) { + m.Set(field.NewEventText(v)) +} + +//GetEventType gets EventType, Tag 865 +func (m NoEvents) GetEventType() (f field.EventTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventDate gets EventDate, Tag 866 +func (m NoEvents) GetEventDate() (f field.EventDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventPx gets EventPx, Tag 867 +func (m NoEvents) GetEventPx() (f field.EventPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventText gets EventText, Tag 868 +func (m NoEvents) GetEventText() (f field.EventTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasEventType returns true if EventType is present, Tag 865 +func (m NoEvents) HasEventType() bool { + return m.Has(tag.EventType) +} + +//HasEventDate returns true if EventDate is present, Tag 866 +func (m NoEvents) HasEventDate() bool { + return m.Has(tag.EventDate) +} + +//HasEventPx returns true if EventPx is present, Tag 867 +func (m NoEvents) HasEventPx() bool { + return m.Has(tag.EventPx) +} + +//HasEventText returns true if EventText is present, Tag 868 +func (m NoEvents) HasEventText() bool { + return m.Has(tag.EventText) +} + +//NoEventsRepeatingGroup is a repeating group, Tag 864 +type NoEventsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoEventsRepeatingGroup returns an initialized, NoEventsRepeatingGroup +func NewNoEventsRepeatingGroup() NoEventsRepeatingGroup { + return NoEventsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoEvents, + quickfix.GroupTemplate{quickfix.GroupElement(tag.EventType), quickfix.GroupElement(tag.EventDate), quickfix.GroupElement(tag.EventPx), quickfix.GroupElement(tag.EventText)})} +} + +//Add create and append a new NoEvents to this group +func (m NoEventsRepeatingGroup) Add() NoEvents { + g := m.RepeatingGroup.Add() + return NoEvents{g} +} + +//Get returns the ith NoEvents in the NoEventsRepeatinGroup +func (m NoEventsRepeatingGroup) Get(i int) NoEvents { + return NoEvents{m.RepeatingGroup.Get(i)} +} + +//NoStrategyParameters is a repeating group element, Tag 957 +type NoStrategyParameters struct { + quickfix.Group +} + +//SetStrategyParameterName sets StrategyParameterName, Tag 958 +func (m NoStrategyParameters) SetStrategyParameterName(v string) { + m.Set(field.NewStrategyParameterName(v)) +} + +//SetStrategyParameterType sets StrategyParameterType, Tag 959 +func (m NoStrategyParameters) SetStrategyParameterType(v int) { + m.Set(field.NewStrategyParameterType(v)) +} + +//SetStrategyParameterValue sets StrategyParameterValue, Tag 960 +func (m NoStrategyParameters) SetStrategyParameterValue(v string) { + m.Set(field.NewStrategyParameterValue(v)) +} + +//GetStrategyParameterName gets StrategyParameterName, Tag 958 +func (m NoStrategyParameters) GetStrategyParameterName() (f field.StrategyParameterNameField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrategyParameterType gets StrategyParameterType, Tag 959 +func (m NoStrategyParameters) GetStrategyParameterType() (f field.StrategyParameterTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrategyParameterValue gets StrategyParameterValue, Tag 960 +func (m NoStrategyParameters) GetStrategyParameterValue() (f field.StrategyParameterValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasStrategyParameterName returns true if StrategyParameterName is present, Tag 958 +func (m NoStrategyParameters) HasStrategyParameterName() bool { + return m.Has(tag.StrategyParameterName) +} + +//HasStrategyParameterType returns true if StrategyParameterType is present, Tag 959 +func (m NoStrategyParameters) HasStrategyParameterType() bool { + return m.Has(tag.StrategyParameterType) +} + +//HasStrategyParameterValue returns true if StrategyParameterValue is present, Tag 960 +func (m NoStrategyParameters) HasStrategyParameterValue() bool { + return m.Has(tag.StrategyParameterValue) +} + +//NoStrategyParametersRepeatingGroup is a repeating group, Tag 957 +type NoStrategyParametersRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoStrategyParametersRepeatingGroup returns an initialized, NoStrategyParametersRepeatingGroup +func NewNoStrategyParametersRepeatingGroup() NoStrategyParametersRepeatingGroup { + return NoStrategyParametersRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoStrategyParameters, + quickfix.GroupTemplate{quickfix.GroupElement(tag.StrategyParameterName), quickfix.GroupElement(tag.StrategyParameterType), quickfix.GroupElement(tag.StrategyParameterValue)})} +} + +//Add create and append a new NoStrategyParameters to this group +func (m NoStrategyParametersRepeatingGroup) Add() NoStrategyParameters { + g := m.RepeatingGroup.Add() + return NoStrategyParameters{g} +} + +//Get returns the ith NoStrategyParameters in the NoStrategyParametersRepeatinGroup +func (m NoStrategyParametersRepeatingGroup) Get(i int) NoStrategyParameters { + return NoStrategyParameters{m.RepeatingGroup.Get(i)} +} + +//NoInstrumentParties is a repeating group element, Tag 1018 +type NoInstrumentParties struct { + quickfix.Group +} + +//SetInstrumentPartyID sets InstrumentPartyID, Tag 1019 +func (m NoInstrumentParties) SetInstrumentPartyID(v string) { + m.Set(field.NewInstrumentPartyID(v)) +} + +//SetInstrumentPartyIDSource sets InstrumentPartyIDSource, Tag 1050 +func (m NoInstrumentParties) SetInstrumentPartyIDSource(v string) { + m.Set(field.NewInstrumentPartyIDSource(v)) +} + +//SetInstrumentPartyRole sets InstrumentPartyRole, Tag 1051 +func (m NoInstrumentParties) SetInstrumentPartyRole(v int) { + m.Set(field.NewInstrumentPartyRole(v)) +} + +//SetNoInstrumentPartySubIDs sets NoInstrumentPartySubIDs, Tag 1052 +func (m NoInstrumentParties) SetNoInstrumentPartySubIDs(f NoInstrumentPartySubIDsRepeatingGroup) { + m.SetGroup(f) +} + +//GetInstrumentPartyID gets InstrumentPartyID, Tag 1019 +func (m NoInstrumentParties) GetInstrumentPartyID() (f field.InstrumentPartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrumentPartyIDSource gets InstrumentPartyIDSource, Tag 1050 +func (m NoInstrumentParties) GetInstrumentPartyIDSource() (f field.InstrumentPartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrumentPartyRole gets InstrumentPartyRole, Tag 1051 +func (m NoInstrumentParties) GetInstrumentPartyRole() (f field.InstrumentPartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoInstrumentPartySubIDs gets NoInstrumentPartySubIDs, Tag 1052 +func (m NoInstrumentParties) GetNoInstrumentPartySubIDs() (NoInstrumentPartySubIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoInstrumentPartySubIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasInstrumentPartyID returns true if InstrumentPartyID is present, Tag 1019 +func (m NoInstrumentParties) HasInstrumentPartyID() bool { + return m.Has(tag.InstrumentPartyID) +} + +//HasInstrumentPartyIDSource returns true if InstrumentPartyIDSource is present, Tag 1050 +func (m NoInstrumentParties) HasInstrumentPartyIDSource() bool { + return m.Has(tag.InstrumentPartyIDSource) +} + +//HasInstrumentPartyRole returns true if InstrumentPartyRole is present, Tag 1051 +func (m NoInstrumentParties) HasInstrumentPartyRole() bool { + return m.Has(tag.InstrumentPartyRole) +} + +//HasNoInstrumentPartySubIDs returns true if NoInstrumentPartySubIDs is present, Tag 1052 +func (m NoInstrumentParties) HasNoInstrumentPartySubIDs() bool { + return m.Has(tag.NoInstrumentPartySubIDs) +} + +//NoInstrumentPartySubIDs is a repeating group element, Tag 1052 +type NoInstrumentPartySubIDs struct { + quickfix.Group +} + +//SetInstrumentPartySubID sets InstrumentPartySubID, Tag 1053 +func (m NoInstrumentPartySubIDs) SetInstrumentPartySubID(v string) { + m.Set(field.NewInstrumentPartySubID(v)) +} + +//SetInstrumentPartySubIDType sets InstrumentPartySubIDType, Tag 1054 +func (m NoInstrumentPartySubIDs) SetInstrumentPartySubIDType(v int) { + m.Set(field.NewInstrumentPartySubIDType(v)) +} + +//GetInstrumentPartySubID gets InstrumentPartySubID, Tag 1053 +func (m NoInstrumentPartySubIDs) GetInstrumentPartySubID() (f field.InstrumentPartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrumentPartySubIDType gets InstrumentPartySubIDType, Tag 1054 +func (m NoInstrumentPartySubIDs) GetInstrumentPartySubIDType() (f field.InstrumentPartySubIDTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasInstrumentPartySubID returns true if InstrumentPartySubID is present, Tag 1053 +func (m NoInstrumentPartySubIDs) HasInstrumentPartySubID() bool { + return m.Has(tag.InstrumentPartySubID) +} + +//HasInstrumentPartySubIDType returns true if InstrumentPartySubIDType is present, Tag 1054 +func (m NoInstrumentPartySubIDs) HasInstrumentPartySubIDType() bool { + return m.Has(tag.InstrumentPartySubIDType) +} + +//NoInstrumentPartySubIDsRepeatingGroup is a repeating group, Tag 1052 +type NoInstrumentPartySubIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoInstrumentPartySubIDsRepeatingGroup returns an initialized, NoInstrumentPartySubIDsRepeatingGroup +func NewNoInstrumentPartySubIDsRepeatingGroup() NoInstrumentPartySubIDsRepeatingGroup { + return NoInstrumentPartySubIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoInstrumentPartySubIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.InstrumentPartySubID), quickfix.GroupElement(tag.InstrumentPartySubIDType)})} +} + +//Add create and append a new NoInstrumentPartySubIDs to this group +func (m NoInstrumentPartySubIDsRepeatingGroup) Add() NoInstrumentPartySubIDs { + g := m.RepeatingGroup.Add() + return NoInstrumentPartySubIDs{g} +} + +//Get returns the ith NoInstrumentPartySubIDs in the NoInstrumentPartySubIDsRepeatinGroup +func (m NoInstrumentPartySubIDsRepeatingGroup) Get(i int) NoInstrumentPartySubIDs { + return NoInstrumentPartySubIDs{m.RepeatingGroup.Get(i)} +} + +//NoInstrumentPartiesRepeatingGroup is a repeating group, Tag 1018 +type NoInstrumentPartiesRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoInstrumentPartiesRepeatingGroup returns an initialized, NoInstrumentPartiesRepeatingGroup +func NewNoInstrumentPartiesRepeatingGroup() NoInstrumentPartiesRepeatingGroup { + return NoInstrumentPartiesRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoInstrumentParties, + quickfix.GroupTemplate{quickfix.GroupElement(tag.InstrumentPartyID), quickfix.GroupElement(tag.InstrumentPartyIDSource), quickfix.GroupElement(tag.InstrumentPartyRole), NewNoInstrumentPartySubIDsRepeatingGroup()})} +} + +//Add create and append a new NoInstrumentParties to this group +func (m NoInstrumentPartiesRepeatingGroup) Add() NoInstrumentParties { + g := m.RepeatingGroup.Add() + return NoInstrumentParties{g} +} + +//Get returns the ith NoInstrumentParties in the NoInstrumentPartiesRepeatinGroup +func (m NoInstrumentPartiesRepeatingGroup) Get(i int) NoInstrumentParties { + return NoInstrumentParties{m.RepeatingGroup.Get(i)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix50/marketdatarequest/MarketDataRequest.generated.go b/vendor/github.com/quickfixgo/quickfix/fix50/marketdatarequest/MarketDataRequest.generated.go new file mode 100644 index 0000000..c00cbab --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix50/marketdatarequest/MarketDataRequest.generated.go @@ -0,0 +1,3734 @@ +package marketdatarequest + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fixt11" + "github.com/quickfixgo/quickfix/tag" +) + +//MarketDataRequest is the fix50 MarketDataRequest type, MsgType = V +type MarketDataRequest struct { + fixt11.Header + quickfix.Body + fixt11.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a MarketDataRequest from a quickfix.Message instance +func FromMessage(m quickfix.Message) MarketDataRequest { + return MarketDataRequest{ + Header: fixt11.Header{Header: m.Header}, + Body: m.Body, + Trailer: fixt11.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m MarketDataRequest) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a MarketDataRequest initialized with the required fields for MarketDataRequest +func New(mdreqid field.MDReqIDField, subscriptionrequesttype field.SubscriptionRequestTypeField, marketdepth field.MarketDepthField) (m MarketDataRequest) { + m.Header = fixt11.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("V")) + m.Set(mdreqid) + m.Set(subscriptionrequesttype) + m.Set(marketdepth) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg MarketDataRequest, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "7", "V", r +} + +//SetNoRelatedSym sets NoRelatedSym, Tag 146 +func (m MarketDataRequest) SetNoRelatedSym(f NoRelatedSymRepeatingGroup) { + m.SetGroup(f) +} + +//SetMDReqID sets MDReqID, Tag 262 +func (m MarketDataRequest) SetMDReqID(v string) { + m.Set(field.NewMDReqID(v)) +} + +//SetSubscriptionRequestType sets SubscriptionRequestType, Tag 263 +func (m MarketDataRequest) SetSubscriptionRequestType(v string) { + m.Set(field.NewSubscriptionRequestType(v)) +} + +//SetMarketDepth sets MarketDepth, Tag 264 +func (m MarketDataRequest) SetMarketDepth(v int) { + m.Set(field.NewMarketDepth(v)) +} + +//SetMDUpdateType sets MDUpdateType, Tag 265 +func (m MarketDataRequest) SetMDUpdateType(v int) { + m.Set(field.NewMDUpdateType(v)) +} + +//SetAggregatedBook sets AggregatedBook, Tag 266 +func (m MarketDataRequest) SetAggregatedBook(v bool) { + m.Set(field.NewAggregatedBook(v)) +} + +//SetNoMDEntryTypes sets NoMDEntryTypes, Tag 267 +func (m MarketDataRequest) SetNoMDEntryTypes(f NoMDEntryTypesRepeatingGroup) { + m.SetGroup(f) +} + +//SetOpenCloseSettlFlag sets OpenCloseSettlFlag, Tag 286 +func (m MarketDataRequest) SetOpenCloseSettlFlag(v string) { + m.Set(field.NewOpenCloseSettlFlag(v)) +} + +//SetNoTradingSessions sets NoTradingSessions, Tag 386 +func (m MarketDataRequest) SetNoTradingSessions(f NoTradingSessionsRepeatingGroup) { + m.SetGroup(f) +} + +//SetScope sets Scope, Tag 546 +func (m MarketDataRequest) SetScope(v string) { + m.Set(field.NewScope(v)) +} + +//SetMDImplicitDelete sets MDImplicitDelete, Tag 547 +func (m MarketDataRequest) SetMDImplicitDelete(v bool) { + m.Set(field.NewMDImplicitDelete(v)) +} + +//SetApplQueueMax sets ApplQueueMax, Tag 812 +func (m MarketDataRequest) SetApplQueueMax(v int) { + m.Set(field.NewApplQueueMax(v)) +} + +//SetApplQueueAction sets ApplQueueAction, Tag 815 +func (m MarketDataRequest) SetApplQueueAction(v int) { + m.Set(field.NewApplQueueAction(v)) +} + +//SetMDQuoteType sets MDQuoteType, Tag 1070 +func (m MarketDataRequest) SetMDQuoteType(v int) { + m.Set(field.NewMDQuoteType(v)) +} + +//GetNoRelatedSym gets NoRelatedSym, Tag 146 +func (m MarketDataRequest) GetNoRelatedSym() (NoRelatedSymRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoRelatedSymRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetMDReqID gets MDReqID, Tag 262 +func (m MarketDataRequest) GetMDReqID() (f field.MDReqIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSubscriptionRequestType gets SubscriptionRequestType, Tag 263 +func (m MarketDataRequest) GetSubscriptionRequestType() (f field.SubscriptionRequestTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMarketDepth gets MarketDepth, Tag 264 +func (m MarketDataRequest) GetMarketDepth() (f field.MarketDepthField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMDUpdateType gets MDUpdateType, Tag 265 +func (m MarketDataRequest) GetMDUpdateType() (f field.MDUpdateTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAggregatedBook gets AggregatedBook, Tag 266 +func (m MarketDataRequest) GetAggregatedBook() (f field.AggregatedBookField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoMDEntryTypes gets NoMDEntryTypes, Tag 267 +func (m MarketDataRequest) GetNoMDEntryTypes() (NoMDEntryTypesRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoMDEntryTypesRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetOpenCloseSettlFlag gets OpenCloseSettlFlag, Tag 286 +func (m MarketDataRequest) GetOpenCloseSettlFlag() (f field.OpenCloseSettlFlagField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoTradingSessions gets NoTradingSessions, Tag 386 +func (m MarketDataRequest) GetNoTradingSessions() (NoTradingSessionsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoTradingSessionsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetScope gets Scope, Tag 546 +func (m MarketDataRequest) GetScope() (f field.ScopeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMDImplicitDelete gets MDImplicitDelete, Tag 547 +func (m MarketDataRequest) GetMDImplicitDelete() (f field.MDImplicitDeleteField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetApplQueueMax gets ApplQueueMax, Tag 812 +func (m MarketDataRequest) GetApplQueueMax() (f field.ApplQueueMaxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetApplQueueAction gets ApplQueueAction, Tag 815 +func (m MarketDataRequest) GetApplQueueAction() (f field.ApplQueueActionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMDQuoteType gets MDQuoteType, Tag 1070 +func (m MarketDataRequest) GetMDQuoteType() (f field.MDQuoteTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasNoRelatedSym returns true if NoRelatedSym is present, Tag 146 +func (m MarketDataRequest) HasNoRelatedSym() bool { + return m.Has(tag.NoRelatedSym) +} + +//HasMDReqID returns true if MDReqID is present, Tag 262 +func (m MarketDataRequest) HasMDReqID() bool { + return m.Has(tag.MDReqID) +} + +//HasSubscriptionRequestType returns true if SubscriptionRequestType is present, Tag 263 +func (m MarketDataRequest) HasSubscriptionRequestType() bool { + return m.Has(tag.SubscriptionRequestType) +} + +//HasMarketDepth returns true if MarketDepth is present, Tag 264 +func (m MarketDataRequest) HasMarketDepth() bool { + return m.Has(tag.MarketDepth) +} + +//HasMDUpdateType returns true if MDUpdateType is present, Tag 265 +func (m MarketDataRequest) HasMDUpdateType() bool { + return m.Has(tag.MDUpdateType) +} + +//HasAggregatedBook returns true if AggregatedBook is present, Tag 266 +func (m MarketDataRequest) HasAggregatedBook() bool { + return m.Has(tag.AggregatedBook) +} + +//HasNoMDEntryTypes returns true if NoMDEntryTypes is present, Tag 267 +func (m MarketDataRequest) HasNoMDEntryTypes() bool { + return m.Has(tag.NoMDEntryTypes) +} + +//HasOpenCloseSettlFlag returns true if OpenCloseSettlFlag is present, Tag 286 +func (m MarketDataRequest) HasOpenCloseSettlFlag() bool { + return m.Has(tag.OpenCloseSettlFlag) +} + +//HasNoTradingSessions returns true if NoTradingSessions is present, Tag 386 +func (m MarketDataRequest) HasNoTradingSessions() bool { + return m.Has(tag.NoTradingSessions) +} + +//HasScope returns true if Scope is present, Tag 546 +func (m MarketDataRequest) HasScope() bool { + return m.Has(tag.Scope) +} + +//HasMDImplicitDelete returns true if MDImplicitDelete is present, Tag 547 +func (m MarketDataRequest) HasMDImplicitDelete() bool { + return m.Has(tag.MDImplicitDelete) +} + +//HasApplQueueMax returns true if ApplQueueMax is present, Tag 812 +func (m MarketDataRequest) HasApplQueueMax() bool { + return m.Has(tag.ApplQueueMax) +} + +//HasApplQueueAction returns true if ApplQueueAction is present, Tag 815 +func (m MarketDataRequest) HasApplQueueAction() bool { + return m.Has(tag.ApplQueueAction) +} + +//HasMDQuoteType returns true if MDQuoteType is present, Tag 1070 +func (m MarketDataRequest) HasMDQuoteType() bool { + return m.Has(tag.MDQuoteType) +} + +//NoRelatedSym is a repeating group element, Tag 146 +type NoRelatedSym struct { + quickfix.Group +} + +//SetSymbol sets Symbol, Tag 55 +func (m NoRelatedSym) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m NoRelatedSym) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m NoRelatedSym) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSecurityIDSource sets SecurityIDSource, Tag 22 +func (m NoRelatedSym) SetSecurityIDSource(v string) { + m.Set(field.NewSecurityIDSource(v)) +} + +//SetNoSecurityAltID sets NoSecurityAltID, Tag 454 +func (m NoRelatedSym) SetNoSecurityAltID(f NoSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetProduct sets Product, Tag 460 +func (m NoRelatedSym) SetProduct(v int) { + m.Set(field.NewProduct(v)) +} + +//SetCFICode sets CFICode, Tag 461 +func (m NoRelatedSym) SetCFICode(v string) { + m.Set(field.NewCFICode(v)) +} + +//SetSecurityType sets SecurityType, Tag 167 +func (m NoRelatedSym) SetSecurityType(v string) { + m.Set(field.NewSecurityType(v)) +} + +//SetSecuritySubType sets SecuritySubType, Tag 762 +func (m NoRelatedSym) SetSecuritySubType(v string) { + m.Set(field.NewSecuritySubType(v)) +} + +//SetMaturityMonthYear sets MaturityMonthYear, Tag 200 +func (m NoRelatedSym) SetMaturityMonthYear(v string) { + m.Set(field.NewMaturityMonthYear(v)) +} + +//SetMaturityDate sets MaturityDate, Tag 541 +func (m NoRelatedSym) SetMaturityDate(v string) { + m.Set(field.NewMaturityDate(v)) +} + +//SetCouponPaymentDate sets CouponPaymentDate, Tag 224 +func (m NoRelatedSym) SetCouponPaymentDate(v string) { + m.Set(field.NewCouponPaymentDate(v)) +} + +//SetIssueDate sets IssueDate, Tag 225 +func (m NoRelatedSym) SetIssueDate(v string) { + m.Set(field.NewIssueDate(v)) +} + +//SetRepoCollateralSecurityType sets RepoCollateralSecurityType, Tag 239 +func (m NoRelatedSym) SetRepoCollateralSecurityType(v int) { + m.Set(field.NewRepoCollateralSecurityType(v)) +} + +//SetRepurchaseTerm sets RepurchaseTerm, Tag 226 +func (m NoRelatedSym) SetRepurchaseTerm(v int) { + m.Set(field.NewRepurchaseTerm(v)) +} + +//SetRepurchaseRate sets RepurchaseRate, Tag 227 +func (m NoRelatedSym) SetRepurchaseRate(v float64) { + m.Set(field.NewRepurchaseRate(v)) +} + +//SetFactor sets Factor, Tag 228 +func (m NoRelatedSym) SetFactor(v float64) { + m.Set(field.NewFactor(v)) +} + +//SetCreditRating sets CreditRating, Tag 255 +func (m NoRelatedSym) SetCreditRating(v string) { + m.Set(field.NewCreditRating(v)) +} + +//SetInstrRegistry sets InstrRegistry, Tag 543 +func (m NoRelatedSym) SetInstrRegistry(v string) { + m.Set(field.NewInstrRegistry(v)) +} + +//SetCountryOfIssue sets CountryOfIssue, Tag 470 +func (m NoRelatedSym) SetCountryOfIssue(v string) { + m.Set(field.NewCountryOfIssue(v)) +} + +//SetStateOrProvinceOfIssue sets StateOrProvinceOfIssue, Tag 471 +func (m NoRelatedSym) SetStateOrProvinceOfIssue(v string) { + m.Set(field.NewStateOrProvinceOfIssue(v)) +} + +//SetLocaleOfIssue sets LocaleOfIssue, Tag 472 +func (m NoRelatedSym) SetLocaleOfIssue(v string) { + m.Set(field.NewLocaleOfIssue(v)) +} + +//SetRedemptionDate sets RedemptionDate, Tag 240 +func (m NoRelatedSym) SetRedemptionDate(v string) { + m.Set(field.NewRedemptionDate(v)) +} + +//SetStrikePrice sets StrikePrice, Tag 202 +func (m NoRelatedSym) SetStrikePrice(v float64) { + m.Set(field.NewStrikePrice(v)) +} + +//SetStrikeCurrency sets StrikeCurrency, Tag 947 +func (m NoRelatedSym) SetStrikeCurrency(v string) { + m.Set(field.NewStrikeCurrency(v)) +} + +//SetOptAttribute sets OptAttribute, Tag 206 +func (m NoRelatedSym) SetOptAttribute(v string) { + m.Set(field.NewOptAttribute(v)) +} + +//SetContractMultiplier sets ContractMultiplier, Tag 231 +func (m NoRelatedSym) SetContractMultiplier(v float64) { + m.Set(field.NewContractMultiplier(v)) +} + +//SetCouponRate sets CouponRate, Tag 223 +func (m NoRelatedSym) SetCouponRate(v float64) { + m.Set(field.NewCouponRate(v)) +} + +//SetSecurityExchange sets SecurityExchange, Tag 207 +func (m NoRelatedSym) SetSecurityExchange(v string) { + m.Set(field.NewSecurityExchange(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m NoRelatedSym) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetEncodedIssuerLen sets EncodedIssuerLen, Tag 348 +func (m NoRelatedSym) SetEncodedIssuerLen(v int) { + m.Set(field.NewEncodedIssuerLen(v)) +} + +//SetEncodedIssuer sets EncodedIssuer, Tag 349 +func (m NoRelatedSym) SetEncodedIssuer(v string) { + m.Set(field.NewEncodedIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m NoRelatedSym) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetEncodedSecurityDescLen sets EncodedSecurityDescLen, Tag 350 +func (m NoRelatedSym) SetEncodedSecurityDescLen(v int) { + m.Set(field.NewEncodedSecurityDescLen(v)) +} + +//SetEncodedSecurityDesc sets EncodedSecurityDesc, Tag 351 +func (m NoRelatedSym) SetEncodedSecurityDesc(v string) { + m.Set(field.NewEncodedSecurityDesc(v)) +} + +//SetPool sets Pool, Tag 691 +func (m NoRelatedSym) SetPool(v string) { + m.Set(field.NewPool(v)) +} + +//SetContractSettlMonth sets ContractSettlMonth, Tag 667 +func (m NoRelatedSym) SetContractSettlMonth(v string) { + m.Set(field.NewContractSettlMonth(v)) +} + +//SetCPProgram sets CPProgram, Tag 875 +func (m NoRelatedSym) SetCPProgram(v int) { + m.Set(field.NewCPProgram(v)) +} + +//SetCPRegType sets CPRegType, Tag 876 +func (m NoRelatedSym) SetCPRegType(v string) { + m.Set(field.NewCPRegType(v)) +} + +//SetNoEvents sets NoEvents, Tag 864 +func (m NoRelatedSym) SetNoEvents(f NoEventsRepeatingGroup) { + m.SetGroup(f) +} + +//SetDatedDate sets DatedDate, Tag 873 +func (m NoRelatedSym) SetDatedDate(v string) { + m.Set(field.NewDatedDate(v)) +} + +//SetInterestAccrualDate sets InterestAccrualDate, Tag 874 +func (m NoRelatedSym) SetInterestAccrualDate(v string) { + m.Set(field.NewInterestAccrualDate(v)) +} + +//SetSecurityStatus sets SecurityStatus, Tag 965 +func (m NoRelatedSym) SetSecurityStatus(v string) { + m.Set(field.NewSecurityStatus(v)) +} + +//SetSettleOnOpenFlag sets SettleOnOpenFlag, Tag 966 +func (m NoRelatedSym) SetSettleOnOpenFlag(v string) { + m.Set(field.NewSettleOnOpenFlag(v)) +} + +//SetInstrmtAssignmentMethod sets InstrmtAssignmentMethod, Tag 1049 +func (m NoRelatedSym) SetInstrmtAssignmentMethod(v string) { + m.Set(field.NewInstrmtAssignmentMethod(v)) +} + +//SetStrikeMultiplier sets StrikeMultiplier, Tag 967 +func (m NoRelatedSym) SetStrikeMultiplier(v float64) { + m.Set(field.NewStrikeMultiplier(v)) +} + +//SetStrikeValue sets StrikeValue, Tag 968 +func (m NoRelatedSym) SetStrikeValue(v float64) { + m.Set(field.NewStrikeValue(v)) +} + +//SetMinPriceIncrement sets MinPriceIncrement, Tag 969 +func (m NoRelatedSym) SetMinPriceIncrement(v float64) { + m.Set(field.NewMinPriceIncrement(v)) +} + +//SetPositionLimit sets PositionLimit, Tag 970 +func (m NoRelatedSym) SetPositionLimit(v int) { + m.Set(field.NewPositionLimit(v)) +} + +//SetNTPositionLimit sets NTPositionLimit, Tag 971 +func (m NoRelatedSym) SetNTPositionLimit(v int) { + m.Set(field.NewNTPositionLimit(v)) +} + +//SetNoInstrumentParties sets NoInstrumentParties, Tag 1018 +func (m NoRelatedSym) SetNoInstrumentParties(f NoInstrumentPartiesRepeatingGroup) { + m.SetGroup(f) +} + +//SetUnitOfMeasure sets UnitOfMeasure, Tag 996 +func (m NoRelatedSym) SetUnitOfMeasure(v string) { + m.Set(field.NewUnitOfMeasure(v)) +} + +//SetTimeUnit sets TimeUnit, Tag 997 +func (m NoRelatedSym) SetTimeUnit(v string) { + m.Set(field.NewTimeUnit(v)) +} + +//SetMaturityTime sets MaturityTime, Tag 1079 +func (m NoRelatedSym) SetMaturityTime(v string) { + m.Set(field.NewMaturityTime(v)) +} + +//SetNoUnderlyings sets NoUnderlyings, Tag 711 +func (m NoRelatedSym) SetNoUnderlyings(f NoUnderlyingsRepeatingGroup) { + m.SetGroup(f) +} + +//SetNoLegs sets NoLegs, Tag 555 +func (m NoRelatedSym) SetNoLegs(f NoLegsRepeatingGroup) { + m.SetGroup(f) +} + +//SetCurrency sets Currency, Tag 15 +func (m NoRelatedSym) SetCurrency(v string) { + m.Set(field.NewCurrency(v)) +} + +//SetQuoteType sets QuoteType, Tag 537 +func (m NoRelatedSym) SetQuoteType(v int) { + m.Set(field.NewQuoteType(v)) +} + +//SetSettlType sets SettlType, Tag 63 +func (m NoRelatedSym) SetSettlType(v string) { + m.Set(field.NewSettlType(v)) +} + +//SetSettlDate sets SettlDate, Tag 64 +func (m NoRelatedSym) SetSettlDate(v string) { + m.Set(field.NewSettlDate(v)) +} + +//SetMDEntrySize sets MDEntrySize, Tag 271 +func (m NoRelatedSym) SetMDEntrySize(v float64) { + m.Set(field.NewMDEntrySize(v)) +} + +//GetSymbol gets Symbol, Tag 55 +func (m NoRelatedSym) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m NoRelatedSym) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m NoRelatedSym) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityIDSource gets SecurityIDSource, Tag 22 +func (m NoRelatedSym) GetSecurityIDSource() (f field.SecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoSecurityAltID gets NoSecurityAltID, Tag 454 +func (m NoRelatedSym) GetNoSecurityAltID() (NoSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetProduct gets Product, Tag 460 +func (m NoRelatedSym) GetProduct() (f field.ProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCFICode gets CFICode, Tag 461 +func (m NoRelatedSym) GetCFICode() (f field.CFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityType gets SecurityType, Tag 167 +func (m NoRelatedSym) GetSecurityType() (f field.SecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecuritySubType gets SecuritySubType, Tag 762 +func (m NoRelatedSym) GetSecuritySubType() (f field.SecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityMonthYear gets MaturityMonthYear, Tag 200 +func (m NoRelatedSym) GetMaturityMonthYear() (f field.MaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityDate gets MaturityDate, Tag 541 +func (m NoRelatedSym) GetMaturityDate() (f field.MaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponPaymentDate gets CouponPaymentDate, Tag 224 +func (m NoRelatedSym) GetCouponPaymentDate() (f field.CouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssueDate gets IssueDate, Tag 225 +func (m NoRelatedSym) GetIssueDate() (f field.IssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepoCollateralSecurityType gets RepoCollateralSecurityType, Tag 239 +func (m NoRelatedSym) GetRepoCollateralSecurityType() (f field.RepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseTerm gets RepurchaseTerm, Tag 226 +func (m NoRelatedSym) GetRepurchaseTerm() (f field.RepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseRate gets RepurchaseRate, Tag 227 +func (m NoRelatedSym) GetRepurchaseRate() (f field.RepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFactor gets Factor, Tag 228 +func (m NoRelatedSym) GetFactor() (f field.FactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCreditRating gets CreditRating, Tag 255 +func (m NoRelatedSym) GetCreditRating() (f field.CreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrRegistry gets InstrRegistry, Tag 543 +func (m NoRelatedSym) GetInstrRegistry() (f field.InstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCountryOfIssue gets CountryOfIssue, Tag 470 +func (m NoRelatedSym) GetCountryOfIssue() (f field.CountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStateOrProvinceOfIssue gets StateOrProvinceOfIssue, Tag 471 +func (m NoRelatedSym) GetStateOrProvinceOfIssue() (f field.StateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLocaleOfIssue gets LocaleOfIssue, Tag 472 +func (m NoRelatedSym) GetLocaleOfIssue() (f field.LocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRedemptionDate gets RedemptionDate, Tag 240 +func (m NoRelatedSym) GetRedemptionDate() (f field.RedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikePrice gets StrikePrice, Tag 202 +func (m NoRelatedSym) GetStrikePrice() (f field.StrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikeCurrency gets StrikeCurrency, Tag 947 +func (m NoRelatedSym) GetStrikeCurrency() (f field.StrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOptAttribute gets OptAttribute, Tag 206 +func (m NoRelatedSym) GetOptAttribute() (f field.OptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractMultiplier gets ContractMultiplier, Tag 231 +func (m NoRelatedSym) GetContractMultiplier() (f field.ContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponRate gets CouponRate, Tag 223 +func (m NoRelatedSym) GetCouponRate() (f field.CouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityExchange gets SecurityExchange, Tag 207 +func (m NoRelatedSym) GetSecurityExchange() (f field.SecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m NoRelatedSym) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuerLen gets EncodedIssuerLen, Tag 348 +func (m NoRelatedSym) GetEncodedIssuerLen() (f field.EncodedIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuer gets EncodedIssuer, Tag 349 +func (m NoRelatedSym) GetEncodedIssuer() (f field.EncodedIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m NoRelatedSym) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDescLen gets EncodedSecurityDescLen, Tag 350 +func (m NoRelatedSym) GetEncodedSecurityDescLen() (f field.EncodedSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDesc gets EncodedSecurityDesc, Tag 351 +func (m NoRelatedSym) GetEncodedSecurityDesc() (f field.EncodedSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPool gets Pool, Tag 691 +func (m NoRelatedSym) GetPool() (f field.PoolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractSettlMonth gets ContractSettlMonth, Tag 667 +func (m NoRelatedSym) GetContractSettlMonth() (f field.ContractSettlMonthField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCPProgram gets CPProgram, Tag 875 +func (m NoRelatedSym) GetCPProgram() (f field.CPProgramField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCPRegType gets CPRegType, Tag 876 +func (m NoRelatedSym) GetCPRegType() (f field.CPRegTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoEvents gets NoEvents, Tag 864 +func (m NoRelatedSym) GetNoEvents() (NoEventsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoEventsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetDatedDate gets DatedDate, Tag 873 +func (m NoRelatedSym) GetDatedDate() (f field.DatedDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInterestAccrualDate gets InterestAccrualDate, Tag 874 +func (m NoRelatedSym) GetInterestAccrualDate() (f field.InterestAccrualDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityStatus gets SecurityStatus, Tag 965 +func (m NoRelatedSym) GetSecurityStatus() (f field.SecurityStatusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettleOnOpenFlag gets SettleOnOpenFlag, Tag 966 +func (m NoRelatedSym) GetSettleOnOpenFlag() (f field.SettleOnOpenFlagField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrmtAssignmentMethod gets InstrmtAssignmentMethod, Tag 1049 +func (m NoRelatedSym) GetInstrmtAssignmentMethod() (f field.InstrmtAssignmentMethodField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikeMultiplier gets StrikeMultiplier, Tag 967 +func (m NoRelatedSym) GetStrikeMultiplier() (f field.StrikeMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikeValue gets StrikeValue, Tag 968 +func (m NoRelatedSym) GetStrikeValue() (f field.StrikeValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMinPriceIncrement gets MinPriceIncrement, Tag 969 +func (m NoRelatedSym) GetMinPriceIncrement() (f field.MinPriceIncrementField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPositionLimit gets PositionLimit, Tag 970 +func (m NoRelatedSym) GetPositionLimit() (f field.PositionLimitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNTPositionLimit gets NTPositionLimit, Tag 971 +func (m NoRelatedSym) GetNTPositionLimit() (f field.NTPositionLimitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoInstrumentParties gets NoInstrumentParties, Tag 1018 +func (m NoRelatedSym) GetNoInstrumentParties() (NoInstrumentPartiesRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoInstrumentPartiesRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetUnitOfMeasure gets UnitOfMeasure, Tag 996 +func (m NoRelatedSym) GetUnitOfMeasure() (f field.UnitOfMeasureField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTimeUnit gets TimeUnit, Tag 997 +func (m NoRelatedSym) GetTimeUnit() (f field.TimeUnitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityTime gets MaturityTime, Tag 1079 +func (m NoRelatedSym) GetMaturityTime() (f field.MaturityTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyings gets NoUnderlyings, Tag 711 +func (m NoRelatedSym) GetNoUnderlyings() (NoUnderlyingsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetNoLegs gets NoLegs, Tag 555 +func (m NoRelatedSym) GetNoLegs() (NoLegsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoLegsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetCurrency gets Currency, Tag 15 +func (m NoRelatedSym) GetCurrency() (f field.CurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetQuoteType gets QuoteType, Tag 537 +func (m NoRelatedSym) GetQuoteType() (f field.QuoteTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlType gets SettlType, Tag 63 +func (m NoRelatedSym) GetSettlType() (f field.SettlTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlDate gets SettlDate, Tag 64 +func (m NoRelatedSym) GetSettlDate() (f field.SettlDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMDEntrySize gets MDEntrySize, Tag 271 +func (m NoRelatedSym) GetMDEntrySize() (f field.MDEntrySizeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m NoRelatedSym) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m NoRelatedSym) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m NoRelatedSym) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSecurityIDSource returns true if SecurityIDSource is present, Tag 22 +func (m NoRelatedSym) HasSecurityIDSource() bool { + return m.Has(tag.SecurityIDSource) +} + +//HasNoSecurityAltID returns true if NoSecurityAltID is present, Tag 454 +func (m NoRelatedSym) HasNoSecurityAltID() bool { + return m.Has(tag.NoSecurityAltID) +} + +//HasProduct returns true if Product is present, Tag 460 +func (m NoRelatedSym) HasProduct() bool { + return m.Has(tag.Product) +} + +//HasCFICode returns true if CFICode is present, Tag 461 +func (m NoRelatedSym) HasCFICode() bool { + return m.Has(tag.CFICode) +} + +//HasSecurityType returns true if SecurityType is present, Tag 167 +func (m NoRelatedSym) HasSecurityType() bool { + return m.Has(tag.SecurityType) +} + +//HasSecuritySubType returns true if SecuritySubType is present, Tag 762 +func (m NoRelatedSym) HasSecuritySubType() bool { + return m.Has(tag.SecuritySubType) +} + +//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200 +func (m NoRelatedSym) HasMaturityMonthYear() bool { + return m.Has(tag.MaturityMonthYear) +} + +//HasMaturityDate returns true if MaturityDate is present, Tag 541 +func (m NoRelatedSym) HasMaturityDate() bool { + return m.Has(tag.MaturityDate) +} + +//HasCouponPaymentDate returns true if CouponPaymentDate is present, Tag 224 +func (m NoRelatedSym) HasCouponPaymentDate() bool { + return m.Has(tag.CouponPaymentDate) +} + +//HasIssueDate returns true if IssueDate is present, Tag 225 +func (m NoRelatedSym) HasIssueDate() bool { + return m.Has(tag.IssueDate) +} + +//HasRepoCollateralSecurityType returns true if RepoCollateralSecurityType is present, Tag 239 +func (m NoRelatedSym) HasRepoCollateralSecurityType() bool { + return m.Has(tag.RepoCollateralSecurityType) +} + +//HasRepurchaseTerm returns true if RepurchaseTerm is present, Tag 226 +func (m NoRelatedSym) HasRepurchaseTerm() bool { + return m.Has(tag.RepurchaseTerm) +} + +//HasRepurchaseRate returns true if RepurchaseRate is present, Tag 227 +func (m NoRelatedSym) HasRepurchaseRate() bool { + return m.Has(tag.RepurchaseRate) +} + +//HasFactor returns true if Factor is present, Tag 228 +func (m NoRelatedSym) HasFactor() bool { + return m.Has(tag.Factor) +} + +//HasCreditRating returns true if CreditRating is present, Tag 255 +func (m NoRelatedSym) HasCreditRating() bool { + return m.Has(tag.CreditRating) +} + +//HasInstrRegistry returns true if InstrRegistry is present, Tag 543 +func (m NoRelatedSym) HasInstrRegistry() bool { + return m.Has(tag.InstrRegistry) +} + +//HasCountryOfIssue returns true if CountryOfIssue is present, Tag 470 +func (m NoRelatedSym) HasCountryOfIssue() bool { + return m.Has(tag.CountryOfIssue) +} + +//HasStateOrProvinceOfIssue returns true if StateOrProvinceOfIssue is present, Tag 471 +func (m NoRelatedSym) HasStateOrProvinceOfIssue() bool { + return m.Has(tag.StateOrProvinceOfIssue) +} + +//HasLocaleOfIssue returns true if LocaleOfIssue is present, Tag 472 +func (m NoRelatedSym) HasLocaleOfIssue() bool { + return m.Has(tag.LocaleOfIssue) +} + +//HasRedemptionDate returns true if RedemptionDate is present, Tag 240 +func (m NoRelatedSym) HasRedemptionDate() bool { + return m.Has(tag.RedemptionDate) +} + +//HasStrikePrice returns true if StrikePrice is present, Tag 202 +func (m NoRelatedSym) HasStrikePrice() bool { + return m.Has(tag.StrikePrice) +} + +//HasStrikeCurrency returns true if StrikeCurrency is present, Tag 947 +func (m NoRelatedSym) HasStrikeCurrency() bool { + return m.Has(tag.StrikeCurrency) +} + +//HasOptAttribute returns true if OptAttribute is present, Tag 206 +func (m NoRelatedSym) HasOptAttribute() bool { + return m.Has(tag.OptAttribute) +} + +//HasContractMultiplier returns true if ContractMultiplier is present, Tag 231 +func (m NoRelatedSym) HasContractMultiplier() bool { + return m.Has(tag.ContractMultiplier) +} + +//HasCouponRate returns true if CouponRate is present, Tag 223 +func (m NoRelatedSym) HasCouponRate() bool { + return m.Has(tag.CouponRate) +} + +//HasSecurityExchange returns true if SecurityExchange is present, Tag 207 +func (m NoRelatedSym) HasSecurityExchange() bool { + return m.Has(tag.SecurityExchange) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m NoRelatedSym) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasEncodedIssuerLen returns true if EncodedIssuerLen is present, Tag 348 +func (m NoRelatedSym) HasEncodedIssuerLen() bool { + return m.Has(tag.EncodedIssuerLen) +} + +//HasEncodedIssuer returns true if EncodedIssuer is present, Tag 349 +func (m NoRelatedSym) HasEncodedIssuer() bool { + return m.Has(tag.EncodedIssuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m NoRelatedSym) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasEncodedSecurityDescLen returns true if EncodedSecurityDescLen is present, Tag 350 +func (m NoRelatedSym) HasEncodedSecurityDescLen() bool { + return m.Has(tag.EncodedSecurityDescLen) +} + +//HasEncodedSecurityDesc returns true if EncodedSecurityDesc is present, Tag 351 +func (m NoRelatedSym) HasEncodedSecurityDesc() bool { + return m.Has(tag.EncodedSecurityDesc) +} + +//HasPool returns true if Pool is present, Tag 691 +func (m NoRelatedSym) HasPool() bool { + return m.Has(tag.Pool) +} + +//HasContractSettlMonth returns true if ContractSettlMonth is present, Tag 667 +func (m NoRelatedSym) HasContractSettlMonth() bool { + return m.Has(tag.ContractSettlMonth) +} + +//HasCPProgram returns true if CPProgram is present, Tag 875 +func (m NoRelatedSym) HasCPProgram() bool { + return m.Has(tag.CPProgram) +} + +//HasCPRegType returns true if CPRegType is present, Tag 876 +func (m NoRelatedSym) HasCPRegType() bool { + return m.Has(tag.CPRegType) +} + +//HasNoEvents returns true if NoEvents is present, Tag 864 +func (m NoRelatedSym) HasNoEvents() bool { + return m.Has(tag.NoEvents) +} + +//HasDatedDate returns true if DatedDate is present, Tag 873 +func (m NoRelatedSym) HasDatedDate() bool { + return m.Has(tag.DatedDate) +} + +//HasInterestAccrualDate returns true if InterestAccrualDate is present, Tag 874 +func (m NoRelatedSym) HasInterestAccrualDate() bool { + return m.Has(tag.InterestAccrualDate) +} + +//HasSecurityStatus returns true if SecurityStatus is present, Tag 965 +func (m NoRelatedSym) HasSecurityStatus() bool { + return m.Has(tag.SecurityStatus) +} + +//HasSettleOnOpenFlag returns true if SettleOnOpenFlag is present, Tag 966 +func (m NoRelatedSym) HasSettleOnOpenFlag() bool { + return m.Has(tag.SettleOnOpenFlag) +} + +//HasInstrmtAssignmentMethod returns true if InstrmtAssignmentMethod is present, Tag 1049 +func (m NoRelatedSym) HasInstrmtAssignmentMethod() bool { + return m.Has(tag.InstrmtAssignmentMethod) +} + +//HasStrikeMultiplier returns true if StrikeMultiplier is present, Tag 967 +func (m NoRelatedSym) HasStrikeMultiplier() bool { + return m.Has(tag.StrikeMultiplier) +} + +//HasStrikeValue returns true if StrikeValue is present, Tag 968 +func (m NoRelatedSym) HasStrikeValue() bool { + return m.Has(tag.StrikeValue) +} + +//HasMinPriceIncrement returns true if MinPriceIncrement is present, Tag 969 +func (m NoRelatedSym) HasMinPriceIncrement() bool { + return m.Has(tag.MinPriceIncrement) +} + +//HasPositionLimit returns true if PositionLimit is present, Tag 970 +func (m NoRelatedSym) HasPositionLimit() bool { + return m.Has(tag.PositionLimit) +} + +//HasNTPositionLimit returns true if NTPositionLimit is present, Tag 971 +func (m NoRelatedSym) HasNTPositionLimit() bool { + return m.Has(tag.NTPositionLimit) +} + +//HasNoInstrumentParties returns true if NoInstrumentParties is present, Tag 1018 +func (m NoRelatedSym) HasNoInstrumentParties() bool { + return m.Has(tag.NoInstrumentParties) +} + +//HasUnitOfMeasure returns true if UnitOfMeasure is present, Tag 996 +func (m NoRelatedSym) HasUnitOfMeasure() bool { + return m.Has(tag.UnitOfMeasure) +} + +//HasTimeUnit returns true if TimeUnit is present, Tag 997 +func (m NoRelatedSym) HasTimeUnit() bool { + return m.Has(tag.TimeUnit) +} + +//HasMaturityTime returns true if MaturityTime is present, Tag 1079 +func (m NoRelatedSym) HasMaturityTime() bool { + return m.Has(tag.MaturityTime) +} + +//HasNoUnderlyings returns true if NoUnderlyings is present, Tag 711 +func (m NoRelatedSym) HasNoUnderlyings() bool { + return m.Has(tag.NoUnderlyings) +} + +//HasNoLegs returns true if NoLegs is present, Tag 555 +func (m NoRelatedSym) HasNoLegs() bool { + return m.Has(tag.NoLegs) +} + +//HasCurrency returns true if Currency is present, Tag 15 +func (m NoRelatedSym) HasCurrency() bool { + return m.Has(tag.Currency) +} + +//HasQuoteType returns true if QuoteType is present, Tag 537 +func (m NoRelatedSym) HasQuoteType() bool { + return m.Has(tag.QuoteType) +} + +//HasSettlType returns true if SettlType is present, Tag 63 +func (m NoRelatedSym) HasSettlType() bool { + return m.Has(tag.SettlType) +} + +//HasSettlDate returns true if SettlDate is present, Tag 64 +func (m NoRelatedSym) HasSettlDate() bool { + return m.Has(tag.SettlDate) +} + +//HasMDEntrySize returns true if MDEntrySize is present, Tag 271 +func (m NoRelatedSym) HasMDEntrySize() bool { + return m.Has(tag.MDEntrySize) +} + +//NoSecurityAltID is a repeating group element, Tag 454 +type NoSecurityAltID struct { + quickfix.Group +} + +//SetSecurityAltID sets SecurityAltID, Tag 455 +func (m NoSecurityAltID) SetSecurityAltID(v string) { + m.Set(field.NewSecurityAltID(v)) +} + +//SetSecurityAltIDSource sets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) SetSecurityAltIDSource(v string) { + m.Set(field.NewSecurityAltIDSource(v)) +} + +//GetSecurityAltID gets SecurityAltID, Tag 455 +func (m NoSecurityAltID) GetSecurityAltID() (f field.SecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityAltIDSource gets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) GetSecurityAltIDSource() (f field.SecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasSecurityAltID returns true if SecurityAltID is present, Tag 455 +func (m NoSecurityAltID) HasSecurityAltID() bool { + return m.Has(tag.SecurityAltID) +} + +//HasSecurityAltIDSource returns true if SecurityAltIDSource is present, Tag 456 +func (m NoSecurityAltID) HasSecurityAltIDSource() bool { + return m.Has(tag.SecurityAltIDSource) +} + +//NoSecurityAltIDRepeatingGroup is a repeating group, Tag 454 +type NoSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoSecurityAltIDRepeatingGroup returns an initialized, NoSecurityAltIDRepeatingGroup +func NewNoSecurityAltIDRepeatingGroup() NoSecurityAltIDRepeatingGroup { + return NoSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.SecurityAltID), quickfix.GroupElement(tag.SecurityAltIDSource)})} +} + +//Add create and append a new NoSecurityAltID to this group +func (m NoSecurityAltIDRepeatingGroup) Add() NoSecurityAltID { + g := m.RepeatingGroup.Add() + return NoSecurityAltID{g} +} + +//Get returns the ith NoSecurityAltID in the NoSecurityAltIDRepeatinGroup +func (m NoSecurityAltIDRepeatingGroup) Get(i int) NoSecurityAltID { + return NoSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoEvents is a repeating group element, Tag 864 +type NoEvents struct { + quickfix.Group +} + +//SetEventType sets EventType, Tag 865 +func (m NoEvents) SetEventType(v int) { + m.Set(field.NewEventType(v)) +} + +//SetEventDate sets EventDate, Tag 866 +func (m NoEvents) SetEventDate(v string) { + m.Set(field.NewEventDate(v)) +} + +//SetEventPx sets EventPx, Tag 867 +func (m NoEvents) SetEventPx(v float64) { + m.Set(field.NewEventPx(v)) +} + +//SetEventText sets EventText, Tag 868 +func (m NoEvents) SetEventText(v string) { + m.Set(field.NewEventText(v)) +} + +//GetEventType gets EventType, Tag 865 +func (m NoEvents) GetEventType() (f field.EventTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventDate gets EventDate, Tag 866 +func (m NoEvents) GetEventDate() (f field.EventDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventPx gets EventPx, Tag 867 +func (m NoEvents) GetEventPx() (f field.EventPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventText gets EventText, Tag 868 +func (m NoEvents) GetEventText() (f field.EventTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasEventType returns true if EventType is present, Tag 865 +func (m NoEvents) HasEventType() bool { + return m.Has(tag.EventType) +} + +//HasEventDate returns true if EventDate is present, Tag 866 +func (m NoEvents) HasEventDate() bool { + return m.Has(tag.EventDate) +} + +//HasEventPx returns true if EventPx is present, Tag 867 +func (m NoEvents) HasEventPx() bool { + return m.Has(tag.EventPx) +} + +//HasEventText returns true if EventText is present, Tag 868 +func (m NoEvents) HasEventText() bool { + return m.Has(tag.EventText) +} + +//NoEventsRepeatingGroup is a repeating group, Tag 864 +type NoEventsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoEventsRepeatingGroup returns an initialized, NoEventsRepeatingGroup +func NewNoEventsRepeatingGroup() NoEventsRepeatingGroup { + return NoEventsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoEvents, + quickfix.GroupTemplate{quickfix.GroupElement(tag.EventType), quickfix.GroupElement(tag.EventDate), quickfix.GroupElement(tag.EventPx), quickfix.GroupElement(tag.EventText)})} +} + +//Add create and append a new NoEvents to this group +func (m NoEventsRepeatingGroup) Add() NoEvents { + g := m.RepeatingGroup.Add() + return NoEvents{g} +} + +//Get returns the ith NoEvents in the NoEventsRepeatinGroup +func (m NoEventsRepeatingGroup) Get(i int) NoEvents { + return NoEvents{m.RepeatingGroup.Get(i)} +} + +//NoInstrumentParties is a repeating group element, Tag 1018 +type NoInstrumentParties struct { + quickfix.Group +} + +//SetInstrumentPartyID sets InstrumentPartyID, Tag 1019 +func (m NoInstrumentParties) SetInstrumentPartyID(v string) { + m.Set(field.NewInstrumentPartyID(v)) +} + +//SetInstrumentPartyIDSource sets InstrumentPartyIDSource, Tag 1050 +func (m NoInstrumentParties) SetInstrumentPartyIDSource(v string) { + m.Set(field.NewInstrumentPartyIDSource(v)) +} + +//SetInstrumentPartyRole sets InstrumentPartyRole, Tag 1051 +func (m NoInstrumentParties) SetInstrumentPartyRole(v int) { + m.Set(field.NewInstrumentPartyRole(v)) +} + +//SetNoInstrumentPartySubIDs sets NoInstrumentPartySubIDs, Tag 1052 +func (m NoInstrumentParties) SetNoInstrumentPartySubIDs(f NoInstrumentPartySubIDsRepeatingGroup) { + m.SetGroup(f) +} + +//GetInstrumentPartyID gets InstrumentPartyID, Tag 1019 +func (m NoInstrumentParties) GetInstrumentPartyID() (f field.InstrumentPartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrumentPartyIDSource gets InstrumentPartyIDSource, Tag 1050 +func (m NoInstrumentParties) GetInstrumentPartyIDSource() (f field.InstrumentPartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrumentPartyRole gets InstrumentPartyRole, Tag 1051 +func (m NoInstrumentParties) GetInstrumentPartyRole() (f field.InstrumentPartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoInstrumentPartySubIDs gets NoInstrumentPartySubIDs, Tag 1052 +func (m NoInstrumentParties) GetNoInstrumentPartySubIDs() (NoInstrumentPartySubIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoInstrumentPartySubIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasInstrumentPartyID returns true if InstrumentPartyID is present, Tag 1019 +func (m NoInstrumentParties) HasInstrumentPartyID() bool { + return m.Has(tag.InstrumentPartyID) +} + +//HasInstrumentPartyIDSource returns true if InstrumentPartyIDSource is present, Tag 1050 +func (m NoInstrumentParties) HasInstrumentPartyIDSource() bool { + return m.Has(tag.InstrumentPartyIDSource) +} + +//HasInstrumentPartyRole returns true if InstrumentPartyRole is present, Tag 1051 +func (m NoInstrumentParties) HasInstrumentPartyRole() bool { + return m.Has(tag.InstrumentPartyRole) +} + +//HasNoInstrumentPartySubIDs returns true if NoInstrumentPartySubIDs is present, Tag 1052 +func (m NoInstrumentParties) HasNoInstrumentPartySubIDs() bool { + return m.Has(tag.NoInstrumentPartySubIDs) +} + +//NoInstrumentPartySubIDs is a repeating group element, Tag 1052 +type NoInstrumentPartySubIDs struct { + quickfix.Group +} + +//SetInstrumentPartySubID sets InstrumentPartySubID, Tag 1053 +func (m NoInstrumentPartySubIDs) SetInstrumentPartySubID(v string) { + m.Set(field.NewInstrumentPartySubID(v)) +} + +//SetInstrumentPartySubIDType sets InstrumentPartySubIDType, Tag 1054 +func (m NoInstrumentPartySubIDs) SetInstrumentPartySubIDType(v int) { + m.Set(field.NewInstrumentPartySubIDType(v)) +} + +//GetInstrumentPartySubID gets InstrumentPartySubID, Tag 1053 +func (m NoInstrumentPartySubIDs) GetInstrumentPartySubID() (f field.InstrumentPartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrumentPartySubIDType gets InstrumentPartySubIDType, Tag 1054 +func (m NoInstrumentPartySubIDs) GetInstrumentPartySubIDType() (f field.InstrumentPartySubIDTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasInstrumentPartySubID returns true if InstrumentPartySubID is present, Tag 1053 +func (m NoInstrumentPartySubIDs) HasInstrumentPartySubID() bool { + return m.Has(tag.InstrumentPartySubID) +} + +//HasInstrumentPartySubIDType returns true if InstrumentPartySubIDType is present, Tag 1054 +func (m NoInstrumentPartySubIDs) HasInstrumentPartySubIDType() bool { + return m.Has(tag.InstrumentPartySubIDType) +} + +//NoInstrumentPartySubIDsRepeatingGroup is a repeating group, Tag 1052 +type NoInstrumentPartySubIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoInstrumentPartySubIDsRepeatingGroup returns an initialized, NoInstrumentPartySubIDsRepeatingGroup +func NewNoInstrumentPartySubIDsRepeatingGroup() NoInstrumentPartySubIDsRepeatingGroup { + return NoInstrumentPartySubIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoInstrumentPartySubIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.InstrumentPartySubID), quickfix.GroupElement(tag.InstrumentPartySubIDType)})} +} + +//Add create and append a new NoInstrumentPartySubIDs to this group +func (m NoInstrumentPartySubIDsRepeatingGroup) Add() NoInstrumentPartySubIDs { + g := m.RepeatingGroup.Add() + return NoInstrumentPartySubIDs{g} +} + +//Get returns the ith NoInstrumentPartySubIDs in the NoInstrumentPartySubIDsRepeatinGroup +func (m NoInstrumentPartySubIDsRepeatingGroup) Get(i int) NoInstrumentPartySubIDs { + return NoInstrumentPartySubIDs{m.RepeatingGroup.Get(i)} +} + +//NoInstrumentPartiesRepeatingGroup is a repeating group, Tag 1018 +type NoInstrumentPartiesRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoInstrumentPartiesRepeatingGroup returns an initialized, NoInstrumentPartiesRepeatingGroup +func NewNoInstrumentPartiesRepeatingGroup() NoInstrumentPartiesRepeatingGroup { + return NoInstrumentPartiesRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoInstrumentParties, + quickfix.GroupTemplate{quickfix.GroupElement(tag.InstrumentPartyID), quickfix.GroupElement(tag.InstrumentPartyIDSource), quickfix.GroupElement(tag.InstrumentPartyRole), NewNoInstrumentPartySubIDsRepeatingGroup()})} +} + +//Add create and append a new NoInstrumentParties to this group +func (m NoInstrumentPartiesRepeatingGroup) Add() NoInstrumentParties { + g := m.RepeatingGroup.Add() + return NoInstrumentParties{g} +} + +//Get returns the ith NoInstrumentParties in the NoInstrumentPartiesRepeatinGroup +func (m NoInstrumentPartiesRepeatingGroup) Get(i int) NoInstrumentParties { + return NoInstrumentParties{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyings is a repeating group element, Tag 711 +type NoUnderlyings struct { + quickfix.Group +} + +//SetUnderlyingSymbol sets UnderlyingSymbol, Tag 311 +func (m NoUnderlyings) SetUnderlyingSymbol(v string) { + m.Set(field.NewUnderlyingSymbol(v)) +} + +//SetUnderlyingSymbolSfx sets UnderlyingSymbolSfx, Tag 312 +func (m NoUnderlyings) SetUnderlyingSymbolSfx(v string) { + m.Set(field.NewUnderlyingSymbolSfx(v)) +} + +//SetUnderlyingSecurityID sets UnderlyingSecurityID, Tag 309 +func (m NoUnderlyings) SetUnderlyingSecurityID(v string) { + m.Set(field.NewUnderlyingSecurityID(v)) +} + +//SetUnderlyingSecurityIDSource sets UnderlyingSecurityIDSource, Tag 305 +func (m NoUnderlyings) SetUnderlyingSecurityIDSource(v string) { + m.Set(field.NewUnderlyingSecurityIDSource(v)) +} + +//SetNoUnderlyingSecurityAltID sets NoUnderlyingSecurityAltID, Tag 457 +func (m NoUnderlyings) SetNoUnderlyingSecurityAltID(f NoUnderlyingSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetUnderlyingProduct sets UnderlyingProduct, Tag 462 +func (m NoUnderlyings) SetUnderlyingProduct(v int) { + m.Set(field.NewUnderlyingProduct(v)) +} + +//SetUnderlyingCFICode sets UnderlyingCFICode, Tag 463 +func (m NoUnderlyings) SetUnderlyingCFICode(v string) { + m.Set(field.NewUnderlyingCFICode(v)) +} + +//SetUnderlyingSecurityType sets UnderlyingSecurityType, Tag 310 +func (m NoUnderlyings) SetUnderlyingSecurityType(v string) { + m.Set(field.NewUnderlyingSecurityType(v)) +} + +//SetUnderlyingSecuritySubType sets UnderlyingSecuritySubType, Tag 763 +func (m NoUnderlyings) SetUnderlyingSecuritySubType(v string) { + m.Set(field.NewUnderlyingSecuritySubType(v)) +} + +//SetUnderlyingMaturityMonthYear sets UnderlyingMaturityMonthYear, Tag 313 +func (m NoUnderlyings) SetUnderlyingMaturityMonthYear(v string) { + m.Set(field.NewUnderlyingMaturityMonthYear(v)) +} + +//SetUnderlyingMaturityDate sets UnderlyingMaturityDate, Tag 542 +func (m NoUnderlyings) SetUnderlyingMaturityDate(v string) { + m.Set(field.NewUnderlyingMaturityDate(v)) +} + +//SetUnderlyingCouponPaymentDate sets UnderlyingCouponPaymentDate, Tag 241 +func (m NoUnderlyings) SetUnderlyingCouponPaymentDate(v string) { + m.Set(field.NewUnderlyingCouponPaymentDate(v)) +} + +//SetUnderlyingIssueDate sets UnderlyingIssueDate, Tag 242 +func (m NoUnderlyings) SetUnderlyingIssueDate(v string) { + m.Set(field.NewUnderlyingIssueDate(v)) +} + +//SetUnderlyingRepoCollateralSecurityType sets UnderlyingRepoCollateralSecurityType, Tag 243 +func (m NoUnderlyings) SetUnderlyingRepoCollateralSecurityType(v int) { + m.Set(field.NewUnderlyingRepoCollateralSecurityType(v)) +} + +//SetUnderlyingRepurchaseTerm sets UnderlyingRepurchaseTerm, Tag 244 +func (m NoUnderlyings) SetUnderlyingRepurchaseTerm(v int) { + m.Set(field.NewUnderlyingRepurchaseTerm(v)) +} + +//SetUnderlyingRepurchaseRate sets UnderlyingRepurchaseRate, Tag 245 +func (m NoUnderlyings) SetUnderlyingRepurchaseRate(v float64) { + m.Set(field.NewUnderlyingRepurchaseRate(v)) +} + +//SetUnderlyingFactor sets UnderlyingFactor, Tag 246 +func (m NoUnderlyings) SetUnderlyingFactor(v float64) { + m.Set(field.NewUnderlyingFactor(v)) +} + +//SetUnderlyingCreditRating sets UnderlyingCreditRating, Tag 256 +func (m NoUnderlyings) SetUnderlyingCreditRating(v string) { + m.Set(field.NewUnderlyingCreditRating(v)) +} + +//SetUnderlyingInstrRegistry sets UnderlyingInstrRegistry, Tag 595 +func (m NoUnderlyings) SetUnderlyingInstrRegistry(v string) { + m.Set(field.NewUnderlyingInstrRegistry(v)) +} + +//SetUnderlyingCountryOfIssue sets UnderlyingCountryOfIssue, Tag 592 +func (m NoUnderlyings) SetUnderlyingCountryOfIssue(v string) { + m.Set(field.NewUnderlyingCountryOfIssue(v)) +} + +//SetUnderlyingStateOrProvinceOfIssue sets UnderlyingStateOrProvinceOfIssue, Tag 593 +func (m NoUnderlyings) SetUnderlyingStateOrProvinceOfIssue(v string) { + m.Set(field.NewUnderlyingStateOrProvinceOfIssue(v)) +} + +//SetUnderlyingLocaleOfIssue sets UnderlyingLocaleOfIssue, Tag 594 +func (m NoUnderlyings) SetUnderlyingLocaleOfIssue(v string) { + m.Set(field.NewUnderlyingLocaleOfIssue(v)) +} + +//SetUnderlyingRedemptionDate sets UnderlyingRedemptionDate, Tag 247 +func (m NoUnderlyings) SetUnderlyingRedemptionDate(v string) { + m.Set(field.NewUnderlyingRedemptionDate(v)) +} + +//SetUnderlyingStrikePrice sets UnderlyingStrikePrice, Tag 316 +func (m NoUnderlyings) SetUnderlyingStrikePrice(v float64) { + m.Set(field.NewUnderlyingStrikePrice(v)) +} + +//SetUnderlyingStrikeCurrency sets UnderlyingStrikeCurrency, Tag 941 +func (m NoUnderlyings) SetUnderlyingStrikeCurrency(v string) { + m.Set(field.NewUnderlyingStrikeCurrency(v)) +} + +//SetUnderlyingOptAttribute sets UnderlyingOptAttribute, Tag 317 +func (m NoUnderlyings) SetUnderlyingOptAttribute(v string) { + m.Set(field.NewUnderlyingOptAttribute(v)) +} + +//SetUnderlyingContractMultiplier sets UnderlyingContractMultiplier, Tag 436 +func (m NoUnderlyings) SetUnderlyingContractMultiplier(v float64) { + m.Set(field.NewUnderlyingContractMultiplier(v)) +} + +//SetUnderlyingCouponRate sets UnderlyingCouponRate, Tag 435 +func (m NoUnderlyings) SetUnderlyingCouponRate(v float64) { + m.Set(field.NewUnderlyingCouponRate(v)) +} + +//SetUnderlyingSecurityExchange sets UnderlyingSecurityExchange, Tag 308 +func (m NoUnderlyings) SetUnderlyingSecurityExchange(v string) { + m.Set(field.NewUnderlyingSecurityExchange(v)) +} + +//SetUnderlyingIssuer sets UnderlyingIssuer, Tag 306 +func (m NoUnderlyings) SetUnderlyingIssuer(v string) { + m.Set(field.NewUnderlyingIssuer(v)) +} + +//SetEncodedUnderlyingIssuerLen sets EncodedUnderlyingIssuerLen, Tag 362 +func (m NoUnderlyings) SetEncodedUnderlyingIssuerLen(v int) { + m.Set(field.NewEncodedUnderlyingIssuerLen(v)) +} + +//SetEncodedUnderlyingIssuer sets EncodedUnderlyingIssuer, Tag 363 +func (m NoUnderlyings) SetEncodedUnderlyingIssuer(v string) { + m.Set(field.NewEncodedUnderlyingIssuer(v)) +} + +//SetUnderlyingSecurityDesc sets UnderlyingSecurityDesc, Tag 307 +func (m NoUnderlyings) SetUnderlyingSecurityDesc(v string) { + m.Set(field.NewUnderlyingSecurityDesc(v)) +} + +//SetEncodedUnderlyingSecurityDescLen sets EncodedUnderlyingSecurityDescLen, Tag 364 +func (m NoUnderlyings) SetEncodedUnderlyingSecurityDescLen(v int) { + m.Set(field.NewEncodedUnderlyingSecurityDescLen(v)) +} + +//SetEncodedUnderlyingSecurityDesc sets EncodedUnderlyingSecurityDesc, Tag 365 +func (m NoUnderlyings) SetEncodedUnderlyingSecurityDesc(v string) { + m.Set(field.NewEncodedUnderlyingSecurityDesc(v)) +} + +//SetUnderlyingCPProgram sets UnderlyingCPProgram, Tag 877 +func (m NoUnderlyings) SetUnderlyingCPProgram(v string) { + m.Set(field.NewUnderlyingCPProgram(v)) +} + +//SetUnderlyingCPRegType sets UnderlyingCPRegType, Tag 878 +func (m NoUnderlyings) SetUnderlyingCPRegType(v string) { + m.Set(field.NewUnderlyingCPRegType(v)) +} + +//SetUnderlyingCurrency sets UnderlyingCurrency, Tag 318 +func (m NoUnderlyings) SetUnderlyingCurrency(v string) { + m.Set(field.NewUnderlyingCurrency(v)) +} + +//SetUnderlyingQty sets UnderlyingQty, Tag 879 +func (m NoUnderlyings) SetUnderlyingQty(v float64) { + m.Set(field.NewUnderlyingQty(v)) +} + +//SetUnderlyingPx sets UnderlyingPx, Tag 810 +func (m NoUnderlyings) SetUnderlyingPx(v float64) { + m.Set(field.NewUnderlyingPx(v)) +} + +//SetUnderlyingDirtyPrice sets UnderlyingDirtyPrice, Tag 882 +func (m NoUnderlyings) SetUnderlyingDirtyPrice(v float64) { + m.Set(field.NewUnderlyingDirtyPrice(v)) +} + +//SetUnderlyingEndPrice sets UnderlyingEndPrice, Tag 883 +func (m NoUnderlyings) SetUnderlyingEndPrice(v float64) { + m.Set(field.NewUnderlyingEndPrice(v)) +} + +//SetUnderlyingStartValue sets UnderlyingStartValue, Tag 884 +func (m NoUnderlyings) SetUnderlyingStartValue(v float64) { + m.Set(field.NewUnderlyingStartValue(v)) +} + +//SetUnderlyingCurrentValue sets UnderlyingCurrentValue, Tag 885 +func (m NoUnderlyings) SetUnderlyingCurrentValue(v float64) { + m.Set(field.NewUnderlyingCurrentValue(v)) +} + +//SetUnderlyingEndValue sets UnderlyingEndValue, Tag 886 +func (m NoUnderlyings) SetUnderlyingEndValue(v float64) { + m.Set(field.NewUnderlyingEndValue(v)) +} + +//SetNoUnderlyingStips sets NoUnderlyingStips, Tag 887 +func (m NoUnderlyings) SetNoUnderlyingStips(f NoUnderlyingStipsRepeatingGroup) { + m.SetGroup(f) +} + +//SetUnderlyingAllocationPercent sets UnderlyingAllocationPercent, Tag 972 +func (m NoUnderlyings) SetUnderlyingAllocationPercent(v float64) { + m.Set(field.NewUnderlyingAllocationPercent(v)) +} + +//SetUnderlyingSettlementType sets UnderlyingSettlementType, Tag 975 +func (m NoUnderlyings) SetUnderlyingSettlementType(v int) { + m.Set(field.NewUnderlyingSettlementType(v)) +} + +//SetUnderlyingCashAmount sets UnderlyingCashAmount, Tag 973 +func (m NoUnderlyings) SetUnderlyingCashAmount(v float64) { + m.Set(field.NewUnderlyingCashAmount(v)) +} + +//SetUnderlyingCashType sets UnderlyingCashType, Tag 974 +func (m NoUnderlyings) SetUnderlyingCashType(v string) { + m.Set(field.NewUnderlyingCashType(v)) +} + +//SetUnderlyingUnitOfMeasure sets UnderlyingUnitOfMeasure, Tag 998 +func (m NoUnderlyings) SetUnderlyingUnitOfMeasure(v string) { + m.Set(field.NewUnderlyingUnitOfMeasure(v)) +} + +//SetUnderlyingTimeUnit sets UnderlyingTimeUnit, Tag 1000 +func (m NoUnderlyings) SetUnderlyingTimeUnit(v string) { + m.Set(field.NewUnderlyingTimeUnit(v)) +} + +//SetUnderlyingCapValue sets UnderlyingCapValue, Tag 1038 +func (m NoUnderlyings) SetUnderlyingCapValue(v float64) { + m.Set(field.NewUnderlyingCapValue(v)) +} + +//SetNoUndlyInstrumentParties sets NoUndlyInstrumentParties, Tag 1058 +func (m NoUnderlyings) SetNoUndlyInstrumentParties(f NoUndlyInstrumentPartiesRepeatingGroup) { + m.SetGroup(f) +} + +//SetUnderlyingSettlMethod sets UnderlyingSettlMethod, Tag 1039 +func (m NoUnderlyings) SetUnderlyingSettlMethod(v string) { + m.Set(field.NewUnderlyingSettlMethod(v)) +} + +//SetUnderlyingAdjustedQuantity sets UnderlyingAdjustedQuantity, Tag 1044 +func (m NoUnderlyings) SetUnderlyingAdjustedQuantity(v float64) { + m.Set(field.NewUnderlyingAdjustedQuantity(v)) +} + +//SetUnderlyingFXRate sets UnderlyingFXRate, Tag 1045 +func (m NoUnderlyings) SetUnderlyingFXRate(v float64) { + m.Set(field.NewUnderlyingFXRate(v)) +} + +//SetUnderlyingFXRateCalc sets UnderlyingFXRateCalc, Tag 1046 +func (m NoUnderlyings) SetUnderlyingFXRateCalc(v string) { + m.Set(field.NewUnderlyingFXRateCalc(v)) +} + +//GetUnderlyingSymbol gets UnderlyingSymbol, Tag 311 +func (m NoUnderlyings) GetUnderlyingSymbol() (f field.UnderlyingSymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSymbolSfx gets UnderlyingSymbolSfx, Tag 312 +func (m NoUnderlyings) GetUnderlyingSymbolSfx() (f field.UnderlyingSymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityID gets UnderlyingSecurityID, Tag 309 +func (m NoUnderlyings) GetUnderlyingSecurityID() (f field.UnderlyingSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityIDSource gets UnderlyingSecurityIDSource, Tag 305 +func (m NoUnderlyings) GetUnderlyingSecurityIDSource() (f field.UnderlyingSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyingSecurityAltID gets NoUnderlyingSecurityAltID, Tag 457 +func (m NoUnderlyings) GetNoUnderlyingSecurityAltID() (NoUnderlyingSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetUnderlyingProduct gets UnderlyingProduct, Tag 462 +func (m NoUnderlyings) GetUnderlyingProduct() (f field.UnderlyingProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCFICode gets UnderlyingCFICode, Tag 463 +func (m NoUnderlyings) GetUnderlyingCFICode() (f field.UnderlyingCFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityType gets UnderlyingSecurityType, Tag 310 +func (m NoUnderlyings) GetUnderlyingSecurityType() (f field.UnderlyingSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecuritySubType gets UnderlyingSecuritySubType, Tag 763 +func (m NoUnderlyings) GetUnderlyingSecuritySubType() (f field.UnderlyingSecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingMaturityMonthYear gets UnderlyingMaturityMonthYear, Tag 313 +func (m NoUnderlyings) GetUnderlyingMaturityMonthYear() (f field.UnderlyingMaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingMaturityDate gets UnderlyingMaturityDate, Tag 542 +func (m NoUnderlyings) GetUnderlyingMaturityDate() (f field.UnderlyingMaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCouponPaymentDate gets UnderlyingCouponPaymentDate, Tag 241 +func (m NoUnderlyings) GetUnderlyingCouponPaymentDate() (f field.UnderlyingCouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingIssueDate gets UnderlyingIssueDate, Tag 242 +func (m NoUnderlyings) GetUnderlyingIssueDate() (f field.UnderlyingIssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepoCollateralSecurityType gets UnderlyingRepoCollateralSecurityType, Tag 243 +func (m NoUnderlyings) GetUnderlyingRepoCollateralSecurityType() (f field.UnderlyingRepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepurchaseTerm gets UnderlyingRepurchaseTerm, Tag 244 +func (m NoUnderlyings) GetUnderlyingRepurchaseTerm() (f field.UnderlyingRepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepurchaseRate gets UnderlyingRepurchaseRate, Tag 245 +func (m NoUnderlyings) GetUnderlyingRepurchaseRate() (f field.UnderlyingRepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingFactor gets UnderlyingFactor, Tag 246 +func (m NoUnderlyings) GetUnderlyingFactor() (f field.UnderlyingFactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCreditRating gets UnderlyingCreditRating, Tag 256 +func (m NoUnderlyings) GetUnderlyingCreditRating() (f field.UnderlyingCreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingInstrRegistry gets UnderlyingInstrRegistry, Tag 595 +func (m NoUnderlyings) GetUnderlyingInstrRegistry() (f field.UnderlyingInstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCountryOfIssue gets UnderlyingCountryOfIssue, Tag 592 +func (m NoUnderlyings) GetUnderlyingCountryOfIssue() (f field.UnderlyingCountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStateOrProvinceOfIssue gets UnderlyingStateOrProvinceOfIssue, Tag 593 +func (m NoUnderlyings) GetUnderlyingStateOrProvinceOfIssue() (f field.UnderlyingStateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingLocaleOfIssue gets UnderlyingLocaleOfIssue, Tag 594 +func (m NoUnderlyings) GetUnderlyingLocaleOfIssue() (f field.UnderlyingLocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRedemptionDate gets UnderlyingRedemptionDate, Tag 247 +func (m NoUnderlyings) GetUnderlyingRedemptionDate() (f field.UnderlyingRedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStrikePrice gets UnderlyingStrikePrice, Tag 316 +func (m NoUnderlyings) GetUnderlyingStrikePrice() (f field.UnderlyingStrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStrikeCurrency gets UnderlyingStrikeCurrency, Tag 941 +func (m NoUnderlyings) GetUnderlyingStrikeCurrency() (f field.UnderlyingStrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingOptAttribute gets UnderlyingOptAttribute, Tag 317 +func (m NoUnderlyings) GetUnderlyingOptAttribute() (f field.UnderlyingOptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingContractMultiplier gets UnderlyingContractMultiplier, Tag 436 +func (m NoUnderlyings) GetUnderlyingContractMultiplier() (f field.UnderlyingContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCouponRate gets UnderlyingCouponRate, Tag 435 +func (m NoUnderlyings) GetUnderlyingCouponRate() (f field.UnderlyingCouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityExchange gets UnderlyingSecurityExchange, Tag 308 +func (m NoUnderlyings) GetUnderlyingSecurityExchange() (f field.UnderlyingSecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingIssuer gets UnderlyingIssuer, Tag 306 +func (m NoUnderlyings) GetUnderlyingIssuer() (f field.UnderlyingIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingIssuerLen gets EncodedUnderlyingIssuerLen, Tag 362 +func (m NoUnderlyings) GetEncodedUnderlyingIssuerLen() (f field.EncodedUnderlyingIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingIssuer gets EncodedUnderlyingIssuer, Tag 363 +func (m NoUnderlyings) GetEncodedUnderlyingIssuer() (f field.EncodedUnderlyingIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityDesc gets UnderlyingSecurityDesc, Tag 307 +func (m NoUnderlyings) GetUnderlyingSecurityDesc() (f field.UnderlyingSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingSecurityDescLen gets EncodedUnderlyingSecurityDescLen, Tag 364 +func (m NoUnderlyings) GetEncodedUnderlyingSecurityDescLen() (f field.EncodedUnderlyingSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingSecurityDesc gets EncodedUnderlyingSecurityDesc, Tag 365 +func (m NoUnderlyings) GetEncodedUnderlyingSecurityDesc() (f field.EncodedUnderlyingSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCPProgram gets UnderlyingCPProgram, Tag 877 +func (m NoUnderlyings) GetUnderlyingCPProgram() (f field.UnderlyingCPProgramField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCPRegType gets UnderlyingCPRegType, Tag 878 +func (m NoUnderlyings) GetUnderlyingCPRegType() (f field.UnderlyingCPRegTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCurrency gets UnderlyingCurrency, Tag 318 +func (m NoUnderlyings) GetUnderlyingCurrency() (f field.UnderlyingCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingQty gets UnderlyingQty, Tag 879 +func (m NoUnderlyings) GetUnderlyingQty() (f field.UnderlyingQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingPx gets UnderlyingPx, Tag 810 +func (m NoUnderlyings) GetUnderlyingPx() (f field.UnderlyingPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingDirtyPrice gets UnderlyingDirtyPrice, Tag 882 +func (m NoUnderlyings) GetUnderlyingDirtyPrice() (f field.UnderlyingDirtyPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingEndPrice gets UnderlyingEndPrice, Tag 883 +func (m NoUnderlyings) GetUnderlyingEndPrice() (f field.UnderlyingEndPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStartValue gets UnderlyingStartValue, Tag 884 +func (m NoUnderlyings) GetUnderlyingStartValue() (f field.UnderlyingStartValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCurrentValue gets UnderlyingCurrentValue, Tag 885 +func (m NoUnderlyings) GetUnderlyingCurrentValue() (f field.UnderlyingCurrentValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingEndValue gets UnderlyingEndValue, Tag 886 +func (m NoUnderlyings) GetUnderlyingEndValue() (f field.UnderlyingEndValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyingStips gets NoUnderlyingStips, Tag 887 +func (m NoUnderlyings) GetNoUnderlyingStips() (NoUnderlyingStipsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingStipsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetUnderlyingAllocationPercent gets UnderlyingAllocationPercent, Tag 972 +func (m NoUnderlyings) GetUnderlyingAllocationPercent() (f field.UnderlyingAllocationPercentField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSettlementType gets UnderlyingSettlementType, Tag 975 +func (m NoUnderlyings) GetUnderlyingSettlementType() (f field.UnderlyingSettlementTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCashAmount gets UnderlyingCashAmount, Tag 973 +func (m NoUnderlyings) GetUnderlyingCashAmount() (f field.UnderlyingCashAmountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCashType gets UnderlyingCashType, Tag 974 +func (m NoUnderlyings) GetUnderlyingCashType() (f field.UnderlyingCashTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingUnitOfMeasure gets UnderlyingUnitOfMeasure, Tag 998 +func (m NoUnderlyings) GetUnderlyingUnitOfMeasure() (f field.UnderlyingUnitOfMeasureField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingTimeUnit gets UnderlyingTimeUnit, Tag 1000 +func (m NoUnderlyings) GetUnderlyingTimeUnit() (f field.UnderlyingTimeUnitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCapValue gets UnderlyingCapValue, Tag 1038 +func (m NoUnderlyings) GetUnderlyingCapValue() (f field.UnderlyingCapValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUndlyInstrumentParties gets NoUndlyInstrumentParties, Tag 1058 +func (m NoUnderlyings) GetNoUndlyInstrumentParties() (NoUndlyInstrumentPartiesRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUndlyInstrumentPartiesRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetUnderlyingSettlMethod gets UnderlyingSettlMethod, Tag 1039 +func (m NoUnderlyings) GetUnderlyingSettlMethod() (f field.UnderlyingSettlMethodField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingAdjustedQuantity gets UnderlyingAdjustedQuantity, Tag 1044 +func (m NoUnderlyings) GetUnderlyingAdjustedQuantity() (f field.UnderlyingAdjustedQuantityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingFXRate gets UnderlyingFXRate, Tag 1045 +func (m NoUnderlyings) GetUnderlyingFXRate() (f field.UnderlyingFXRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingFXRateCalc gets UnderlyingFXRateCalc, Tag 1046 +func (m NoUnderlyings) GetUnderlyingFXRateCalc() (f field.UnderlyingFXRateCalcField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingSymbol returns true if UnderlyingSymbol is present, Tag 311 +func (m NoUnderlyings) HasUnderlyingSymbol() bool { + return m.Has(tag.UnderlyingSymbol) +} + +//HasUnderlyingSymbolSfx returns true if UnderlyingSymbolSfx is present, Tag 312 +func (m NoUnderlyings) HasUnderlyingSymbolSfx() bool { + return m.Has(tag.UnderlyingSymbolSfx) +} + +//HasUnderlyingSecurityID returns true if UnderlyingSecurityID is present, Tag 309 +func (m NoUnderlyings) HasUnderlyingSecurityID() bool { + return m.Has(tag.UnderlyingSecurityID) +} + +//HasUnderlyingSecurityIDSource returns true if UnderlyingSecurityIDSource is present, Tag 305 +func (m NoUnderlyings) HasUnderlyingSecurityIDSource() bool { + return m.Has(tag.UnderlyingSecurityIDSource) +} + +//HasNoUnderlyingSecurityAltID returns true if NoUnderlyingSecurityAltID is present, Tag 457 +func (m NoUnderlyings) HasNoUnderlyingSecurityAltID() bool { + return m.Has(tag.NoUnderlyingSecurityAltID) +} + +//HasUnderlyingProduct returns true if UnderlyingProduct is present, Tag 462 +func (m NoUnderlyings) HasUnderlyingProduct() bool { + return m.Has(tag.UnderlyingProduct) +} + +//HasUnderlyingCFICode returns true if UnderlyingCFICode is present, Tag 463 +func (m NoUnderlyings) HasUnderlyingCFICode() bool { + return m.Has(tag.UnderlyingCFICode) +} + +//HasUnderlyingSecurityType returns true if UnderlyingSecurityType is present, Tag 310 +func (m NoUnderlyings) HasUnderlyingSecurityType() bool { + return m.Has(tag.UnderlyingSecurityType) +} + +//HasUnderlyingSecuritySubType returns true if UnderlyingSecuritySubType is present, Tag 763 +func (m NoUnderlyings) HasUnderlyingSecuritySubType() bool { + return m.Has(tag.UnderlyingSecuritySubType) +} + +//HasUnderlyingMaturityMonthYear returns true if UnderlyingMaturityMonthYear is present, Tag 313 +func (m NoUnderlyings) HasUnderlyingMaturityMonthYear() bool { + return m.Has(tag.UnderlyingMaturityMonthYear) +} + +//HasUnderlyingMaturityDate returns true if UnderlyingMaturityDate is present, Tag 542 +func (m NoUnderlyings) HasUnderlyingMaturityDate() bool { + return m.Has(tag.UnderlyingMaturityDate) +} + +//HasUnderlyingCouponPaymentDate returns true if UnderlyingCouponPaymentDate is present, Tag 241 +func (m NoUnderlyings) HasUnderlyingCouponPaymentDate() bool { + return m.Has(tag.UnderlyingCouponPaymentDate) +} + +//HasUnderlyingIssueDate returns true if UnderlyingIssueDate is present, Tag 242 +func (m NoUnderlyings) HasUnderlyingIssueDate() bool { + return m.Has(tag.UnderlyingIssueDate) +} + +//HasUnderlyingRepoCollateralSecurityType returns true if UnderlyingRepoCollateralSecurityType is present, Tag 243 +func (m NoUnderlyings) HasUnderlyingRepoCollateralSecurityType() bool { + return m.Has(tag.UnderlyingRepoCollateralSecurityType) +} + +//HasUnderlyingRepurchaseTerm returns true if UnderlyingRepurchaseTerm is present, Tag 244 +func (m NoUnderlyings) HasUnderlyingRepurchaseTerm() bool { + return m.Has(tag.UnderlyingRepurchaseTerm) +} + +//HasUnderlyingRepurchaseRate returns true if UnderlyingRepurchaseRate is present, Tag 245 +func (m NoUnderlyings) HasUnderlyingRepurchaseRate() bool { + return m.Has(tag.UnderlyingRepurchaseRate) +} + +//HasUnderlyingFactor returns true if UnderlyingFactor is present, Tag 246 +func (m NoUnderlyings) HasUnderlyingFactor() bool { + return m.Has(tag.UnderlyingFactor) +} + +//HasUnderlyingCreditRating returns true if UnderlyingCreditRating is present, Tag 256 +func (m NoUnderlyings) HasUnderlyingCreditRating() bool { + return m.Has(tag.UnderlyingCreditRating) +} + +//HasUnderlyingInstrRegistry returns true if UnderlyingInstrRegistry is present, Tag 595 +func (m NoUnderlyings) HasUnderlyingInstrRegistry() bool { + return m.Has(tag.UnderlyingInstrRegistry) +} + +//HasUnderlyingCountryOfIssue returns true if UnderlyingCountryOfIssue is present, Tag 592 +func (m NoUnderlyings) HasUnderlyingCountryOfIssue() bool { + return m.Has(tag.UnderlyingCountryOfIssue) +} + +//HasUnderlyingStateOrProvinceOfIssue returns true if UnderlyingStateOrProvinceOfIssue is present, Tag 593 +func (m NoUnderlyings) HasUnderlyingStateOrProvinceOfIssue() bool { + return m.Has(tag.UnderlyingStateOrProvinceOfIssue) +} + +//HasUnderlyingLocaleOfIssue returns true if UnderlyingLocaleOfIssue is present, Tag 594 +func (m NoUnderlyings) HasUnderlyingLocaleOfIssue() bool { + return m.Has(tag.UnderlyingLocaleOfIssue) +} + +//HasUnderlyingRedemptionDate returns true if UnderlyingRedemptionDate is present, Tag 247 +func (m NoUnderlyings) HasUnderlyingRedemptionDate() bool { + return m.Has(tag.UnderlyingRedemptionDate) +} + +//HasUnderlyingStrikePrice returns true if UnderlyingStrikePrice is present, Tag 316 +func (m NoUnderlyings) HasUnderlyingStrikePrice() bool { + return m.Has(tag.UnderlyingStrikePrice) +} + +//HasUnderlyingStrikeCurrency returns true if UnderlyingStrikeCurrency is present, Tag 941 +func (m NoUnderlyings) HasUnderlyingStrikeCurrency() bool { + return m.Has(tag.UnderlyingStrikeCurrency) +} + +//HasUnderlyingOptAttribute returns true if UnderlyingOptAttribute is present, Tag 317 +func (m NoUnderlyings) HasUnderlyingOptAttribute() bool { + return m.Has(tag.UnderlyingOptAttribute) +} + +//HasUnderlyingContractMultiplier returns true if UnderlyingContractMultiplier is present, Tag 436 +func (m NoUnderlyings) HasUnderlyingContractMultiplier() bool { + return m.Has(tag.UnderlyingContractMultiplier) +} + +//HasUnderlyingCouponRate returns true if UnderlyingCouponRate is present, Tag 435 +func (m NoUnderlyings) HasUnderlyingCouponRate() bool { + return m.Has(tag.UnderlyingCouponRate) +} + +//HasUnderlyingSecurityExchange returns true if UnderlyingSecurityExchange is present, Tag 308 +func (m NoUnderlyings) HasUnderlyingSecurityExchange() bool { + return m.Has(tag.UnderlyingSecurityExchange) +} + +//HasUnderlyingIssuer returns true if UnderlyingIssuer is present, Tag 306 +func (m NoUnderlyings) HasUnderlyingIssuer() bool { + return m.Has(tag.UnderlyingIssuer) +} + +//HasEncodedUnderlyingIssuerLen returns true if EncodedUnderlyingIssuerLen is present, Tag 362 +func (m NoUnderlyings) HasEncodedUnderlyingIssuerLen() bool { + return m.Has(tag.EncodedUnderlyingIssuerLen) +} + +//HasEncodedUnderlyingIssuer returns true if EncodedUnderlyingIssuer is present, Tag 363 +func (m NoUnderlyings) HasEncodedUnderlyingIssuer() bool { + return m.Has(tag.EncodedUnderlyingIssuer) +} + +//HasUnderlyingSecurityDesc returns true if UnderlyingSecurityDesc is present, Tag 307 +func (m NoUnderlyings) HasUnderlyingSecurityDesc() bool { + return m.Has(tag.UnderlyingSecurityDesc) +} + +//HasEncodedUnderlyingSecurityDescLen returns true if EncodedUnderlyingSecurityDescLen is present, Tag 364 +func (m NoUnderlyings) HasEncodedUnderlyingSecurityDescLen() bool { + return m.Has(tag.EncodedUnderlyingSecurityDescLen) +} + +//HasEncodedUnderlyingSecurityDesc returns true if EncodedUnderlyingSecurityDesc is present, Tag 365 +func (m NoUnderlyings) HasEncodedUnderlyingSecurityDesc() bool { + return m.Has(tag.EncodedUnderlyingSecurityDesc) +} + +//HasUnderlyingCPProgram returns true if UnderlyingCPProgram is present, Tag 877 +func (m NoUnderlyings) HasUnderlyingCPProgram() bool { + return m.Has(tag.UnderlyingCPProgram) +} + +//HasUnderlyingCPRegType returns true if UnderlyingCPRegType is present, Tag 878 +func (m NoUnderlyings) HasUnderlyingCPRegType() bool { + return m.Has(tag.UnderlyingCPRegType) +} + +//HasUnderlyingCurrency returns true if UnderlyingCurrency is present, Tag 318 +func (m NoUnderlyings) HasUnderlyingCurrency() bool { + return m.Has(tag.UnderlyingCurrency) +} + +//HasUnderlyingQty returns true if UnderlyingQty is present, Tag 879 +func (m NoUnderlyings) HasUnderlyingQty() bool { + return m.Has(tag.UnderlyingQty) +} + +//HasUnderlyingPx returns true if UnderlyingPx is present, Tag 810 +func (m NoUnderlyings) HasUnderlyingPx() bool { + return m.Has(tag.UnderlyingPx) +} + +//HasUnderlyingDirtyPrice returns true if UnderlyingDirtyPrice is present, Tag 882 +func (m NoUnderlyings) HasUnderlyingDirtyPrice() bool { + return m.Has(tag.UnderlyingDirtyPrice) +} + +//HasUnderlyingEndPrice returns true if UnderlyingEndPrice is present, Tag 883 +func (m NoUnderlyings) HasUnderlyingEndPrice() bool { + return m.Has(tag.UnderlyingEndPrice) +} + +//HasUnderlyingStartValue returns true if UnderlyingStartValue is present, Tag 884 +func (m NoUnderlyings) HasUnderlyingStartValue() bool { + return m.Has(tag.UnderlyingStartValue) +} + +//HasUnderlyingCurrentValue returns true if UnderlyingCurrentValue is present, Tag 885 +func (m NoUnderlyings) HasUnderlyingCurrentValue() bool { + return m.Has(tag.UnderlyingCurrentValue) +} + +//HasUnderlyingEndValue returns true if UnderlyingEndValue is present, Tag 886 +func (m NoUnderlyings) HasUnderlyingEndValue() bool { + return m.Has(tag.UnderlyingEndValue) +} + +//HasNoUnderlyingStips returns true if NoUnderlyingStips is present, Tag 887 +func (m NoUnderlyings) HasNoUnderlyingStips() bool { + return m.Has(tag.NoUnderlyingStips) +} + +//HasUnderlyingAllocationPercent returns true if UnderlyingAllocationPercent is present, Tag 972 +func (m NoUnderlyings) HasUnderlyingAllocationPercent() bool { + return m.Has(tag.UnderlyingAllocationPercent) +} + +//HasUnderlyingSettlementType returns true if UnderlyingSettlementType is present, Tag 975 +func (m NoUnderlyings) HasUnderlyingSettlementType() bool { + return m.Has(tag.UnderlyingSettlementType) +} + +//HasUnderlyingCashAmount returns true if UnderlyingCashAmount is present, Tag 973 +func (m NoUnderlyings) HasUnderlyingCashAmount() bool { + return m.Has(tag.UnderlyingCashAmount) +} + +//HasUnderlyingCashType returns true if UnderlyingCashType is present, Tag 974 +func (m NoUnderlyings) HasUnderlyingCashType() bool { + return m.Has(tag.UnderlyingCashType) +} + +//HasUnderlyingUnitOfMeasure returns true if UnderlyingUnitOfMeasure is present, Tag 998 +func (m NoUnderlyings) HasUnderlyingUnitOfMeasure() bool { + return m.Has(tag.UnderlyingUnitOfMeasure) +} + +//HasUnderlyingTimeUnit returns true if UnderlyingTimeUnit is present, Tag 1000 +func (m NoUnderlyings) HasUnderlyingTimeUnit() bool { + return m.Has(tag.UnderlyingTimeUnit) +} + +//HasUnderlyingCapValue returns true if UnderlyingCapValue is present, Tag 1038 +func (m NoUnderlyings) HasUnderlyingCapValue() bool { + return m.Has(tag.UnderlyingCapValue) +} + +//HasNoUndlyInstrumentParties returns true if NoUndlyInstrumentParties is present, Tag 1058 +func (m NoUnderlyings) HasNoUndlyInstrumentParties() bool { + return m.Has(tag.NoUndlyInstrumentParties) +} + +//HasUnderlyingSettlMethod returns true if UnderlyingSettlMethod is present, Tag 1039 +func (m NoUnderlyings) HasUnderlyingSettlMethod() bool { + return m.Has(tag.UnderlyingSettlMethod) +} + +//HasUnderlyingAdjustedQuantity returns true if UnderlyingAdjustedQuantity is present, Tag 1044 +func (m NoUnderlyings) HasUnderlyingAdjustedQuantity() bool { + return m.Has(tag.UnderlyingAdjustedQuantity) +} + +//HasUnderlyingFXRate returns true if UnderlyingFXRate is present, Tag 1045 +func (m NoUnderlyings) HasUnderlyingFXRate() bool { + return m.Has(tag.UnderlyingFXRate) +} + +//HasUnderlyingFXRateCalc returns true if UnderlyingFXRateCalc is present, Tag 1046 +func (m NoUnderlyings) HasUnderlyingFXRateCalc() bool { + return m.Has(tag.UnderlyingFXRateCalc) +} + +//NoUnderlyingSecurityAltID is a repeating group element, Tag 457 +type NoUnderlyingSecurityAltID struct { + quickfix.Group +} + +//SetUnderlyingSecurityAltID sets UnderlyingSecurityAltID, Tag 458 +func (m NoUnderlyingSecurityAltID) SetUnderlyingSecurityAltID(v string) { + m.Set(field.NewUnderlyingSecurityAltID(v)) +} + +//SetUnderlyingSecurityAltIDSource sets UnderlyingSecurityAltIDSource, Tag 459 +func (m NoUnderlyingSecurityAltID) SetUnderlyingSecurityAltIDSource(v string) { + m.Set(field.NewUnderlyingSecurityAltIDSource(v)) +} + +//GetUnderlyingSecurityAltID gets UnderlyingSecurityAltID, Tag 458 +func (m NoUnderlyingSecurityAltID) GetUnderlyingSecurityAltID() (f field.UnderlyingSecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityAltIDSource gets UnderlyingSecurityAltIDSource, Tag 459 +func (m NoUnderlyingSecurityAltID) GetUnderlyingSecurityAltIDSource() (f field.UnderlyingSecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingSecurityAltID returns true if UnderlyingSecurityAltID is present, Tag 458 +func (m NoUnderlyingSecurityAltID) HasUnderlyingSecurityAltID() bool { + return m.Has(tag.UnderlyingSecurityAltID) +} + +//HasUnderlyingSecurityAltIDSource returns true if UnderlyingSecurityAltIDSource is present, Tag 459 +func (m NoUnderlyingSecurityAltID) HasUnderlyingSecurityAltIDSource() bool { + return m.Has(tag.UnderlyingSecurityAltIDSource) +} + +//NoUnderlyingSecurityAltIDRepeatingGroup is a repeating group, Tag 457 +type NoUnderlyingSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingSecurityAltIDRepeatingGroup returns an initialized, NoUnderlyingSecurityAltIDRepeatingGroup +func NewNoUnderlyingSecurityAltIDRepeatingGroup() NoUnderlyingSecurityAltIDRepeatingGroup { + return NoUnderlyingSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyingSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingSecurityAltID), quickfix.GroupElement(tag.UnderlyingSecurityAltIDSource)})} +} + +//Add create and append a new NoUnderlyingSecurityAltID to this group +func (m NoUnderlyingSecurityAltIDRepeatingGroup) Add() NoUnderlyingSecurityAltID { + g := m.RepeatingGroup.Add() + return NoUnderlyingSecurityAltID{g} +} + +//Get returns the ith NoUnderlyingSecurityAltID in the NoUnderlyingSecurityAltIDRepeatinGroup +func (m NoUnderlyingSecurityAltIDRepeatingGroup) Get(i int) NoUnderlyingSecurityAltID { + return NoUnderlyingSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyingStips is a repeating group element, Tag 887 +type NoUnderlyingStips struct { + quickfix.Group +} + +//SetUnderlyingStipType sets UnderlyingStipType, Tag 888 +func (m NoUnderlyingStips) SetUnderlyingStipType(v string) { + m.Set(field.NewUnderlyingStipType(v)) +} + +//SetUnderlyingStipValue sets UnderlyingStipValue, Tag 889 +func (m NoUnderlyingStips) SetUnderlyingStipValue(v string) { + m.Set(field.NewUnderlyingStipValue(v)) +} + +//GetUnderlyingStipType gets UnderlyingStipType, Tag 888 +func (m NoUnderlyingStips) GetUnderlyingStipType() (f field.UnderlyingStipTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStipValue gets UnderlyingStipValue, Tag 889 +func (m NoUnderlyingStips) GetUnderlyingStipValue() (f field.UnderlyingStipValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingStipType returns true if UnderlyingStipType is present, Tag 888 +func (m NoUnderlyingStips) HasUnderlyingStipType() bool { + return m.Has(tag.UnderlyingStipType) +} + +//HasUnderlyingStipValue returns true if UnderlyingStipValue is present, Tag 889 +func (m NoUnderlyingStips) HasUnderlyingStipValue() bool { + return m.Has(tag.UnderlyingStipValue) +} + +//NoUnderlyingStipsRepeatingGroup is a repeating group, Tag 887 +type NoUnderlyingStipsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingStipsRepeatingGroup returns an initialized, NoUnderlyingStipsRepeatingGroup +func NewNoUnderlyingStipsRepeatingGroup() NoUnderlyingStipsRepeatingGroup { + return NoUnderlyingStipsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyingStips, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingStipType), quickfix.GroupElement(tag.UnderlyingStipValue)})} +} + +//Add create and append a new NoUnderlyingStips to this group +func (m NoUnderlyingStipsRepeatingGroup) Add() NoUnderlyingStips { + g := m.RepeatingGroup.Add() + return NoUnderlyingStips{g} +} + +//Get returns the ith NoUnderlyingStips in the NoUnderlyingStipsRepeatinGroup +func (m NoUnderlyingStipsRepeatingGroup) Get(i int) NoUnderlyingStips { + return NoUnderlyingStips{m.RepeatingGroup.Get(i)} +} + +//NoUndlyInstrumentParties is a repeating group element, Tag 1058 +type NoUndlyInstrumentParties struct { + quickfix.Group +} + +//SetUndlyInstrumentPartyID sets UndlyInstrumentPartyID, Tag 1059 +func (m NoUndlyInstrumentParties) SetUndlyInstrumentPartyID(v string) { + m.Set(field.NewUndlyInstrumentPartyID(v)) +} + +//SetUndlyInstrumentPartyIDSource sets UndlyInstrumentPartyIDSource, Tag 1060 +func (m NoUndlyInstrumentParties) SetUndlyInstrumentPartyIDSource(v string) { + m.Set(field.NewUndlyInstrumentPartyIDSource(v)) +} + +//SetUndlyInstrumentPartyRole sets UndlyInstrumentPartyRole, Tag 1061 +func (m NoUndlyInstrumentParties) SetUndlyInstrumentPartyRole(v int) { + m.Set(field.NewUndlyInstrumentPartyRole(v)) +} + +//SetNoUndlyInstrumentPartySubIDs sets NoUndlyInstrumentPartySubIDs, Tag 1062 +func (m NoUndlyInstrumentParties) SetNoUndlyInstrumentPartySubIDs(f NoUndlyInstrumentPartySubIDsRepeatingGroup) { + m.SetGroup(f) +} + +//GetUndlyInstrumentPartyID gets UndlyInstrumentPartyID, Tag 1059 +func (m NoUndlyInstrumentParties) GetUndlyInstrumentPartyID() (f field.UndlyInstrumentPartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUndlyInstrumentPartyIDSource gets UndlyInstrumentPartyIDSource, Tag 1060 +func (m NoUndlyInstrumentParties) GetUndlyInstrumentPartyIDSource() (f field.UndlyInstrumentPartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUndlyInstrumentPartyRole gets UndlyInstrumentPartyRole, Tag 1061 +func (m NoUndlyInstrumentParties) GetUndlyInstrumentPartyRole() (f field.UndlyInstrumentPartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUndlyInstrumentPartySubIDs gets NoUndlyInstrumentPartySubIDs, Tag 1062 +func (m NoUndlyInstrumentParties) GetNoUndlyInstrumentPartySubIDs() (NoUndlyInstrumentPartySubIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUndlyInstrumentPartySubIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasUndlyInstrumentPartyID returns true if UndlyInstrumentPartyID is present, Tag 1059 +func (m NoUndlyInstrumentParties) HasUndlyInstrumentPartyID() bool { + return m.Has(tag.UndlyInstrumentPartyID) +} + +//HasUndlyInstrumentPartyIDSource returns true if UndlyInstrumentPartyIDSource is present, Tag 1060 +func (m NoUndlyInstrumentParties) HasUndlyInstrumentPartyIDSource() bool { + return m.Has(tag.UndlyInstrumentPartyIDSource) +} + +//HasUndlyInstrumentPartyRole returns true if UndlyInstrumentPartyRole is present, Tag 1061 +func (m NoUndlyInstrumentParties) HasUndlyInstrumentPartyRole() bool { + return m.Has(tag.UndlyInstrumentPartyRole) +} + +//HasNoUndlyInstrumentPartySubIDs returns true if NoUndlyInstrumentPartySubIDs is present, Tag 1062 +func (m NoUndlyInstrumentParties) HasNoUndlyInstrumentPartySubIDs() bool { + return m.Has(tag.NoUndlyInstrumentPartySubIDs) +} + +//NoUndlyInstrumentPartySubIDs is a repeating group element, Tag 1062 +type NoUndlyInstrumentPartySubIDs struct { + quickfix.Group +} + +//SetUndlyInstrumentPartySubID sets UndlyInstrumentPartySubID, Tag 1063 +func (m NoUndlyInstrumentPartySubIDs) SetUndlyInstrumentPartySubID(v string) { + m.Set(field.NewUndlyInstrumentPartySubID(v)) +} + +//SetUndlyInstrumentPartySubIDType sets UndlyInstrumentPartySubIDType, Tag 1064 +func (m NoUndlyInstrumentPartySubIDs) SetUndlyInstrumentPartySubIDType(v int) { + m.Set(field.NewUndlyInstrumentPartySubIDType(v)) +} + +//GetUndlyInstrumentPartySubID gets UndlyInstrumentPartySubID, Tag 1063 +func (m NoUndlyInstrumentPartySubIDs) GetUndlyInstrumentPartySubID() (f field.UndlyInstrumentPartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUndlyInstrumentPartySubIDType gets UndlyInstrumentPartySubIDType, Tag 1064 +func (m NoUndlyInstrumentPartySubIDs) GetUndlyInstrumentPartySubIDType() (f field.UndlyInstrumentPartySubIDTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUndlyInstrumentPartySubID returns true if UndlyInstrumentPartySubID is present, Tag 1063 +func (m NoUndlyInstrumentPartySubIDs) HasUndlyInstrumentPartySubID() bool { + return m.Has(tag.UndlyInstrumentPartySubID) +} + +//HasUndlyInstrumentPartySubIDType returns true if UndlyInstrumentPartySubIDType is present, Tag 1064 +func (m NoUndlyInstrumentPartySubIDs) HasUndlyInstrumentPartySubIDType() bool { + return m.Has(tag.UndlyInstrumentPartySubIDType) +} + +//NoUndlyInstrumentPartySubIDsRepeatingGroup is a repeating group, Tag 1062 +type NoUndlyInstrumentPartySubIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUndlyInstrumentPartySubIDsRepeatingGroup returns an initialized, NoUndlyInstrumentPartySubIDsRepeatingGroup +func NewNoUndlyInstrumentPartySubIDsRepeatingGroup() NoUndlyInstrumentPartySubIDsRepeatingGroup { + return NoUndlyInstrumentPartySubIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUndlyInstrumentPartySubIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UndlyInstrumentPartySubID), quickfix.GroupElement(tag.UndlyInstrumentPartySubIDType)})} +} + +//Add create and append a new NoUndlyInstrumentPartySubIDs to this group +func (m NoUndlyInstrumentPartySubIDsRepeatingGroup) Add() NoUndlyInstrumentPartySubIDs { + g := m.RepeatingGroup.Add() + return NoUndlyInstrumentPartySubIDs{g} +} + +//Get returns the ith NoUndlyInstrumentPartySubIDs in the NoUndlyInstrumentPartySubIDsRepeatinGroup +func (m NoUndlyInstrumentPartySubIDsRepeatingGroup) Get(i int) NoUndlyInstrumentPartySubIDs { + return NoUndlyInstrumentPartySubIDs{m.RepeatingGroup.Get(i)} +} + +//NoUndlyInstrumentPartiesRepeatingGroup is a repeating group, Tag 1058 +type NoUndlyInstrumentPartiesRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUndlyInstrumentPartiesRepeatingGroup returns an initialized, NoUndlyInstrumentPartiesRepeatingGroup +func NewNoUndlyInstrumentPartiesRepeatingGroup() NoUndlyInstrumentPartiesRepeatingGroup { + return NoUndlyInstrumentPartiesRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUndlyInstrumentParties, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UndlyInstrumentPartyID), quickfix.GroupElement(tag.UndlyInstrumentPartyIDSource), quickfix.GroupElement(tag.UndlyInstrumentPartyRole), NewNoUndlyInstrumentPartySubIDsRepeatingGroup()})} +} + +//Add create and append a new NoUndlyInstrumentParties to this group +func (m NoUndlyInstrumentPartiesRepeatingGroup) Add() NoUndlyInstrumentParties { + g := m.RepeatingGroup.Add() + return NoUndlyInstrumentParties{g} +} + +//Get returns the ith NoUndlyInstrumentParties in the NoUndlyInstrumentPartiesRepeatinGroup +func (m NoUndlyInstrumentPartiesRepeatingGroup) Get(i int) NoUndlyInstrumentParties { + return NoUndlyInstrumentParties{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyingsRepeatingGroup is a repeating group, Tag 711 +type NoUnderlyingsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingsRepeatingGroup returns an initialized, NoUnderlyingsRepeatingGroup +func NewNoUnderlyingsRepeatingGroup() NoUnderlyingsRepeatingGroup { + return NoUnderlyingsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyings, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingSymbol), quickfix.GroupElement(tag.UnderlyingSymbolSfx), quickfix.GroupElement(tag.UnderlyingSecurityID), quickfix.GroupElement(tag.UnderlyingSecurityIDSource), NewNoUnderlyingSecurityAltIDRepeatingGroup(), quickfix.GroupElement(tag.UnderlyingProduct), quickfix.GroupElement(tag.UnderlyingCFICode), quickfix.GroupElement(tag.UnderlyingSecurityType), quickfix.GroupElement(tag.UnderlyingSecuritySubType), quickfix.GroupElement(tag.UnderlyingMaturityMonthYear), quickfix.GroupElement(tag.UnderlyingMaturityDate), quickfix.GroupElement(tag.UnderlyingCouponPaymentDate), quickfix.GroupElement(tag.UnderlyingIssueDate), quickfix.GroupElement(tag.UnderlyingRepoCollateralSecurityType), quickfix.GroupElement(tag.UnderlyingRepurchaseTerm), quickfix.GroupElement(tag.UnderlyingRepurchaseRate), quickfix.GroupElement(tag.UnderlyingFactor), quickfix.GroupElement(tag.UnderlyingCreditRating), quickfix.GroupElement(tag.UnderlyingInstrRegistry), quickfix.GroupElement(tag.UnderlyingCountryOfIssue), quickfix.GroupElement(tag.UnderlyingStateOrProvinceOfIssue), quickfix.GroupElement(tag.UnderlyingLocaleOfIssue), quickfix.GroupElement(tag.UnderlyingRedemptionDate), quickfix.GroupElement(tag.UnderlyingStrikePrice), quickfix.GroupElement(tag.UnderlyingStrikeCurrency), quickfix.GroupElement(tag.UnderlyingOptAttribute), quickfix.GroupElement(tag.UnderlyingContractMultiplier), quickfix.GroupElement(tag.UnderlyingCouponRate), quickfix.GroupElement(tag.UnderlyingSecurityExchange), quickfix.GroupElement(tag.UnderlyingIssuer), quickfix.GroupElement(tag.EncodedUnderlyingIssuerLen), quickfix.GroupElement(tag.EncodedUnderlyingIssuer), quickfix.GroupElement(tag.UnderlyingSecurityDesc), quickfix.GroupElement(tag.EncodedUnderlyingSecurityDescLen), quickfix.GroupElement(tag.EncodedUnderlyingSecurityDesc), quickfix.GroupElement(tag.UnderlyingCPProgram), quickfix.GroupElement(tag.UnderlyingCPRegType), quickfix.GroupElement(tag.UnderlyingCurrency), quickfix.GroupElement(tag.UnderlyingQty), quickfix.GroupElement(tag.UnderlyingPx), quickfix.GroupElement(tag.UnderlyingDirtyPrice), quickfix.GroupElement(tag.UnderlyingEndPrice), quickfix.GroupElement(tag.UnderlyingStartValue), quickfix.GroupElement(tag.UnderlyingCurrentValue), quickfix.GroupElement(tag.UnderlyingEndValue), NewNoUnderlyingStipsRepeatingGroup(), quickfix.GroupElement(tag.UnderlyingAllocationPercent), quickfix.GroupElement(tag.UnderlyingSettlementType), quickfix.GroupElement(tag.UnderlyingCashAmount), quickfix.GroupElement(tag.UnderlyingCashType), quickfix.GroupElement(tag.UnderlyingUnitOfMeasure), quickfix.GroupElement(tag.UnderlyingTimeUnit), quickfix.GroupElement(tag.UnderlyingCapValue), NewNoUndlyInstrumentPartiesRepeatingGroup(), quickfix.GroupElement(tag.UnderlyingSettlMethod), quickfix.GroupElement(tag.UnderlyingAdjustedQuantity), quickfix.GroupElement(tag.UnderlyingFXRate), quickfix.GroupElement(tag.UnderlyingFXRateCalc)})} +} + +//Add create and append a new NoUnderlyings to this group +func (m NoUnderlyingsRepeatingGroup) Add() NoUnderlyings { + g := m.RepeatingGroup.Add() + return NoUnderlyings{g} +} + +//Get returns the ith NoUnderlyings in the NoUnderlyingsRepeatinGroup +func (m NoUnderlyingsRepeatingGroup) Get(i int) NoUnderlyings { + return NoUnderlyings{m.RepeatingGroup.Get(i)} +} + +//NoLegs is a repeating group element, Tag 555 +type NoLegs struct { + quickfix.Group +} + +//SetLegSymbol sets LegSymbol, Tag 600 +func (m NoLegs) SetLegSymbol(v string) { + m.Set(field.NewLegSymbol(v)) +} + +//SetLegSymbolSfx sets LegSymbolSfx, Tag 601 +func (m NoLegs) SetLegSymbolSfx(v string) { + m.Set(field.NewLegSymbolSfx(v)) +} + +//SetLegSecurityID sets LegSecurityID, Tag 602 +func (m NoLegs) SetLegSecurityID(v string) { + m.Set(field.NewLegSecurityID(v)) +} + +//SetLegSecurityIDSource sets LegSecurityIDSource, Tag 603 +func (m NoLegs) SetLegSecurityIDSource(v string) { + m.Set(field.NewLegSecurityIDSource(v)) +} + +//SetNoLegSecurityAltID sets NoLegSecurityAltID, Tag 604 +func (m NoLegs) SetNoLegSecurityAltID(f NoLegSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetLegProduct sets LegProduct, Tag 607 +func (m NoLegs) SetLegProduct(v int) { + m.Set(field.NewLegProduct(v)) +} + +//SetLegCFICode sets LegCFICode, Tag 608 +func (m NoLegs) SetLegCFICode(v string) { + m.Set(field.NewLegCFICode(v)) +} + +//SetLegSecurityType sets LegSecurityType, Tag 609 +func (m NoLegs) SetLegSecurityType(v string) { + m.Set(field.NewLegSecurityType(v)) +} + +//SetLegSecuritySubType sets LegSecuritySubType, Tag 764 +func (m NoLegs) SetLegSecuritySubType(v string) { + m.Set(field.NewLegSecuritySubType(v)) +} + +//SetLegMaturityMonthYear sets LegMaturityMonthYear, Tag 610 +func (m NoLegs) SetLegMaturityMonthYear(v string) { + m.Set(field.NewLegMaturityMonthYear(v)) +} + +//SetLegMaturityDate sets LegMaturityDate, Tag 611 +func (m NoLegs) SetLegMaturityDate(v string) { + m.Set(field.NewLegMaturityDate(v)) +} + +//SetLegCouponPaymentDate sets LegCouponPaymentDate, Tag 248 +func (m NoLegs) SetLegCouponPaymentDate(v string) { + m.Set(field.NewLegCouponPaymentDate(v)) +} + +//SetLegIssueDate sets LegIssueDate, Tag 249 +func (m NoLegs) SetLegIssueDate(v string) { + m.Set(field.NewLegIssueDate(v)) +} + +//SetLegRepoCollateralSecurityType sets LegRepoCollateralSecurityType, Tag 250 +func (m NoLegs) SetLegRepoCollateralSecurityType(v int) { + m.Set(field.NewLegRepoCollateralSecurityType(v)) +} + +//SetLegRepurchaseTerm sets LegRepurchaseTerm, Tag 251 +func (m NoLegs) SetLegRepurchaseTerm(v int) { + m.Set(field.NewLegRepurchaseTerm(v)) +} + +//SetLegRepurchaseRate sets LegRepurchaseRate, Tag 252 +func (m NoLegs) SetLegRepurchaseRate(v float64) { + m.Set(field.NewLegRepurchaseRate(v)) +} + +//SetLegFactor sets LegFactor, Tag 253 +func (m NoLegs) SetLegFactor(v float64) { + m.Set(field.NewLegFactor(v)) +} + +//SetLegCreditRating sets LegCreditRating, Tag 257 +func (m NoLegs) SetLegCreditRating(v string) { + m.Set(field.NewLegCreditRating(v)) +} + +//SetLegInstrRegistry sets LegInstrRegistry, Tag 599 +func (m NoLegs) SetLegInstrRegistry(v string) { + m.Set(field.NewLegInstrRegistry(v)) +} + +//SetLegCountryOfIssue sets LegCountryOfIssue, Tag 596 +func (m NoLegs) SetLegCountryOfIssue(v string) { + m.Set(field.NewLegCountryOfIssue(v)) +} + +//SetLegStateOrProvinceOfIssue sets LegStateOrProvinceOfIssue, Tag 597 +func (m NoLegs) SetLegStateOrProvinceOfIssue(v string) { + m.Set(field.NewLegStateOrProvinceOfIssue(v)) +} + +//SetLegLocaleOfIssue sets LegLocaleOfIssue, Tag 598 +func (m NoLegs) SetLegLocaleOfIssue(v string) { + m.Set(field.NewLegLocaleOfIssue(v)) +} + +//SetLegRedemptionDate sets LegRedemptionDate, Tag 254 +func (m NoLegs) SetLegRedemptionDate(v string) { + m.Set(field.NewLegRedemptionDate(v)) +} + +//SetLegStrikePrice sets LegStrikePrice, Tag 612 +func (m NoLegs) SetLegStrikePrice(v float64) { + m.Set(field.NewLegStrikePrice(v)) +} + +//SetLegStrikeCurrency sets LegStrikeCurrency, Tag 942 +func (m NoLegs) SetLegStrikeCurrency(v string) { + m.Set(field.NewLegStrikeCurrency(v)) +} + +//SetLegOptAttribute sets LegOptAttribute, Tag 613 +func (m NoLegs) SetLegOptAttribute(v string) { + m.Set(field.NewLegOptAttribute(v)) +} + +//SetLegContractMultiplier sets LegContractMultiplier, Tag 614 +func (m NoLegs) SetLegContractMultiplier(v float64) { + m.Set(field.NewLegContractMultiplier(v)) +} + +//SetLegCouponRate sets LegCouponRate, Tag 615 +func (m NoLegs) SetLegCouponRate(v float64) { + m.Set(field.NewLegCouponRate(v)) +} + +//SetLegSecurityExchange sets LegSecurityExchange, Tag 616 +func (m NoLegs) SetLegSecurityExchange(v string) { + m.Set(field.NewLegSecurityExchange(v)) +} + +//SetLegIssuer sets LegIssuer, Tag 617 +func (m NoLegs) SetLegIssuer(v string) { + m.Set(field.NewLegIssuer(v)) +} + +//SetEncodedLegIssuerLen sets EncodedLegIssuerLen, Tag 618 +func (m NoLegs) SetEncodedLegIssuerLen(v int) { + m.Set(field.NewEncodedLegIssuerLen(v)) +} + +//SetEncodedLegIssuer sets EncodedLegIssuer, Tag 619 +func (m NoLegs) SetEncodedLegIssuer(v string) { + m.Set(field.NewEncodedLegIssuer(v)) +} + +//SetLegSecurityDesc sets LegSecurityDesc, Tag 620 +func (m NoLegs) SetLegSecurityDesc(v string) { + m.Set(field.NewLegSecurityDesc(v)) +} + +//SetEncodedLegSecurityDescLen sets EncodedLegSecurityDescLen, Tag 621 +func (m NoLegs) SetEncodedLegSecurityDescLen(v int) { + m.Set(field.NewEncodedLegSecurityDescLen(v)) +} + +//SetEncodedLegSecurityDesc sets EncodedLegSecurityDesc, Tag 622 +func (m NoLegs) SetEncodedLegSecurityDesc(v string) { + m.Set(field.NewEncodedLegSecurityDesc(v)) +} + +//SetLegRatioQty sets LegRatioQty, Tag 623 +func (m NoLegs) SetLegRatioQty(v float64) { + m.Set(field.NewLegRatioQty(v)) +} + +//SetLegSide sets LegSide, Tag 624 +func (m NoLegs) SetLegSide(v string) { + m.Set(field.NewLegSide(v)) +} + +//SetLegCurrency sets LegCurrency, Tag 556 +func (m NoLegs) SetLegCurrency(v string) { + m.Set(field.NewLegCurrency(v)) +} + +//SetLegPool sets LegPool, Tag 740 +func (m NoLegs) SetLegPool(v string) { + m.Set(field.NewLegPool(v)) +} + +//SetLegDatedDate sets LegDatedDate, Tag 739 +func (m NoLegs) SetLegDatedDate(v string) { + m.Set(field.NewLegDatedDate(v)) +} + +//SetLegContractSettlMonth sets LegContractSettlMonth, Tag 955 +func (m NoLegs) SetLegContractSettlMonth(v string) { + m.Set(field.NewLegContractSettlMonth(v)) +} + +//SetLegInterestAccrualDate sets LegInterestAccrualDate, Tag 956 +func (m NoLegs) SetLegInterestAccrualDate(v string) { + m.Set(field.NewLegInterestAccrualDate(v)) +} + +//SetLegUnitOfMeasure sets LegUnitOfMeasure, Tag 999 +func (m NoLegs) SetLegUnitOfMeasure(v string) { + m.Set(field.NewLegUnitOfMeasure(v)) +} + +//SetLegTimeUnit sets LegTimeUnit, Tag 1001 +func (m NoLegs) SetLegTimeUnit(v string) { + m.Set(field.NewLegTimeUnit(v)) +} + +//GetLegSymbol gets LegSymbol, Tag 600 +func (m NoLegs) GetLegSymbol() (f field.LegSymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSymbolSfx gets LegSymbolSfx, Tag 601 +func (m NoLegs) GetLegSymbolSfx() (f field.LegSymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityID gets LegSecurityID, Tag 602 +func (m NoLegs) GetLegSecurityID() (f field.LegSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityIDSource gets LegSecurityIDSource, Tag 603 +func (m NoLegs) GetLegSecurityIDSource() (f field.LegSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoLegSecurityAltID gets NoLegSecurityAltID, Tag 604 +func (m NoLegs) GetNoLegSecurityAltID() (NoLegSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoLegSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetLegProduct gets LegProduct, Tag 607 +func (m NoLegs) GetLegProduct() (f field.LegProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCFICode gets LegCFICode, Tag 608 +func (m NoLegs) GetLegCFICode() (f field.LegCFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityType gets LegSecurityType, Tag 609 +func (m NoLegs) GetLegSecurityType() (f field.LegSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecuritySubType gets LegSecuritySubType, Tag 764 +func (m NoLegs) GetLegSecuritySubType() (f field.LegSecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegMaturityMonthYear gets LegMaturityMonthYear, Tag 610 +func (m NoLegs) GetLegMaturityMonthYear() (f field.LegMaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegMaturityDate gets LegMaturityDate, Tag 611 +func (m NoLegs) GetLegMaturityDate() (f field.LegMaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCouponPaymentDate gets LegCouponPaymentDate, Tag 248 +func (m NoLegs) GetLegCouponPaymentDate() (f field.LegCouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegIssueDate gets LegIssueDate, Tag 249 +func (m NoLegs) GetLegIssueDate() (f field.LegIssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRepoCollateralSecurityType gets LegRepoCollateralSecurityType, Tag 250 +func (m NoLegs) GetLegRepoCollateralSecurityType() (f field.LegRepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRepurchaseTerm gets LegRepurchaseTerm, Tag 251 +func (m NoLegs) GetLegRepurchaseTerm() (f field.LegRepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRepurchaseRate gets LegRepurchaseRate, Tag 252 +func (m NoLegs) GetLegRepurchaseRate() (f field.LegRepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegFactor gets LegFactor, Tag 253 +func (m NoLegs) GetLegFactor() (f field.LegFactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCreditRating gets LegCreditRating, Tag 257 +func (m NoLegs) GetLegCreditRating() (f field.LegCreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegInstrRegistry gets LegInstrRegistry, Tag 599 +func (m NoLegs) GetLegInstrRegistry() (f field.LegInstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCountryOfIssue gets LegCountryOfIssue, Tag 596 +func (m NoLegs) GetLegCountryOfIssue() (f field.LegCountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegStateOrProvinceOfIssue gets LegStateOrProvinceOfIssue, Tag 597 +func (m NoLegs) GetLegStateOrProvinceOfIssue() (f field.LegStateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegLocaleOfIssue gets LegLocaleOfIssue, Tag 598 +func (m NoLegs) GetLegLocaleOfIssue() (f field.LegLocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRedemptionDate gets LegRedemptionDate, Tag 254 +func (m NoLegs) GetLegRedemptionDate() (f field.LegRedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegStrikePrice gets LegStrikePrice, Tag 612 +func (m NoLegs) GetLegStrikePrice() (f field.LegStrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegStrikeCurrency gets LegStrikeCurrency, Tag 942 +func (m NoLegs) GetLegStrikeCurrency() (f field.LegStrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegOptAttribute gets LegOptAttribute, Tag 613 +func (m NoLegs) GetLegOptAttribute() (f field.LegOptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegContractMultiplier gets LegContractMultiplier, Tag 614 +func (m NoLegs) GetLegContractMultiplier() (f field.LegContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCouponRate gets LegCouponRate, Tag 615 +func (m NoLegs) GetLegCouponRate() (f field.LegCouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityExchange gets LegSecurityExchange, Tag 616 +func (m NoLegs) GetLegSecurityExchange() (f field.LegSecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegIssuer gets LegIssuer, Tag 617 +func (m NoLegs) GetLegIssuer() (f field.LegIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegIssuerLen gets EncodedLegIssuerLen, Tag 618 +func (m NoLegs) GetEncodedLegIssuerLen() (f field.EncodedLegIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegIssuer gets EncodedLegIssuer, Tag 619 +func (m NoLegs) GetEncodedLegIssuer() (f field.EncodedLegIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityDesc gets LegSecurityDesc, Tag 620 +func (m NoLegs) GetLegSecurityDesc() (f field.LegSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegSecurityDescLen gets EncodedLegSecurityDescLen, Tag 621 +func (m NoLegs) GetEncodedLegSecurityDescLen() (f field.EncodedLegSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedLegSecurityDesc gets EncodedLegSecurityDesc, Tag 622 +func (m NoLegs) GetEncodedLegSecurityDesc() (f field.EncodedLegSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegRatioQty gets LegRatioQty, Tag 623 +func (m NoLegs) GetLegRatioQty() (f field.LegRatioQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSide gets LegSide, Tag 624 +func (m NoLegs) GetLegSide() (f field.LegSideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegCurrency gets LegCurrency, Tag 556 +func (m NoLegs) GetLegCurrency() (f field.LegCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegPool gets LegPool, Tag 740 +func (m NoLegs) GetLegPool() (f field.LegPoolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegDatedDate gets LegDatedDate, Tag 739 +func (m NoLegs) GetLegDatedDate() (f field.LegDatedDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegContractSettlMonth gets LegContractSettlMonth, Tag 955 +func (m NoLegs) GetLegContractSettlMonth() (f field.LegContractSettlMonthField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegInterestAccrualDate gets LegInterestAccrualDate, Tag 956 +func (m NoLegs) GetLegInterestAccrualDate() (f field.LegInterestAccrualDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegUnitOfMeasure gets LegUnitOfMeasure, Tag 999 +func (m NoLegs) GetLegUnitOfMeasure() (f field.LegUnitOfMeasureField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegTimeUnit gets LegTimeUnit, Tag 1001 +func (m NoLegs) GetLegTimeUnit() (f field.LegTimeUnitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasLegSymbol returns true if LegSymbol is present, Tag 600 +func (m NoLegs) HasLegSymbol() bool { + return m.Has(tag.LegSymbol) +} + +//HasLegSymbolSfx returns true if LegSymbolSfx is present, Tag 601 +func (m NoLegs) HasLegSymbolSfx() bool { + return m.Has(tag.LegSymbolSfx) +} + +//HasLegSecurityID returns true if LegSecurityID is present, Tag 602 +func (m NoLegs) HasLegSecurityID() bool { + return m.Has(tag.LegSecurityID) +} + +//HasLegSecurityIDSource returns true if LegSecurityIDSource is present, Tag 603 +func (m NoLegs) HasLegSecurityIDSource() bool { + return m.Has(tag.LegSecurityIDSource) +} + +//HasNoLegSecurityAltID returns true if NoLegSecurityAltID is present, Tag 604 +func (m NoLegs) HasNoLegSecurityAltID() bool { + return m.Has(tag.NoLegSecurityAltID) +} + +//HasLegProduct returns true if LegProduct is present, Tag 607 +func (m NoLegs) HasLegProduct() bool { + return m.Has(tag.LegProduct) +} + +//HasLegCFICode returns true if LegCFICode is present, Tag 608 +func (m NoLegs) HasLegCFICode() bool { + return m.Has(tag.LegCFICode) +} + +//HasLegSecurityType returns true if LegSecurityType is present, Tag 609 +func (m NoLegs) HasLegSecurityType() bool { + return m.Has(tag.LegSecurityType) +} + +//HasLegSecuritySubType returns true if LegSecuritySubType is present, Tag 764 +func (m NoLegs) HasLegSecuritySubType() bool { + return m.Has(tag.LegSecuritySubType) +} + +//HasLegMaturityMonthYear returns true if LegMaturityMonthYear is present, Tag 610 +func (m NoLegs) HasLegMaturityMonthYear() bool { + return m.Has(tag.LegMaturityMonthYear) +} + +//HasLegMaturityDate returns true if LegMaturityDate is present, Tag 611 +func (m NoLegs) HasLegMaturityDate() bool { + return m.Has(tag.LegMaturityDate) +} + +//HasLegCouponPaymentDate returns true if LegCouponPaymentDate is present, Tag 248 +func (m NoLegs) HasLegCouponPaymentDate() bool { + return m.Has(tag.LegCouponPaymentDate) +} + +//HasLegIssueDate returns true if LegIssueDate is present, Tag 249 +func (m NoLegs) HasLegIssueDate() bool { + return m.Has(tag.LegIssueDate) +} + +//HasLegRepoCollateralSecurityType returns true if LegRepoCollateralSecurityType is present, Tag 250 +func (m NoLegs) HasLegRepoCollateralSecurityType() bool { + return m.Has(tag.LegRepoCollateralSecurityType) +} + +//HasLegRepurchaseTerm returns true if LegRepurchaseTerm is present, Tag 251 +func (m NoLegs) HasLegRepurchaseTerm() bool { + return m.Has(tag.LegRepurchaseTerm) +} + +//HasLegRepurchaseRate returns true if LegRepurchaseRate is present, Tag 252 +func (m NoLegs) HasLegRepurchaseRate() bool { + return m.Has(tag.LegRepurchaseRate) +} + +//HasLegFactor returns true if LegFactor is present, Tag 253 +func (m NoLegs) HasLegFactor() bool { + return m.Has(tag.LegFactor) +} + +//HasLegCreditRating returns true if LegCreditRating is present, Tag 257 +func (m NoLegs) HasLegCreditRating() bool { + return m.Has(tag.LegCreditRating) +} + +//HasLegInstrRegistry returns true if LegInstrRegistry is present, Tag 599 +func (m NoLegs) HasLegInstrRegistry() bool { + return m.Has(tag.LegInstrRegistry) +} + +//HasLegCountryOfIssue returns true if LegCountryOfIssue is present, Tag 596 +func (m NoLegs) HasLegCountryOfIssue() bool { + return m.Has(tag.LegCountryOfIssue) +} + +//HasLegStateOrProvinceOfIssue returns true if LegStateOrProvinceOfIssue is present, Tag 597 +func (m NoLegs) HasLegStateOrProvinceOfIssue() bool { + return m.Has(tag.LegStateOrProvinceOfIssue) +} + +//HasLegLocaleOfIssue returns true if LegLocaleOfIssue is present, Tag 598 +func (m NoLegs) HasLegLocaleOfIssue() bool { + return m.Has(tag.LegLocaleOfIssue) +} + +//HasLegRedemptionDate returns true if LegRedemptionDate is present, Tag 254 +func (m NoLegs) HasLegRedemptionDate() bool { + return m.Has(tag.LegRedemptionDate) +} + +//HasLegStrikePrice returns true if LegStrikePrice is present, Tag 612 +func (m NoLegs) HasLegStrikePrice() bool { + return m.Has(tag.LegStrikePrice) +} + +//HasLegStrikeCurrency returns true if LegStrikeCurrency is present, Tag 942 +func (m NoLegs) HasLegStrikeCurrency() bool { + return m.Has(tag.LegStrikeCurrency) +} + +//HasLegOptAttribute returns true if LegOptAttribute is present, Tag 613 +func (m NoLegs) HasLegOptAttribute() bool { + return m.Has(tag.LegOptAttribute) +} + +//HasLegContractMultiplier returns true if LegContractMultiplier is present, Tag 614 +func (m NoLegs) HasLegContractMultiplier() bool { + return m.Has(tag.LegContractMultiplier) +} + +//HasLegCouponRate returns true if LegCouponRate is present, Tag 615 +func (m NoLegs) HasLegCouponRate() bool { + return m.Has(tag.LegCouponRate) +} + +//HasLegSecurityExchange returns true if LegSecurityExchange is present, Tag 616 +func (m NoLegs) HasLegSecurityExchange() bool { + return m.Has(tag.LegSecurityExchange) +} + +//HasLegIssuer returns true if LegIssuer is present, Tag 617 +func (m NoLegs) HasLegIssuer() bool { + return m.Has(tag.LegIssuer) +} + +//HasEncodedLegIssuerLen returns true if EncodedLegIssuerLen is present, Tag 618 +func (m NoLegs) HasEncodedLegIssuerLen() bool { + return m.Has(tag.EncodedLegIssuerLen) +} + +//HasEncodedLegIssuer returns true if EncodedLegIssuer is present, Tag 619 +func (m NoLegs) HasEncodedLegIssuer() bool { + return m.Has(tag.EncodedLegIssuer) +} + +//HasLegSecurityDesc returns true if LegSecurityDesc is present, Tag 620 +func (m NoLegs) HasLegSecurityDesc() bool { + return m.Has(tag.LegSecurityDesc) +} + +//HasEncodedLegSecurityDescLen returns true if EncodedLegSecurityDescLen is present, Tag 621 +func (m NoLegs) HasEncodedLegSecurityDescLen() bool { + return m.Has(tag.EncodedLegSecurityDescLen) +} + +//HasEncodedLegSecurityDesc returns true if EncodedLegSecurityDesc is present, Tag 622 +func (m NoLegs) HasEncodedLegSecurityDesc() bool { + return m.Has(tag.EncodedLegSecurityDesc) +} + +//HasLegRatioQty returns true if LegRatioQty is present, Tag 623 +func (m NoLegs) HasLegRatioQty() bool { + return m.Has(tag.LegRatioQty) +} + +//HasLegSide returns true if LegSide is present, Tag 624 +func (m NoLegs) HasLegSide() bool { + return m.Has(tag.LegSide) +} + +//HasLegCurrency returns true if LegCurrency is present, Tag 556 +func (m NoLegs) HasLegCurrency() bool { + return m.Has(tag.LegCurrency) +} + +//HasLegPool returns true if LegPool is present, Tag 740 +func (m NoLegs) HasLegPool() bool { + return m.Has(tag.LegPool) +} + +//HasLegDatedDate returns true if LegDatedDate is present, Tag 739 +func (m NoLegs) HasLegDatedDate() bool { + return m.Has(tag.LegDatedDate) +} + +//HasLegContractSettlMonth returns true if LegContractSettlMonth is present, Tag 955 +func (m NoLegs) HasLegContractSettlMonth() bool { + return m.Has(tag.LegContractSettlMonth) +} + +//HasLegInterestAccrualDate returns true if LegInterestAccrualDate is present, Tag 956 +func (m NoLegs) HasLegInterestAccrualDate() bool { + return m.Has(tag.LegInterestAccrualDate) +} + +//HasLegUnitOfMeasure returns true if LegUnitOfMeasure is present, Tag 999 +func (m NoLegs) HasLegUnitOfMeasure() bool { + return m.Has(tag.LegUnitOfMeasure) +} + +//HasLegTimeUnit returns true if LegTimeUnit is present, Tag 1001 +func (m NoLegs) HasLegTimeUnit() bool { + return m.Has(tag.LegTimeUnit) +} + +//NoLegSecurityAltID is a repeating group element, Tag 604 +type NoLegSecurityAltID struct { + quickfix.Group +} + +//SetLegSecurityAltID sets LegSecurityAltID, Tag 605 +func (m NoLegSecurityAltID) SetLegSecurityAltID(v string) { + m.Set(field.NewLegSecurityAltID(v)) +} + +//SetLegSecurityAltIDSource sets LegSecurityAltIDSource, Tag 606 +func (m NoLegSecurityAltID) SetLegSecurityAltIDSource(v string) { + m.Set(field.NewLegSecurityAltIDSource(v)) +} + +//GetLegSecurityAltID gets LegSecurityAltID, Tag 605 +func (m NoLegSecurityAltID) GetLegSecurityAltID() (f field.LegSecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLegSecurityAltIDSource gets LegSecurityAltIDSource, Tag 606 +func (m NoLegSecurityAltID) GetLegSecurityAltIDSource() (f field.LegSecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasLegSecurityAltID returns true if LegSecurityAltID is present, Tag 605 +func (m NoLegSecurityAltID) HasLegSecurityAltID() bool { + return m.Has(tag.LegSecurityAltID) +} + +//HasLegSecurityAltIDSource returns true if LegSecurityAltIDSource is present, Tag 606 +func (m NoLegSecurityAltID) HasLegSecurityAltIDSource() bool { + return m.Has(tag.LegSecurityAltIDSource) +} + +//NoLegSecurityAltIDRepeatingGroup is a repeating group, Tag 604 +type NoLegSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoLegSecurityAltIDRepeatingGroup returns an initialized, NoLegSecurityAltIDRepeatingGroup +func NewNoLegSecurityAltIDRepeatingGroup() NoLegSecurityAltIDRepeatingGroup { + return NoLegSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoLegSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.LegSecurityAltID), quickfix.GroupElement(tag.LegSecurityAltIDSource)})} +} + +//Add create and append a new NoLegSecurityAltID to this group +func (m NoLegSecurityAltIDRepeatingGroup) Add() NoLegSecurityAltID { + g := m.RepeatingGroup.Add() + return NoLegSecurityAltID{g} +} + +//Get returns the ith NoLegSecurityAltID in the NoLegSecurityAltIDRepeatinGroup +func (m NoLegSecurityAltIDRepeatingGroup) Get(i int) NoLegSecurityAltID { + return NoLegSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoLegsRepeatingGroup is a repeating group, Tag 555 +type NoLegsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoLegsRepeatingGroup returns an initialized, NoLegsRepeatingGroup +func NewNoLegsRepeatingGroup() NoLegsRepeatingGroup { + return NoLegsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoLegs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.LegSymbol), quickfix.GroupElement(tag.LegSymbolSfx), quickfix.GroupElement(tag.LegSecurityID), quickfix.GroupElement(tag.LegSecurityIDSource), NewNoLegSecurityAltIDRepeatingGroup(), quickfix.GroupElement(tag.LegProduct), quickfix.GroupElement(tag.LegCFICode), quickfix.GroupElement(tag.LegSecurityType), quickfix.GroupElement(tag.LegSecuritySubType), quickfix.GroupElement(tag.LegMaturityMonthYear), quickfix.GroupElement(tag.LegMaturityDate), quickfix.GroupElement(tag.LegCouponPaymentDate), quickfix.GroupElement(tag.LegIssueDate), quickfix.GroupElement(tag.LegRepoCollateralSecurityType), quickfix.GroupElement(tag.LegRepurchaseTerm), quickfix.GroupElement(tag.LegRepurchaseRate), quickfix.GroupElement(tag.LegFactor), quickfix.GroupElement(tag.LegCreditRating), quickfix.GroupElement(tag.LegInstrRegistry), quickfix.GroupElement(tag.LegCountryOfIssue), quickfix.GroupElement(tag.LegStateOrProvinceOfIssue), quickfix.GroupElement(tag.LegLocaleOfIssue), quickfix.GroupElement(tag.LegRedemptionDate), quickfix.GroupElement(tag.LegStrikePrice), quickfix.GroupElement(tag.LegStrikeCurrency), quickfix.GroupElement(tag.LegOptAttribute), quickfix.GroupElement(tag.LegContractMultiplier), quickfix.GroupElement(tag.LegCouponRate), quickfix.GroupElement(tag.LegSecurityExchange), quickfix.GroupElement(tag.LegIssuer), quickfix.GroupElement(tag.EncodedLegIssuerLen), quickfix.GroupElement(tag.EncodedLegIssuer), quickfix.GroupElement(tag.LegSecurityDesc), quickfix.GroupElement(tag.EncodedLegSecurityDescLen), quickfix.GroupElement(tag.EncodedLegSecurityDesc), quickfix.GroupElement(tag.LegRatioQty), quickfix.GroupElement(tag.LegSide), quickfix.GroupElement(tag.LegCurrency), quickfix.GroupElement(tag.LegPool), quickfix.GroupElement(tag.LegDatedDate), quickfix.GroupElement(tag.LegContractSettlMonth), quickfix.GroupElement(tag.LegInterestAccrualDate), quickfix.GroupElement(tag.LegUnitOfMeasure), quickfix.GroupElement(tag.LegTimeUnit)})} +} + +//Add create and append a new NoLegs to this group +func (m NoLegsRepeatingGroup) Add() NoLegs { + g := m.RepeatingGroup.Add() + return NoLegs{g} +} + +//Get returns the ith NoLegs in the NoLegsRepeatinGroup +func (m NoLegsRepeatingGroup) Get(i int) NoLegs { + return NoLegs{m.RepeatingGroup.Get(i)} +} + +//NoRelatedSymRepeatingGroup is a repeating group, Tag 146 +type NoRelatedSymRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoRelatedSymRepeatingGroup returns an initialized, NoRelatedSymRepeatingGroup +func NewNoRelatedSymRepeatingGroup() NoRelatedSymRepeatingGroup { + return NoRelatedSymRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoRelatedSym, + quickfix.GroupTemplate{quickfix.GroupElement(tag.Symbol), quickfix.GroupElement(tag.SymbolSfx), quickfix.GroupElement(tag.SecurityID), quickfix.GroupElement(tag.SecurityIDSource), NewNoSecurityAltIDRepeatingGroup(), quickfix.GroupElement(tag.Product), quickfix.GroupElement(tag.CFICode), quickfix.GroupElement(tag.SecurityType), quickfix.GroupElement(tag.SecuritySubType), quickfix.GroupElement(tag.MaturityMonthYear), quickfix.GroupElement(tag.MaturityDate), quickfix.GroupElement(tag.CouponPaymentDate), quickfix.GroupElement(tag.IssueDate), quickfix.GroupElement(tag.RepoCollateralSecurityType), quickfix.GroupElement(tag.RepurchaseTerm), quickfix.GroupElement(tag.RepurchaseRate), quickfix.GroupElement(tag.Factor), quickfix.GroupElement(tag.CreditRating), quickfix.GroupElement(tag.InstrRegistry), quickfix.GroupElement(tag.CountryOfIssue), quickfix.GroupElement(tag.StateOrProvinceOfIssue), quickfix.GroupElement(tag.LocaleOfIssue), quickfix.GroupElement(tag.RedemptionDate), quickfix.GroupElement(tag.StrikePrice), quickfix.GroupElement(tag.StrikeCurrency), quickfix.GroupElement(tag.OptAttribute), quickfix.GroupElement(tag.ContractMultiplier), quickfix.GroupElement(tag.CouponRate), quickfix.GroupElement(tag.SecurityExchange), quickfix.GroupElement(tag.Issuer), quickfix.GroupElement(tag.EncodedIssuerLen), quickfix.GroupElement(tag.EncodedIssuer), quickfix.GroupElement(tag.SecurityDesc), quickfix.GroupElement(tag.EncodedSecurityDescLen), quickfix.GroupElement(tag.EncodedSecurityDesc), quickfix.GroupElement(tag.Pool), quickfix.GroupElement(tag.ContractSettlMonth), quickfix.GroupElement(tag.CPProgram), quickfix.GroupElement(tag.CPRegType), NewNoEventsRepeatingGroup(), quickfix.GroupElement(tag.DatedDate), quickfix.GroupElement(tag.InterestAccrualDate), quickfix.GroupElement(tag.SecurityStatus), quickfix.GroupElement(tag.SettleOnOpenFlag), quickfix.GroupElement(tag.InstrmtAssignmentMethod), quickfix.GroupElement(tag.StrikeMultiplier), quickfix.GroupElement(tag.StrikeValue), quickfix.GroupElement(tag.MinPriceIncrement), quickfix.GroupElement(tag.PositionLimit), quickfix.GroupElement(tag.NTPositionLimit), NewNoInstrumentPartiesRepeatingGroup(), quickfix.GroupElement(tag.UnitOfMeasure), quickfix.GroupElement(tag.TimeUnit), quickfix.GroupElement(tag.MaturityTime), NewNoUnderlyingsRepeatingGroup(), NewNoLegsRepeatingGroup(), quickfix.GroupElement(tag.Currency), quickfix.GroupElement(tag.QuoteType), quickfix.GroupElement(tag.SettlType), quickfix.GroupElement(tag.SettlDate), quickfix.GroupElement(tag.MDEntrySize)})} +} + +//Add create and append a new NoRelatedSym to this group +func (m NoRelatedSymRepeatingGroup) Add() NoRelatedSym { + g := m.RepeatingGroup.Add() + return NoRelatedSym{g} +} + +//Get returns the ith NoRelatedSym in the NoRelatedSymRepeatinGroup +func (m NoRelatedSymRepeatingGroup) Get(i int) NoRelatedSym { + return NoRelatedSym{m.RepeatingGroup.Get(i)} +} + +//NoMDEntryTypes is a repeating group element, Tag 267 +type NoMDEntryTypes struct { + quickfix.Group +} + +//SetMDEntryType sets MDEntryType, Tag 269 +func (m NoMDEntryTypes) SetMDEntryType(v string) { + m.Set(field.NewMDEntryType(v)) +} + +//GetMDEntryType gets MDEntryType, Tag 269 +func (m NoMDEntryTypes) GetMDEntryType() (f field.MDEntryTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasMDEntryType returns true if MDEntryType is present, Tag 269 +func (m NoMDEntryTypes) HasMDEntryType() bool { + return m.Has(tag.MDEntryType) +} + +//NoMDEntryTypesRepeatingGroup is a repeating group, Tag 267 +type NoMDEntryTypesRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoMDEntryTypesRepeatingGroup returns an initialized, NoMDEntryTypesRepeatingGroup +func NewNoMDEntryTypesRepeatingGroup() NoMDEntryTypesRepeatingGroup { + return NoMDEntryTypesRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoMDEntryTypes, + quickfix.GroupTemplate{quickfix.GroupElement(tag.MDEntryType)})} +} + +//Add create and append a new NoMDEntryTypes to this group +func (m NoMDEntryTypesRepeatingGroup) Add() NoMDEntryTypes { + g := m.RepeatingGroup.Add() + return NoMDEntryTypes{g} +} + +//Get returns the ith NoMDEntryTypes in the NoMDEntryTypesRepeatinGroup +func (m NoMDEntryTypesRepeatingGroup) Get(i int) NoMDEntryTypes { + return NoMDEntryTypes{m.RepeatingGroup.Get(i)} +} + +//NoTradingSessions is a repeating group element, Tag 386 +type NoTradingSessions struct { + quickfix.Group +} + +//SetTradingSessionID sets TradingSessionID, Tag 336 +func (m NoTradingSessions) SetTradingSessionID(v string) { + m.Set(field.NewTradingSessionID(v)) +} + +//SetTradingSessionSubID sets TradingSessionSubID, Tag 625 +func (m NoTradingSessions) SetTradingSessionSubID(v string) { + m.Set(field.NewTradingSessionSubID(v)) +} + +//GetTradingSessionID gets TradingSessionID, Tag 336 +func (m NoTradingSessions) GetTradingSessionID() (f field.TradingSessionIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradingSessionSubID gets TradingSessionSubID, Tag 625 +func (m NoTradingSessions) GetTradingSessionSubID() (f field.TradingSessionSubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasTradingSessionID returns true if TradingSessionID is present, Tag 336 +func (m NoTradingSessions) HasTradingSessionID() bool { + return m.Has(tag.TradingSessionID) +} + +//HasTradingSessionSubID returns true if TradingSessionSubID is present, Tag 625 +func (m NoTradingSessions) HasTradingSessionSubID() bool { + return m.Has(tag.TradingSessionSubID) +} + +//NoTradingSessionsRepeatingGroup is a repeating group, Tag 386 +type NoTradingSessionsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoTradingSessionsRepeatingGroup returns an initialized, NoTradingSessionsRepeatingGroup +func NewNoTradingSessionsRepeatingGroup() NoTradingSessionsRepeatingGroup { + return NoTradingSessionsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoTradingSessions, + quickfix.GroupTemplate{quickfix.GroupElement(tag.TradingSessionID), quickfix.GroupElement(tag.TradingSessionSubID)})} +} + +//Add create and append a new NoTradingSessions to this group +func (m NoTradingSessionsRepeatingGroup) Add() NoTradingSessions { + g := m.RepeatingGroup.Add() + return NoTradingSessions{g} +} + +//Get returns the ith NoTradingSessions in the NoTradingSessionsRepeatinGroup +func (m NoTradingSessionsRepeatingGroup) Get(i int) NoTradingSessions { + return NoTradingSessions{m.RepeatingGroup.Get(i)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix50/newordersingle/NewOrderSingle.generated.go b/vendor/github.com/quickfixgo/quickfix/fix50/newordersingle/NewOrderSingle.generated.go new file mode 100644 index 0000000..7b2d22b --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix50/newordersingle/NewOrderSingle.generated.go @@ -0,0 +1,5707 @@ +package newordersingle + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fixt11" + "github.com/quickfixgo/quickfix/tag" +) + +//NewOrderSingle is the fix50 NewOrderSingle type, MsgType = D +type NewOrderSingle struct { + fixt11.Header + quickfix.Body + fixt11.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a NewOrderSingle from a quickfix.Message instance +func FromMessage(m quickfix.Message) NewOrderSingle { + return NewOrderSingle{ + Header: fixt11.Header{Header: m.Header}, + Body: m.Body, + Trailer: fixt11.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m NewOrderSingle) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a NewOrderSingle initialized with the required fields for NewOrderSingle +func New(clordid field.ClOrdIDField, side field.SideField, transacttime field.TransactTimeField, ordtype field.OrdTypeField) (m NewOrderSingle) { + m.Header = fixt11.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("D")) + m.Set(clordid) + m.Set(side) + m.Set(transacttime) + m.Set(ordtype) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg NewOrderSingle, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "7", "D", r +} + +//SetAccount sets Account, Tag 1 +func (m NewOrderSingle) SetAccount(v string) { + m.Set(field.NewAccount(v)) +} + +//SetClOrdID sets ClOrdID, Tag 11 +func (m NewOrderSingle) SetClOrdID(v string) { + m.Set(field.NewClOrdID(v)) +} + +//SetCommission sets Commission, Tag 12 +func (m NewOrderSingle) SetCommission(v float64) { + m.Set(field.NewCommission(v)) +} + +//SetCommType sets CommType, Tag 13 +func (m NewOrderSingle) SetCommType(v string) { + m.Set(field.NewCommType(v)) +} + +//SetCurrency sets Currency, Tag 15 +func (m NewOrderSingle) SetCurrency(v string) { + m.Set(field.NewCurrency(v)) +} + +//SetExecInst sets ExecInst, Tag 18 +func (m NewOrderSingle) SetExecInst(v string) { + m.Set(field.NewExecInst(v)) +} + +//SetHandlInst sets HandlInst, Tag 21 +func (m NewOrderSingle) SetHandlInst(v string) { + m.Set(field.NewHandlInst(v)) +} + +//SetSecurityIDSource sets SecurityIDSource, Tag 22 +func (m NewOrderSingle) SetSecurityIDSource(v string) { + m.Set(field.NewSecurityIDSource(v)) +} + +//SetIOIID sets IOIID, Tag 23 +func (m NewOrderSingle) SetIOIID(v string) { + m.Set(field.NewIOIID(v)) +} + +//SetOrderQty sets OrderQty, Tag 38 +func (m NewOrderSingle) SetOrderQty(v float64) { + m.Set(field.NewOrderQty(v)) +} + +//SetOrdType sets OrdType, Tag 40 +func (m NewOrderSingle) SetOrdType(v string) { + m.Set(field.NewOrdType(v)) +} + +//SetPrice sets Price, Tag 44 +func (m NewOrderSingle) SetPrice(v float64) { + m.Set(field.NewPrice(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m NewOrderSingle) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSide sets Side, Tag 54 +func (m NewOrderSingle) SetSide(v string) { + m.Set(field.NewSide(v)) +} + +//SetSymbol sets Symbol, Tag 55 +func (m NewOrderSingle) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetText sets Text, Tag 58 +func (m NewOrderSingle) SetText(v string) { + m.Set(field.NewText(v)) +} + +//SetTimeInForce sets TimeInForce, Tag 59 +func (m NewOrderSingle) SetTimeInForce(v string) { + m.Set(field.NewTimeInForce(v)) +} + +//SetTransactTime sets TransactTime, Tag 60 +func (m NewOrderSingle) SetTransactTime(v time.Time) { + m.Set(field.NewTransactTime(v)) +} + +//SetSettlType sets SettlType, Tag 63 +func (m NewOrderSingle) SetSettlType(v string) { + m.Set(field.NewSettlType(v)) +} + +//SetSettlDate sets SettlDate, Tag 64 +func (m NewOrderSingle) SetSettlDate(v string) { + m.Set(field.NewSettlDate(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m NewOrderSingle) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetAllocID sets AllocID, Tag 70 +func (m NewOrderSingle) SetAllocID(v string) { + m.Set(field.NewAllocID(v)) +} + +//SetTradeDate sets TradeDate, Tag 75 +func (m NewOrderSingle) SetTradeDate(v string) { + m.Set(field.NewTradeDate(v)) +} + +//SetPositionEffect sets PositionEffect, Tag 77 +func (m NewOrderSingle) SetPositionEffect(v string) { + m.Set(field.NewPositionEffect(v)) +} + +//SetNoAllocs sets NoAllocs, Tag 78 +func (m NewOrderSingle) SetNoAllocs(f NoAllocsRepeatingGroup) { + m.SetGroup(f) +} + +//SetProcessCode sets ProcessCode, Tag 81 +func (m NewOrderSingle) SetProcessCode(v string) { + m.Set(field.NewProcessCode(v)) +} + +//SetStopPx sets StopPx, Tag 99 +func (m NewOrderSingle) SetStopPx(v float64) { + m.Set(field.NewStopPx(v)) +} + +//SetExDestination sets ExDestination, Tag 100 +func (m NewOrderSingle) SetExDestination(v string) { + m.Set(field.NewExDestination(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m NewOrderSingle) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m NewOrderSingle) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetMinQty sets MinQty, Tag 110 +func (m NewOrderSingle) SetMinQty(v float64) { + m.Set(field.NewMinQty(v)) +} + +//SetMaxFloor sets MaxFloor, Tag 111 +func (m NewOrderSingle) SetMaxFloor(v float64) { + m.Set(field.NewMaxFloor(v)) +} + +//SetLocateReqd sets LocateReqd, Tag 114 +func (m NewOrderSingle) SetLocateReqd(v bool) { + m.Set(field.NewLocateReqd(v)) +} + +//SetQuoteID sets QuoteID, Tag 117 +func (m NewOrderSingle) SetQuoteID(v string) { + m.Set(field.NewQuoteID(v)) +} + +//SetSettlCurrency sets SettlCurrency, Tag 120 +func (m NewOrderSingle) SetSettlCurrency(v string) { + m.Set(field.NewSettlCurrency(v)) +} + +//SetForexReq sets ForexReq, Tag 121 +func (m NewOrderSingle) SetForexReq(v bool) { + m.Set(field.NewForexReq(v)) +} + +//SetExpireTime sets ExpireTime, Tag 126 +func (m NewOrderSingle) SetExpireTime(v time.Time) { + m.Set(field.NewExpireTime(v)) +} + +//SetPrevClosePx sets PrevClosePx, Tag 140 +func (m NewOrderSingle) SetPrevClosePx(v float64) { + m.Set(field.NewPrevClosePx(v)) +} + +//SetCashOrderQty sets CashOrderQty, Tag 152 +func (m NewOrderSingle) SetCashOrderQty(v float64) { + m.Set(field.NewCashOrderQty(v)) +} + +//SetSecurityType sets SecurityType, Tag 167 +func (m NewOrderSingle) SetSecurityType(v string) { + m.Set(field.NewSecurityType(v)) +} + +//SetEffectiveTime sets EffectiveTime, Tag 168 +func (m NewOrderSingle) SetEffectiveTime(v time.Time) { + m.Set(field.NewEffectiveTime(v)) +} + +//SetOrderQty2 sets OrderQty2, Tag 192 +func (m NewOrderSingle) SetOrderQty2(v float64) { + m.Set(field.NewOrderQty2(v)) +} + +//SetSettlDate2 sets SettlDate2, Tag 193 +func (m NewOrderSingle) SetSettlDate2(v string) { + m.Set(field.NewSettlDate2(v)) +} + +//SetMaturityMonthYear sets MaturityMonthYear, Tag 200 +func (m NewOrderSingle) SetMaturityMonthYear(v string) { + m.Set(field.NewMaturityMonthYear(v)) +} + +//SetStrikePrice sets StrikePrice, Tag 202 +func (m NewOrderSingle) SetStrikePrice(v float64) { + m.Set(field.NewStrikePrice(v)) +} + +//SetCoveredOrUncovered sets CoveredOrUncovered, Tag 203 +func (m NewOrderSingle) SetCoveredOrUncovered(v int) { + m.Set(field.NewCoveredOrUncovered(v)) +} + +//SetOptAttribute sets OptAttribute, Tag 206 +func (m NewOrderSingle) SetOptAttribute(v string) { + m.Set(field.NewOptAttribute(v)) +} + +//SetSecurityExchange sets SecurityExchange, Tag 207 +func (m NewOrderSingle) SetSecurityExchange(v string) { + m.Set(field.NewSecurityExchange(v)) +} + +//SetMaxShow sets MaxShow, Tag 210 +func (m NewOrderSingle) SetMaxShow(v float64) { + m.Set(field.NewMaxShow(v)) +} + +//SetPegOffsetValue sets PegOffsetValue, Tag 211 +func (m NewOrderSingle) SetPegOffsetValue(v float64) { + m.Set(field.NewPegOffsetValue(v)) +} + +//SetSpread sets Spread, Tag 218 +func (m NewOrderSingle) SetSpread(v float64) { + m.Set(field.NewSpread(v)) +} + +//SetBenchmarkCurveCurrency sets BenchmarkCurveCurrency, Tag 220 +func (m NewOrderSingle) SetBenchmarkCurveCurrency(v string) { + m.Set(field.NewBenchmarkCurveCurrency(v)) +} + +//SetBenchmarkCurveName sets BenchmarkCurveName, Tag 221 +func (m NewOrderSingle) SetBenchmarkCurveName(v string) { + m.Set(field.NewBenchmarkCurveName(v)) +} + +//SetBenchmarkCurvePoint sets BenchmarkCurvePoint, Tag 222 +func (m NewOrderSingle) SetBenchmarkCurvePoint(v string) { + m.Set(field.NewBenchmarkCurvePoint(v)) +} + +//SetCouponRate sets CouponRate, Tag 223 +func (m NewOrderSingle) SetCouponRate(v float64) { + m.Set(field.NewCouponRate(v)) +} + +//SetCouponPaymentDate sets CouponPaymentDate, Tag 224 +func (m NewOrderSingle) SetCouponPaymentDate(v string) { + m.Set(field.NewCouponPaymentDate(v)) +} + +//SetIssueDate sets IssueDate, Tag 225 +func (m NewOrderSingle) SetIssueDate(v string) { + m.Set(field.NewIssueDate(v)) +} + +//SetRepurchaseTerm sets RepurchaseTerm, Tag 226 +func (m NewOrderSingle) SetRepurchaseTerm(v int) { + m.Set(field.NewRepurchaseTerm(v)) +} + +//SetRepurchaseRate sets RepurchaseRate, Tag 227 +func (m NewOrderSingle) SetRepurchaseRate(v float64) { + m.Set(field.NewRepurchaseRate(v)) +} + +//SetFactor sets Factor, Tag 228 +func (m NewOrderSingle) SetFactor(v float64) { + m.Set(field.NewFactor(v)) +} + +//SetTradeOriginationDate sets TradeOriginationDate, Tag 229 +func (m NewOrderSingle) SetTradeOriginationDate(v string) { + m.Set(field.NewTradeOriginationDate(v)) +} + +//SetContractMultiplier sets ContractMultiplier, Tag 231 +func (m NewOrderSingle) SetContractMultiplier(v float64) { + m.Set(field.NewContractMultiplier(v)) +} + +//SetNoStipulations sets NoStipulations, Tag 232 +func (m NewOrderSingle) SetNoStipulations(f NoStipulationsRepeatingGroup) { + m.SetGroup(f) +} + +//SetYieldType sets YieldType, Tag 235 +func (m NewOrderSingle) SetYieldType(v string) { + m.Set(field.NewYieldType(v)) +} + +//SetYield sets Yield, Tag 236 +func (m NewOrderSingle) SetYield(v float64) { + m.Set(field.NewYield(v)) +} + +//SetRepoCollateralSecurityType sets RepoCollateralSecurityType, Tag 239 +func (m NewOrderSingle) SetRepoCollateralSecurityType(v int) { + m.Set(field.NewRepoCollateralSecurityType(v)) +} + +//SetRedemptionDate sets RedemptionDate, Tag 240 +func (m NewOrderSingle) SetRedemptionDate(v string) { + m.Set(field.NewRedemptionDate(v)) +} + +//SetCreditRating sets CreditRating, Tag 255 +func (m NewOrderSingle) SetCreditRating(v string) { + m.Set(field.NewCreditRating(v)) +} + +//SetEncodedIssuerLen sets EncodedIssuerLen, Tag 348 +func (m NewOrderSingle) SetEncodedIssuerLen(v int) { + m.Set(field.NewEncodedIssuerLen(v)) +} + +//SetEncodedIssuer sets EncodedIssuer, Tag 349 +func (m NewOrderSingle) SetEncodedIssuer(v string) { + m.Set(field.NewEncodedIssuer(v)) +} + +//SetEncodedSecurityDescLen sets EncodedSecurityDescLen, Tag 350 +func (m NewOrderSingle) SetEncodedSecurityDescLen(v int) { + m.Set(field.NewEncodedSecurityDescLen(v)) +} + +//SetEncodedSecurityDesc sets EncodedSecurityDesc, Tag 351 +func (m NewOrderSingle) SetEncodedSecurityDesc(v string) { + m.Set(field.NewEncodedSecurityDesc(v)) +} + +//SetEncodedTextLen sets EncodedTextLen, Tag 354 +func (m NewOrderSingle) SetEncodedTextLen(v int) { + m.Set(field.NewEncodedTextLen(v)) +} + +//SetEncodedText sets EncodedText, Tag 355 +func (m NewOrderSingle) SetEncodedText(v string) { + m.Set(field.NewEncodedText(v)) +} + +//SetComplianceID sets ComplianceID, Tag 376 +func (m NewOrderSingle) SetComplianceID(v string) { + m.Set(field.NewComplianceID(v)) +} + +//SetSolicitedFlag sets SolicitedFlag, Tag 377 +func (m NewOrderSingle) SetSolicitedFlag(v bool) { + m.Set(field.NewSolicitedFlag(v)) +} + +//SetNoTradingSessions sets NoTradingSessions, Tag 386 +func (m NewOrderSingle) SetNoTradingSessions(f NoTradingSessionsRepeatingGroup) { + m.SetGroup(f) +} + +//SetDiscretionInst sets DiscretionInst, Tag 388 +func (m NewOrderSingle) SetDiscretionInst(v string) { + m.Set(field.NewDiscretionInst(v)) +} + +//SetDiscretionOffsetValue sets DiscretionOffsetValue, Tag 389 +func (m NewOrderSingle) SetDiscretionOffsetValue(v float64) { + m.Set(field.NewDiscretionOffsetValue(v)) +} + +//SetPriceType sets PriceType, Tag 423 +func (m NewOrderSingle) SetPriceType(v int) { + m.Set(field.NewPriceType(v)) +} + +//SetGTBookingInst sets GTBookingInst, Tag 427 +func (m NewOrderSingle) SetGTBookingInst(v int) { + m.Set(field.NewGTBookingInst(v)) +} + +//SetExpireDate sets ExpireDate, Tag 432 +func (m NewOrderSingle) SetExpireDate(v string) { + m.Set(field.NewExpireDate(v)) +} + +//SetNoPartyIDs sets NoPartyIDs, Tag 453 +func (m NewOrderSingle) SetNoPartyIDs(f NoPartyIDsRepeatingGroup) { + m.SetGroup(f) +} + +//SetNoSecurityAltID sets NoSecurityAltID, Tag 454 +func (m NewOrderSingle) SetNoSecurityAltID(f NoSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetProduct sets Product, Tag 460 +func (m NewOrderSingle) SetProduct(v int) { + m.Set(field.NewProduct(v)) +} + +//SetCFICode sets CFICode, Tag 461 +func (m NewOrderSingle) SetCFICode(v string) { + m.Set(field.NewCFICode(v)) +} + +//SetRoundingDirection sets RoundingDirection, Tag 468 +func (m NewOrderSingle) SetRoundingDirection(v string) { + m.Set(field.NewRoundingDirection(v)) +} + +//SetRoundingModulus sets RoundingModulus, Tag 469 +func (m NewOrderSingle) SetRoundingModulus(v float64) { + m.Set(field.NewRoundingModulus(v)) +} + +//SetCountryOfIssue sets CountryOfIssue, Tag 470 +func (m NewOrderSingle) SetCountryOfIssue(v string) { + m.Set(field.NewCountryOfIssue(v)) +} + +//SetStateOrProvinceOfIssue sets StateOrProvinceOfIssue, Tag 471 +func (m NewOrderSingle) SetStateOrProvinceOfIssue(v string) { + m.Set(field.NewStateOrProvinceOfIssue(v)) +} + +//SetLocaleOfIssue sets LocaleOfIssue, Tag 472 +func (m NewOrderSingle) SetLocaleOfIssue(v string) { + m.Set(field.NewLocaleOfIssue(v)) +} + +//SetCommCurrency sets CommCurrency, Tag 479 +func (m NewOrderSingle) SetCommCurrency(v string) { + m.Set(field.NewCommCurrency(v)) +} + +//SetCancellationRights sets CancellationRights, Tag 480 +func (m NewOrderSingle) SetCancellationRights(v string) { + m.Set(field.NewCancellationRights(v)) +} + +//SetMoneyLaunderingStatus sets MoneyLaunderingStatus, Tag 481 +func (m NewOrderSingle) SetMoneyLaunderingStatus(v string) { + m.Set(field.NewMoneyLaunderingStatus(v)) +} + +//SetDesignation sets Designation, Tag 494 +func (m NewOrderSingle) SetDesignation(v string) { + m.Set(field.NewDesignation(v)) +} + +//SetFundRenewWaiv sets FundRenewWaiv, Tag 497 +func (m NewOrderSingle) SetFundRenewWaiv(v string) { + m.Set(field.NewFundRenewWaiv(v)) +} + +//SetRegistID sets RegistID, Tag 513 +func (m NewOrderSingle) SetRegistID(v string) { + m.Set(field.NewRegistID(v)) +} + +//SetOrderPercent sets OrderPercent, Tag 516 +func (m NewOrderSingle) SetOrderPercent(v float64) { + m.Set(field.NewOrderPercent(v)) +} + +//SetSecondaryClOrdID sets SecondaryClOrdID, Tag 526 +func (m NewOrderSingle) SetSecondaryClOrdID(v string) { + m.Set(field.NewSecondaryClOrdID(v)) +} + +//SetOrderCapacity sets OrderCapacity, Tag 528 +func (m NewOrderSingle) SetOrderCapacity(v string) { + m.Set(field.NewOrderCapacity(v)) +} + +//SetOrderRestrictions sets OrderRestrictions, Tag 529 +func (m NewOrderSingle) SetOrderRestrictions(v string) { + m.Set(field.NewOrderRestrictions(v)) +} + +//SetMaturityDate sets MaturityDate, Tag 541 +func (m NewOrderSingle) SetMaturityDate(v string) { + m.Set(field.NewMaturityDate(v)) +} + +//SetInstrRegistry sets InstrRegistry, Tag 543 +func (m NewOrderSingle) SetInstrRegistry(v string) { + m.Set(field.NewInstrRegistry(v)) +} + +//SetCashMargin sets CashMargin, Tag 544 +func (m NewOrderSingle) SetCashMargin(v string) { + m.Set(field.NewCashMargin(v)) +} + +//SetAccountType sets AccountType, Tag 581 +func (m NewOrderSingle) SetAccountType(v int) { + m.Set(field.NewAccountType(v)) +} + +//SetCustOrderCapacity sets CustOrderCapacity, Tag 582 +func (m NewOrderSingle) SetCustOrderCapacity(v int) { + m.Set(field.NewCustOrderCapacity(v)) +} + +//SetClOrdLinkID sets ClOrdLinkID, Tag 583 +func (m NewOrderSingle) SetClOrdLinkID(v string) { + m.Set(field.NewClOrdLinkID(v)) +} + +//SetDayBookingInst sets DayBookingInst, Tag 589 +func (m NewOrderSingle) SetDayBookingInst(v string) { + m.Set(field.NewDayBookingInst(v)) +} + +//SetBookingUnit sets BookingUnit, Tag 590 +func (m NewOrderSingle) SetBookingUnit(v string) { + m.Set(field.NewBookingUnit(v)) +} + +//SetPreallocMethod sets PreallocMethod, Tag 591 +func (m NewOrderSingle) SetPreallocMethod(v string) { + m.Set(field.NewPreallocMethod(v)) +} + +//SetClearingFeeIndicator sets ClearingFeeIndicator, Tag 635 +func (m NewOrderSingle) SetClearingFeeIndicator(v string) { + m.Set(field.NewClearingFeeIndicator(v)) +} + +//SetPrice2 sets Price2, Tag 640 +func (m NewOrderSingle) SetPrice2(v float64) { + m.Set(field.NewPrice2(v)) +} + +//SetAcctIDSource sets AcctIDSource, Tag 660 +func (m NewOrderSingle) SetAcctIDSource(v int) { + m.Set(field.NewAcctIDSource(v)) +} + +//SetBenchmarkPrice sets BenchmarkPrice, Tag 662 +func (m NewOrderSingle) SetBenchmarkPrice(v float64) { + m.Set(field.NewBenchmarkPrice(v)) +} + +//SetBenchmarkPriceType sets BenchmarkPriceType, Tag 663 +func (m NewOrderSingle) SetBenchmarkPriceType(v int) { + m.Set(field.NewBenchmarkPriceType(v)) +} + +//SetContractSettlMonth sets ContractSettlMonth, Tag 667 +func (m NewOrderSingle) SetContractSettlMonth(v string) { + m.Set(field.NewContractSettlMonth(v)) +} + +//SetPool sets Pool, Tag 691 +func (m NewOrderSingle) SetPool(v string) { + m.Set(field.NewPool(v)) +} + +//SetYieldRedemptionDate sets YieldRedemptionDate, Tag 696 +func (m NewOrderSingle) SetYieldRedemptionDate(v string) { + m.Set(field.NewYieldRedemptionDate(v)) +} + +//SetYieldRedemptionPrice sets YieldRedemptionPrice, Tag 697 +func (m NewOrderSingle) SetYieldRedemptionPrice(v float64) { + m.Set(field.NewYieldRedemptionPrice(v)) +} + +//SetYieldRedemptionPriceType sets YieldRedemptionPriceType, Tag 698 +func (m NewOrderSingle) SetYieldRedemptionPriceType(v int) { + m.Set(field.NewYieldRedemptionPriceType(v)) +} + +//SetBenchmarkSecurityID sets BenchmarkSecurityID, Tag 699 +func (m NewOrderSingle) SetBenchmarkSecurityID(v string) { + m.Set(field.NewBenchmarkSecurityID(v)) +} + +//SetYieldCalcDate sets YieldCalcDate, Tag 701 +func (m NewOrderSingle) SetYieldCalcDate(v string) { + m.Set(field.NewYieldCalcDate(v)) +} + +//SetNoUnderlyings sets NoUnderlyings, Tag 711 +func (m NewOrderSingle) SetNoUnderlyings(f NoUnderlyingsRepeatingGroup) { + m.SetGroup(f) +} + +//SetBenchmarkSecurityIDSource sets BenchmarkSecurityIDSource, Tag 761 +func (m NewOrderSingle) SetBenchmarkSecurityIDSource(v string) { + m.Set(field.NewBenchmarkSecurityIDSource(v)) +} + +//SetSecuritySubType sets SecuritySubType, Tag 762 +func (m NewOrderSingle) SetSecuritySubType(v string) { + m.Set(field.NewSecuritySubType(v)) +} + +//SetNoTrdRegTimestamps sets NoTrdRegTimestamps, Tag 768 +func (m NewOrderSingle) SetNoTrdRegTimestamps(f NoTrdRegTimestampsRepeatingGroup) { + m.SetGroup(f) +} + +//SetBookingType sets BookingType, Tag 775 +func (m NewOrderSingle) SetBookingType(v int) { + m.Set(field.NewBookingType(v)) +} + +//SetTerminationType sets TerminationType, Tag 788 +func (m NewOrderSingle) SetTerminationType(v int) { + m.Set(field.NewTerminationType(v)) +} + +//SetPegMoveType sets PegMoveType, Tag 835 +func (m NewOrderSingle) SetPegMoveType(v int) { + m.Set(field.NewPegMoveType(v)) +} + +//SetPegOffsetType sets PegOffsetType, Tag 836 +func (m NewOrderSingle) SetPegOffsetType(v int) { + m.Set(field.NewPegOffsetType(v)) +} + +//SetPegLimitType sets PegLimitType, Tag 837 +func (m NewOrderSingle) SetPegLimitType(v int) { + m.Set(field.NewPegLimitType(v)) +} + +//SetPegRoundDirection sets PegRoundDirection, Tag 838 +func (m NewOrderSingle) SetPegRoundDirection(v int) { + m.Set(field.NewPegRoundDirection(v)) +} + +//SetPegScope sets PegScope, Tag 840 +func (m NewOrderSingle) SetPegScope(v int) { + m.Set(field.NewPegScope(v)) +} + +//SetDiscretionMoveType sets DiscretionMoveType, Tag 841 +func (m NewOrderSingle) SetDiscretionMoveType(v int) { + m.Set(field.NewDiscretionMoveType(v)) +} + +//SetDiscretionOffsetType sets DiscretionOffsetType, Tag 842 +func (m NewOrderSingle) SetDiscretionOffsetType(v int) { + m.Set(field.NewDiscretionOffsetType(v)) +} + +//SetDiscretionLimitType sets DiscretionLimitType, Tag 843 +func (m NewOrderSingle) SetDiscretionLimitType(v int) { + m.Set(field.NewDiscretionLimitType(v)) +} + +//SetDiscretionRoundDirection sets DiscretionRoundDirection, Tag 844 +func (m NewOrderSingle) SetDiscretionRoundDirection(v int) { + m.Set(field.NewDiscretionRoundDirection(v)) +} + +//SetDiscretionScope sets DiscretionScope, Tag 846 +func (m NewOrderSingle) SetDiscretionScope(v int) { + m.Set(field.NewDiscretionScope(v)) +} + +//SetTargetStrategy sets TargetStrategy, Tag 847 +func (m NewOrderSingle) SetTargetStrategy(v int) { + m.Set(field.NewTargetStrategy(v)) +} + +//SetTargetStrategyParameters sets TargetStrategyParameters, Tag 848 +func (m NewOrderSingle) SetTargetStrategyParameters(v string) { + m.Set(field.NewTargetStrategyParameters(v)) +} + +//SetParticipationRate sets ParticipationRate, Tag 849 +func (m NewOrderSingle) SetParticipationRate(v float64) { + m.Set(field.NewParticipationRate(v)) +} + +//SetQtyType sets QtyType, Tag 854 +func (m NewOrderSingle) SetQtyType(v int) { + m.Set(field.NewQtyType(v)) +} + +//SetNoEvents sets NoEvents, Tag 864 +func (m NewOrderSingle) SetNoEvents(f NoEventsRepeatingGroup) { + m.SetGroup(f) +} + +//SetDatedDate sets DatedDate, Tag 873 +func (m NewOrderSingle) SetDatedDate(v string) { + m.Set(field.NewDatedDate(v)) +} + +//SetInterestAccrualDate sets InterestAccrualDate, Tag 874 +func (m NewOrderSingle) SetInterestAccrualDate(v string) { + m.Set(field.NewInterestAccrualDate(v)) +} + +//SetCPProgram sets CPProgram, Tag 875 +func (m NewOrderSingle) SetCPProgram(v int) { + m.Set(field.NewCPProgram(v)) +} + +//SetCPRegType sets CPRegType, Tag 876 +func (m NewOrderSingle) SetCPRegType(v string) { + m.Set(field.NewCPRegType(v)) +} + +//SetMarginRatio sets MarginRatio, Tag 898 +func (m NewOrderSingle) SetMarginRatio(v float64) { + m.Set(field.NewMarginRatio(v)) +} + +//SetAgreementDesc sets AgreementDesc, Tag 913 +func (m NewOrderSingle) SetAgreementDesc(v string) { + m.Set(field.NewAgreementDesc(v)) +} + +//SetAgreementID sets AgreementID, Tag 914 +func (m NewOrderSingle) SetAgreementID(v string) { + m.Set(field.NewAgreementID(v)) +} + +//SetAgreementDate sets AgreementDate, Tag 915 +func (m NewOrderSingle) SetAgreementDate(v string) { + m.Set(field.NewAgreementDate(v)) +} + +//SetStartDate sets StartDate, Tag 916 +func (m NewOrderSingle) SetStartDate(v string) { + m.Set(field.NewStartDate(v)) +} + +//SetEndDate sets EndDate, Tag 917 +func (m NewOrderSingle) SetEndDate(v string) { + m.Set(field.NewEndDate(v)) +} + +//SetAgreementCurrency sets AgreementCurrency, Tag 918 +func (m NewOrderSingle) SetAgreementCurrency(v string) { + m.Set(field.NewAgreementCurrency(v)) +} + +//SetDeliveryType sets DeliveryType, Tag 919 +func (m NewOrderSingle) SetDeliveryType(v int) { + m.Set(field.NewDeliveryType(v)) +} + +//SetStrikeCurrency sets StrikeCurrency, Tag 947 +func (m NewOrderSingle) SetStrikeCurrency(v string) { + m.Set(field.NewStrikeCurrency(v)) +} + +//SetNoStrategyParameters sets NoStrategyParameters, Tag 957 +func (m NewOrderSingle) SetNoStrategyParameters(f NoStrategyParametersRepeatingGroup) { + m.SetGroup(f) +} + +//SetSecurityStatus sets SecurityStatus, Tag 965 +func (m NewOrderSingle) SetSecurityStatus(v string) { + m.Set(field.NewSecurityStatus(v)) +} + +//SetSettleOnOpenFlag sets SettleOnOpenFlag, Tag 966 +func (m NewOrderSingle) SetSettleOnOpenFlag(v string) { + m.Set(field.NewSettleOnOpenFlag(v)) +} + +//SetStrikeMultiplier sets StrikeMultiplier, Tag 967 +func (m NewOrderSingle) SetStrikeMultiplier(v float64) { + m.Set(field.NewStrikeMultiplier(v)) +} + +//SetStrikeValue sets StrikeValue, Tag 968 +func (m NewOrderSingle) SetStrikeValue(v float64) { + m.Set(field.NewStrikeValue(v)) +} + +//SetMinPriceIncrement sets MinPriceIncrement, Tag 969 +func (m NewOrderSingle) SetMinPriceIncrement(v float64) { + m.Set(field.NewMinPriceIncrement(v)) +} + +//SetPositionLimit sets PositionLimit, Tag 970 +func (m NewOrderSingle) SetPositionLimit(v int) { + m.Set(field.NewPositionLimit(v)) +} + +//SetNTPositionLimit sets NTPositionLimit, Tag 971 +func (m NewOrderSingle) SetNTPositionLimit(v int) { + m.Set(field.NewNTPositionLimit(v)) +} + +//SetUnitOfMeasure sets UnitOfMeasure, Tag 996 +func (m NewOrderSingle) SetUnitOfMeasure(v string) { + m.Set(field.NewUnitOfMeasure(v)) +} + +//SetTimeUnit sets TimeUnit, Tag 997 +func (m NewOrderSingle) SetTimeUnit(v string) { + m.Set(field.NewTimeUnit(v)) +} + +//SetNoInstrumentParties sets NoInstrumentParties, Tag 1018 +func (m NewOrderSingle) SetNoInstrumentParties(f NoInstrumentPartiesRepeatingGroup) { + m.SetGroup(f) +} + +//SetManualOrderIndicator sets ManualOrderIndicator, Tag 1028 +func (m NewOrderSingle) SetManualOrderIndicator(v bool) { + m.Set(field.NewManualOrderIndicator(v)) +} + +//SetCustDirectedOrder sets CustDirectedOrder, Tag 1029 +func (m NewOrderSingle) SetCustDirectedOrder(v bool) { + m.Set(field.NewCustDirectedOrder(v)) +} + +//SetReceivedDeptID sets ReceivedDeptID, Tag 1030 +func (m NewOrderSingle) SetReceivedDeptID(v string) { + m.Set(field.NewReceivedDeptID(v)) +} + +//SetCustOrderHandlingInst sets CustOrderHandlingInst, Tag 1031 +func (m NewOrderSingle) SetCustOrderHandlingInst(v string) { + m.Set(field.NewCustOrderHandlingInst(v)) +} + +//SetOrderHandlingInstSource sets OrderHandlingInstSource, Tag 1032 +func (m NewOrderSingle) SetOrderHandlingInstSource(v int) { + m.Set(field.NewOrderHandlingInstSource(v)) +} + +//SetInstrmtAssignmentMethod sets InstrmtAssignmentMethod, Tag 1049 +func (m NewOrderSingle) SetInstrmtAssignmentMethod(v string) { + m.Set(field.NewInstrmtAssignmentMethod(v)) +} + +//SetMaturityTime sets MaturityTime, Tag 1079 +func (m NewOrderSingle) SetMaturityTime(v string) { + m.Set(field.NewMaturityTime(v)) +} + +//SetRefOrderID sets RefOrderID, Tag 1080 +func (m NewOrderSingle) SetRefOrderID(v string) { + m.Set(field.NewRefOrderID(v)) +} + +//SetRefOrderIDSource sets RefOrderIDSource, Tag 1081 +func (m NewOrderSingle) SetRefOrderIDSource(v string) { + m.Set(field.NewRefOrderIDSource(v)) +} + +//SetSecondaryDisplayQty sets SecondaryDisplayQty, Tag 1082 +func (m NewOrderSingle) SetSecondaryDisplayQty(v float64) { + m.Set(field.NewSecondaryDisplayQty(v)) +} + +//SetDisplayWhen sets DisplayWhen, Tag 1083 +func (m NewOrderSingle) SetDisplayWhen(v string) { + m.Set(field.NewDisplayWhen(v)) +} + +//SetDisplayMethod sets DisplayMethod, Tag 1084 +func (m NewOrderSingle) SetDisplayMethod(v string) { + m.Set(field.NewDisplayMethod(v)) +} + +//SetDisplayLowQty sets DisplayLowQty, Tag 1085 +func (m NewOrderSingle) SetDisplayLowQty(v float64) { + m.Set(field.NewDisplayLowQty(v)) +} + +//SetDisplayHighQty sets DisplayHighQty, Tag 1086 +func (m NewOrderSingle) SetDisplayHighQty(v float64) { + m.Set(field.NewDisplayHighQty(v)) +} + +//SetDisplayMinIncr sets DisplayMinIncr, Tag 1087 +func (m NewOrderSingle) SetDisplayMinIncr(v float64) { + m.Set(field.NewDisplayMinIncr(v)) +} + +//SetRefreshQty sets RefreshQty, Tag 1088 +func (m NewOrderSingle) SetRefreshQty(v float64) { + m.Set(field.NewRefreshQty(v)) +} + +//SetMatchIncrement sets MatchIncrement, Tag 1089 +func (m NewOrderSingle) SetMatchIncrement(v float64) { + m.Set(field.NewMatchIncrement(v)) +} + +//SetMaxPriceLevels sets MaxPriceLevels, Tag 1090 +func (m NewOrderSingle) SetMaxPriceLevels(v int) { + m.Set(field.NewMaxPriceLevels(v)) +} + +//SetPreTradeAnonymity sets PreTradeAnonymity, Tag 1091 +func (m NewOrderSingle) SetPreTradeAnonymity(v bool) { + m.Set(field.NewPreTradeAnonymity(v)) +} + +//SetPriceProtectionScope sets PriceProtectionScope, Tag 1092 +func (m NewOrderSingle) SetPriceProtectionScope(v string) { + m.Set(field.NewPriceProtectionScope(v)) +} + +//SetPegPriceType sets PegPriceType, Tag 1094 +func (m NewOrderSingle) SetPegPriceType(v int) { + m.Set(field.NewPegPriceType(v)) +} + +//SetPegSecurityIDSource sets PegSecurityIDSource, Tag 1096 +func (m NewOrderSingle) SetPegSecurityIDSource(v string) { + m.Set(field.NewPegSecurityIDSource(v)) +} + +//SetPegSecurityID sets PegSecurityID, Tag 1097 +func (m NewOrderSingle) SetPegSecurityID(v string) { + m.Set(field.NewPegSecurityID(v)) +} + +//SetPegSymbol sets PegSymbol, Tag 1098 +func (m NewOrderSingle) SetPegSymbol(v string) { + m.Set(field.NewPegSymbol(v)) +} + +//SetPegSecurityDesc sets PegSecurityDesc, Tag 1099 +func (m NewOrderSingle) SetPegSecurityDesc(v string) { + m.Set(field.NewPegSecurityDesc(v)) +} + +//SetTriggerType sets TriggerType, Tag 1100 +func (m NewOrderSingle) SetTriggerType(v string) { + m.Set(field.NewTriggerType(v)) +} + +//SetTriggerAction sets TriggerAction, Tag 1101 +func (m NewOrderSingle) SetTriggerAction(v string) { + m.Set(field.NewTriggerAction(v)) +} + +//SetTriggerPrice sets TriggerPrice, Tag 1102 +func (m NewOrderSingle) SetTriggerPrice(v float64) { + m.Set(field.NewTriggerPrice(v)) +} + +//SetTriggerSymbol sets TriggerSymbol, Tag 1103 +func (m NewOrderSingle) SetTriggerSymbol(v string) { + m.Set(field.NewTriggerSymbol(v)) +} + +//SetTriggerSecurityID sets TriggerSecurityID, Tag 1104 +func (m NewOrderSingle) SetTriggerSecurityID(v string) { + m.Set(field.NewTriggerSecurityID(v)) +} + +//SetTriggerSecurityIDSource sets TriggerSecurityIDSource, Tag 1105 +func (m NewOrderSingle) SetTriggerSecurityIDSource(v string) { + m.Set(field.NewTriggerSecurityIDSource(v)) +} + +//SetTriggerSecurityDesc sets TriggerSecurityDesc, Tag 1106 +func (m NewOrderSingle) SetTriggerSecurityDesc(v string) { + m.Set(field.NewTriggerSecurityDesc(v)) +} + +//SetTriggerPriceType sets TriggerPriceType, Tag 1107 +func (m NewOrderSingle) SetTriggerPriceType(v string) { + m.Set(field.NewTriggerPriceType(v)) +} + +//SetTriggerPriceTypeScope sets TriggerPriceTypeScope, Tag 1108 +func (m NewOrderSingle) SetTriggerPriceTypeScope(v string) { + m.Set(field.NewTriggerPriceTypeScope(v)) +} + +//SetTriggerPriceDirection sets TriggerPriceDirection, Tag 1109 +func (m NewOrderSingle) SetTriggerPriceDirection(v string) { + m.Set(field.NewTriggerPriceDirection(v)) +} + +//SetTriggerNewPrice sets TriggerNewPrice, Tag 1110 +func (m NewOrderSingle) SetTriggerNewPrice(v float64) { + m.Set(field.NewTriggerNewPrice(v)) +} + +//SetTriggerOrderType sets TriggerOrderType, Tag 1111 +func (m NewOrderSingle) SetTriggerOrderType(v string) { + m.Set(field.NewTriggerOrderType(v)) +} + +//SetTriggerNewQty sets TriggerNewQty, Tag 1112 +func (m NewOrderSingle) SetTriggerNewQty(v float64) { + m.Set(field.NewTriggerNewQty(v)) +} + +//SetTriggerTradingSessionID sets TriggerTradingSessionID, Tag 1113 +func (m NewOrderSingle) SetTriggerTradingSessionID(v string) { + m.Set(field.NewTriggerTradingSessionID(v)) +} + +//SetTriggerTradingSessionSubID sets TriggerTradingSessionSubID, Tag 1114 +func (m NewOrderSingle) SetTriggerTradingSessionSubID(v string) { + m.Set(field.NewTriggerTradingSessionSubID(v)) +} + +//SetExDestinationIDSource sets ExDestinationIDSource, Tag 1133 +func (m NewOrderSingle) SetExDestinationIDSource(v string) { + m.Set(field.NewExDestinationIDSource(v)) +} + +//SetDisplayQty sets DisplayQty, Tag 1138 +func (m NewOrderSingle) SetDisplayQty(v float64) { + m.Set(field.NewDisplayQty(v)) +} + +//GetAccount gets Account, Tag 1 +func (m NewOrderSingle) GetAccount() (f field.AccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdID gets ClOrdID, Tag 11 +func (m NewOrderSingle) GetClOrdID() (f field.ClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommission gets Commission, Tag 12 +func (m NewOrderSingle) GetCommission() (f field.CommissionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommType gets CommType, Tag 13 +func (m NewOrderSingle) GetCommType() (f field.CommTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCurrency gets Currency, Tag 15 +func (m NewOrderSingle) GetCurrency() (f field.CurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExecInst gets ExecInst, Tag 18 +func (m NewOrderSingle) GetExecInst() (f field.ExecInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetHandlInst gets HandlInst, Tag 21 +func (m NewOrderSingle) GetHandlInst() (f field.HandlInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityIDSource gets SecurityIDSource, Tag 22 +func (m NewOrderSingle) GetSecurityIDSource() (f field.SecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIOIID gets IOIID, Tag 23 +func (m NewOrderSingle) GetIOIID() (f field.IOIIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty gets OrderQty, Tag 38 +func (m NewOrderSingle) GetOrderQty() (f field.OrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrdType gets OrdType, Tag 40 +func (m NewOrderSingle) GetOrdType() (f field.OrdTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrice gets Price, Tag 44 +func (m NewOrderSingle) GetPrice() (f field.PriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m NewOrderSingle) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSide gets Side, Tag 54 +func (m NewOrderSingle) GetSide() (f field.SideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbol gets Symbol, Tag 55 +func (m NewOrderSingle) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetText gets Text, Tag 58 +func (m NewOrderSingle) GetText() (f field.TextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTimeInForce gets TimeInForce, Tag 59 +func (m NewOrderSingle) GetTimeInForce() (f field.TimeInForceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTransactTime gets TransactTime, Tag 60 +func (m NewOrderSingle) GetTransactTime() (f field.TransactTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlType gets SettlType, Tag 63 +func (m NewOrderSingle) GetSettlType() (f field.SettlTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlDate gets SettlDate, Tag 64 +func (m NewOrderSingle) GetSettlDate() (f field.SettlDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m NewOrderSingle) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAllocID gets AllocID, Tag 70 +func (m NewOrderSingle) GetAllocID() (f field.AllocIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradeDate gets TradeDate, Tag 75 +func (m NewOrderSingle) GetTradeDate() (f field.TradeDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPositionEffect gets PositionEffect, Tag 77 +func (m NewOrderSingle) GetPositionEffect() (f field.PositionEffectField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoAllocs gets NoAllocs, Tag 78 +func (m NewOrderSingle) GetNoAllocs() (NoAllocsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoAllocsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetProcessCode gets ProcessCode, Tag 81 +func (m NewOrderSingle) GetProcessCode() (f field.ProcessCodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStopPx gets StopPx, Tag 99 +func (m NewOrderSingle) GetStopPx() (f field.StopPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExDestination gets ExDestination, Tag 100 +func (m NewOrderSingle) GetExDestination() (f field.ExDestinationField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m NewOrderSingle) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m NewOrderSingle) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMinQty gets MinQty, Tag 110 +func (m NewOrderSingle) GetMinQty() (f field.MinQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxFloor gets MaxFloor, Tag 111 +func (m NewOrderSingle) GetMaxFloor() (f field.MaxFloorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLocateReqd gets LocateReqd, Tag 114 +func (m NewOrderSingle) GetLocateReqd() (f field.LocateReqdField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetQuoteID gets QuoteID, Tag 117 +func (m NewOrderSingle) GetQuoteID() (f field.QuoteIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlCurrency gets SettlCurrency, Tag 120 +func (m NewOrderSingle) GetSettlCurrency() (f field.SettlCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetForexReq gets ForexReq, Tag 121 +func (m NewOrderSingle) GetForexReq() (f field.ForexReqField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireTime gets ExpireTime, Tag 126 +func (m NewOrderSingle) GetExpireTime() (f field.ExpireTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrevClosePx gets PrevClosePx, Tag 140 +func (m NewOrderSingle) GetPrevClosePx() (f field.PrevClosePxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashOrderQty gets CashOrderQty, Tag 152 +func (m NewOrderSingle) GetCashOrderQty() (f field.CashOrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityType gets SecurityType, Tag 167 +func (m NewOrderSingle) GetSecurityType() (f field.SecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEffectiveTime gets EffectiveTime, Tag 168 +func (m NewOrderSingle) GetEffectiveTime() (f field.EffectiveTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty2 gets OrderQty2, Tag 192 +func (m NewOrderSingle) GetOrderQty2() (f field.OrderQty2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettlDate2 gets SettlDate2, Tag 193 +func (m NewOrderSingle) GetSettlDate2() (f field.SettlDate2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityMonthYear gets MaturityMonthYear, Tag 200 +func (m NewOrderSingle) GetMaturityMonthYear() (f field.MaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikePrice gets StrikePrice, Tag 202 +func (m NewOrderSingle) GetStrikePrice() (f field.StrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCoveredOrUncovered gets CoveredOrUncovered, Tag 203 +func (m NewOrderSingle) GetCoveredOrUncovered() (f field.CoveredOrUncoveredField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOptAttribute gets OptAttribute, Tag 206 +func (m NewOrderSingle) GetOptAttribute() (f field.OptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityExchange gets SecurityExchange, Tag 207 +func (m NewOrderSingle) GetSecurityExchange() (f field.SecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxShow gets MaxShow, Tag 210 +func (m NewOrderSingle) GetMaxShow() (f field.MaxShowField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegOffsetValue gets PegOffsetValue, Tag 211 +func (m NewOrderSingle) GetPegOffsetValue() (f field.PegOffsetValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSpread gets Spread, Tag 218 +func (m NewOrderSingle) GetSpread() (f field.SpreadField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkCurveCurrency gets BenchmarkCurveCurrency, Tag 220 +func (m NewOrderSingle) GetBenchmarkCurveCurrency() (f field.BenchmarkCurveCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkCurveName gets BenchmarkCurveName, Tag 221 +func (m NewOrderSingle) GetBenchmarkCurveName() (f field.BenchmarkCurveNameField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkCurvePoint gets BenchmarkCurvePoint, Tag 222 +func (m NewOrderSingle) GetBenchmarkCurvePoint() (f field.BenchmarkCurvePointField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponRate gets CouponRate, Tag 223 +func (m NewOrderSingle) GetCouponRate() (f field.CouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponPaymentDate gets CouponPaymentDate, Tag 224 +func (m NewOrderSingle) GetCouponPaymentDate() (f field.CouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssueDate gets IssueDate, Tag 225 +func (m NewOrderSingle) GetIssueDate() (f field.IssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseTerm gets RepurchaseTerm, Tag 226 +func (m NewOrderSingle) GetRepurchaseTerm() (f field.RepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseRate gets RepurchaseRate, Tag 227 +func (m NewOrderSingle) GetRepurchaseRate() (f field.RepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFactor gets Factor, Tag 228 +func (m NewOrderSingle) GetFactor() (f field.FactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradeOriginationDate gets TradeOriginationDate, Tag 229 +func (m NewOrderSingle) GetTradeOriginationDate() (f field.TradeOriginationDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractMultiplier gets ContractMultiplier, Tag 231 +func (m NewOrderSingle) GetContractMultiplier() (f field.ContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoStipulations gets NoStipulations, Tag 232 +func (m NewOrderSingle) GetNoStipulations() (NoStipulationsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoStipulationsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetYieldType gets YieldType, Tag 235 +func (m NewOrderSingle) GetYieldType() (f field.YieldTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYield gets Yield, Tag 236 +func (m NewOrderSingle) GetYield() (f field.YieldField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepoCollateralSecurityType gets RepoCollateralSecurityType, Tag 239 +func (m NewOrderSingle) GetRepoCollateralSecurityType() (f field.RepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRedemptionDate gets RedemptionDate, Tag 240 +func (m NewOrderSingle) GetRedemptionDate() (f field.RedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCreditRating gets CreditRating, Tag 255 +func (m NewOrderSingle) GetCreditRating() (f field.CreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuerLen gets EncodedIssuerLen, Tag 348 +func (m NewOrderSingle) GetEncodedIssuerLen() (f field.EncodedIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuer gets EncodedIssuer, Tag 349 +func (m NewOrderSingle) GetEncodedIssuer() (f field.EncodedIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDescLen gets EncodedSecurityDescLen, Tag 350 +func (m NewOrderSingle) GetEncodedSecurityDescLen() (f field.EncodedSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDesc gets EncodedSecurityDesc, Tag 351 +func (m NewOrderSingle) GetEncodedSecurityDesc() (f field.EncodedSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedTextLen gets EncodedTextLen, Tag 354 +func (m NewOrderSingle) GetEncodedTextLen() (f field.EncodedTextLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedText gets EncodedText, Tag 355 +func (m NewOrderSingle) GetEncodedText() (f field.EncodedTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetComplianceID gets ComplianceID, Tag 376 +func (m NewOrderSingle) GetComplianceID() (f field.ComplianceIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSolicitedFlag gets SolicitedFlag, Tag 377 +func (m NewOrderSingle) GetSolicitedFlag() (f field.SolicitedFlagField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoTradingSessions gets NoTradingSessions, Tag 386 +func (m NewOrderSingle) GetNoTradingSessions() (NoTradingSessionsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoTradingSessionsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetDiscretionInst gets DiscretionInst, Tag 388 +func (m NewOrderSingle) GetDiscretionInst() (f field.DiscretionInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionOffsetValue gets DiscretionOffsetValue, Tag 389 +func (m NewOrderSingle) GetDiscretionOffsetValue() (f field.DiscretionOffsetValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPriceType gets PriceType, Tag 423 +func (m NewOrderSingle) GetPriceType() (f field.PriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetGTBookingInst gets GTBookingInst, Tag 427 +func (m NewOrderSingle) GetGTBookingInst() (f field.GTBookingInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExpireDate gets ExpireDate, Tag 432 +func (m NewOrderSingle) GetExpireDate() (f field.ExpireDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoPartyIDs gets NoPartyIDs, Tag 453 +func (m NewOrderSingle) GetNoPartyIDs() (NoPartyIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoPartyIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetNoSecurityAltID gets NoSecurityAltID, Tag 454 +func (m NewOrderSingle) GetNoSecurityAltID() (NoSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetProduct gets Product, Tag 460 +func (m NewOrderSingle) GetProduct() (f field.ProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCFICode gets CFICode, Tag 461 +func (m NewOrderSingle) GetCFICode() (f field.CFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRoundingDirection gets RoundingDirection, Tag 468 +func (m NewOrderSingle) GetRoundingDirection() (f field.RoundingDirectionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRoundingModulus gets RoundingModulus, Tag 469 +func (m NewOrderSingle) GetRoundingModulus() (f field.RoundingModulusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCountryOfIssue gets CountryOfIssue, Tag 470 +func (m NewOrderSingle) GetCountryOfIssue() (f field.CountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStateOrProvinceOfIssue gets StateOrProvinceOfIssue, Tag 471 +func (m NewOrderSingle) GetStateOrProvinceOfIssue() (f field.StateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLocaleOfIssue gets LocaleOfIssue, Tag 472 +func (m NewOrderSingle) GetLocaleOfIssue() (f field.LocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCommCurrency gets CommCurrency, Tag 479 +func (m NewOrderSingle) GetCommCurrency() (f field.CommCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCancellationRights gets CancellationRights, Tag 480 +func (m NewOrderSingle) GetCancellationRights() (f field.CancellationRightsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMoneyLaunderingStatus gets MoneyLaunderingStatus, Tag 481 +func (m NewOrderSingle) GetMoneyLaunderingStatus() (f field.MoneyLaunderingStatusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDesignation gets Designation, Tag 494 +func (m NewOrderSingle) GetDesignation() (f field.DesignationField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFundRenewWaiv gets FundRenewWaiv, Tag 497 +func (m NewOrderSingle) GetFundRenewWaiv() (f field.FundRenewWaivField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRegistID gets RegistID, Tag 513 +func (m NewOrderSingle) GetRegistID() (f field.RegistIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderPercent gets OrderPercent, Tag 516 +func (m NewOrderSingle) GetOrderPercent() (f field.OrderPercentField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecondaryClOrdID gets SecondaryClOrdID, Tag 526 +func (m NewOrderSingle) GetSecondaryClOrdID() (f field.SecondaryClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderCapacity gets OrderCapacity, Tag 528 +func (m NewOrderSingle) GetOrderCapacity() (f field.OrderCapacityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderRestrictions gets OrderRestrictions, Tag 529 +func (m NewOrderSingle) GetOrderRestrictions() (f field.OrderRestrictionsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityDate gets MaturityDate, Tag 541 +func (m NewOrderSingle) GetMaturityDate() (f field.MaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrRegistry gets InstrRegistry, Tag 543 +func (m NewOrderSingle) GetInstrRegistry() (f field.InstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashMargin gets CashMargin, Tag 544 +func (m NewOrderSingle) GetCashMargin() (f field.CashMarginField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAccountType gets AccountType, Tag 581 +func (m NewOrderSingle) GetAccountType() (f field.AccountTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCustOrderCapacity gets CustOrderCapacity, Tag 582 +func (m NewOrderSingle) GetCustOrderCapacity() (f field.CustOrderCapacityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdLinkID gets ClOrdLinkID, Tag 583 +func (m NewOrderSingle) GetClOrdLinkID() (f field.ClOrdLinkIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDayBookingInst gets DayBookingInst, Tag 589 +func (m NewOrderSingle) GetDayBookingInst() (f field.DayBookingInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBookingUnit gets BookingUnit, Tag 590 +func (m NewOrderSingle) GetBookingUnit() (f field.BookingUnitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPreallocMethod gets PreallocMethod, Tag 591 +func (m NewOrderSingle) GetPreallocMethod() (f field.PreallocMethodField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClearingFeeIndicator gets ClearingFeeIndicator, Tag 635 +func (m NewOrderSingle) GetClearingFeeIndicator() (f field.ClearingFeeIndicatorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPrice2 gets Price2, Tag 640 +func (m NewOrderSingle) GetPrice2() (f field.Price2Field, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAcctIDSource gets AcctIDSource, Tag 660 +func (m NewOrderSingle) GetAcctIDSource() (f field.AcctIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkPrice gets BenchmarkPrice, Tag 662 +func (m NewOrderSingle) GetBenchmarkPrice() (f field.BenchmarkPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkPriceType gets BenchmarkPriceType, Tag 663 +func (m NewOrderSingle) GetBenchmarkPriceType() (f field.BenchmarkPriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractSettlMonth gets ContractSettlMonth, Tag 667 +func (m NewOrderSingle) GetContractSettlMonth() (f field.ContractSettlMonthField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPool gets Pool, Tag 691 +func (m NewOrderSingle) GetPool() (f field.PoolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYieldRedemptionDate gets YieldRedemptionDate, Tag 696 +func (m NewOrderSingle) GetYieldRedemptionDate() (f field.YieldRedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYieldRedemptionPrice gets YieldRedemptionPrice, Tag 697 +func (m NewOrderSingle) GetYieldRedemptionPrice() (f field.YieldRedemptionPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYieldRedemptionPriceType gets YieldRedemptionPriceType, Tag 698 +func (m NewOrderSingle) GetYieldRedemptionPriceType() (f field.YieldRedemptionPriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetBenchmarkSecurityID gets BenchmarkSecurityID, Tag 699 +func (m NewOrderSingle) GetBenchmarkSecurityID() (f field.BenchmarkSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetYieldCalcDate gets YieldCalcDate, Tag 701 +func (m NewOrderSingle) GetYieldCalcDate() (f field.YieldCalcDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyings gets NoUnderlyings, Tag 711 +func (m NewOrderSingle) GetNoUnderlyings() (NoUnderlyingsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetBenchmarkSecurityIDSource gets BenchmarkSecurityIDSource, Tag 761 +func (m NewOrderSingle) GetBenchmarkSecurityIDSource() (f field.BenchmarkSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecuritySubType gets SecuritySubType, Tag 762 +func (m NewOrderSingle) GetSecuritySubType() (f field.SecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoTrdRegTimestamps gets NoTrdRegTimestamps, Tag 768 +func (m NewOrderSingle) GetNoTrdRegTimestamps() (NoTrdRegTimestampsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoTrdRegTimestampsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetBookingType gets BookingType, Tag 775 +func (m NewOrderSingle) GetBookingType() (f field.BookingTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTerminationType gets TerminationType, Tag 788 +func (m NewOrderSingle) GetTerminationType() (f field.TerminationTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegMoveType gets PegMoveType, Tag 835 +func (m NewOrderSingle) GetPegMoveType() (f field.PegMoveTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegOffsetType gets PegOffsetType, Tag 836 +func (m NewOrderSingle) GetPegOffsetType() (f field.PegOffsetTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegLimitType gets PegLimitType, Tag 837 +func (m NewOrderSingle) GetPegLimitType() (f field.PegLimitTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegRoundDirection gets PegRoundDirection, Tag 838 +func (m NewOrderSingle) GetPegRoundDirection() (f field.PegRoundDirectionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegScope gets PegScope, Tag 840 +func (m NewOrderSingle) GetPegScope() (f field.PegScopeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionMoveType gets DiscretionMoveType, Tag 841 +func (m NewOrderSingle) GetDiscretionMoveType() (f field.DiscretionMoveTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionOffsetType gets DiscretionOffsetType, Tag 842 +func (m NewOrderSingle) GetDiscretionOffsetType() (f field.DiscretionOffsetTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionLimitType gets DiscretionLimitType, Tag 843 +func (m NewOrderSingle) GetDiscretionLimitType() (f field.DiscretionLimitTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionRoundDirection gets DiscretionRoundDirection, Tag 844 +func (m NewOrderSingle) GetDiscretionRoundDirection() (f field.DiscretionRoundDirectionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDiscretionScope gets DiscretionScope, Tag 846 +func (m NewOrderSingle) GetDiscretionScope() (f field.DiscretionScopeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTargetStrategy gets TargetStrategy, Tag 847 +func (m NewOrderSingle) GetTargetStrategy() (f field.TargetStrategyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTargetStrategyParameters gets TargetStrategyParameters, Tag 848 +func (m NewOrderSingle) GetTargetStrategyParameters() (f field.TargetStrategyParametersField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetParticipationRate gets ParticipationRate, Tag 849 +func (m NewOrderSingle) GetParticipationRate() (f field.ParticipationRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetQtyType gets QtyType, Tag 854 +func (m NewOrderSingle) GetQtyType() (f field.QtyTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoEvents gets NoEvents, Tag 864 +func (m NewOrderSingle) GetNoEvents() (NoEventsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoEventsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetDatedDate gets DatedDate, Tag 873 +func (m NewOrderSingle) GetDatedDate() (f field.DatedDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInterestAccrualDate gets InterestAccrualDate, Tag 874 +func (m NewOrderSingle) GetInterestAccrualDate() (f field.InterestAccrualDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCPProgram gets CPProgram, Tag 875 +func (m NewOrderSingle) GetCPProgram() (f field.CPProgramField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCPRegType gets CPRegType, Tag 876 +func (m NewOrderSingle) GetCPRegType() (f field.CPRegTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMarginRatio gets MarginRatio, Tag 898 +func (m NewOrderSingle) GetMarginRatio() (f field.MarginRatioField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementDesc gets AgreementDesc, Tag 913 +func (m NewOrderSingle) GetAgreementDesc() (f field.AgreementDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementID gets AgreementID, Tag 914 +func (m NewOrderSingle) GetAgreementID() (f field.AgreementIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementDate gets AgreementDate, Tag 915 +func (m NewOrderSingle) GetAgreementDate() (f field.AgreementDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStartDate gets StartDate, Tag 916 +func (m NewOrderSingle) GetStartDate() (f field.StartDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEndDate gets EndDate, Tag 917 +func (m NewOrderSingle) GetEndDate() (f field.EndDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementCurrency gets AgreementCurrency, Tag 918 +func (m NewOrderSingle) GetAgreementCurrency() (f field.AgreementCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDeliveryType gets DeliveryType, Tag 919 +func (m NewOrderSingle) GetDeliveryType() (f field.DeliveryTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikeCurrency gets StrikeCurrency, Tag 947 +func (m NewOrderSingle) GetStrikeCurrency() (f field.StrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoStrategyParameters gets NoStrategyParameters, Tag 957 +func (m NewOrderSingle) GetNoStrategyParameters() (NoStrategyParametersRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoStrategyParametersRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetSecurityStatus gets SecurityStatus, Tag 965 +func (m NewOrderSingle) GetSecurityStatus() (f field.SecurityStatusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettleOnOpenFlag gets SettleOnOpenFlag, Tag 966 +func (m NewOrderSingle) GetSettleOnOpenFlag() (f field.SettleOnOpenFlagField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikeMultiplier gets StrikeMultiplier, Tag 967 +func (m NewOrderSingle) GetStrikeMultiplier() (f field.StrikeMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikeValue gets StrikeValue, Tag 968 +func (m NewOrderSingle) GetStrikeValue() (f field.StrikeValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMinPriceIncrement gets MinPriceIncrement, Tag 969 +func (m NewOrderSingle) GetMinPriceIncrement() (f field.MinPriceIncrementField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPositionLimit gets PositionLimit, Tag 970 +func (m NewOrderSingle) GetPositionLimit() (f field.PositionLimitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNTPositionLimit gets NTPositionLimit, Tag 971 +func (m NewOrderSingle) GetNTPositionLimit() (f field.NTPositionLimitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnitOfMeasure gets UnitOfMeasure, Tag 996 +func (m NewOrderSingle) GetUnitOfMeasure() (f field.UnitOfMeasureField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTimeUnit gets TimeUnit, Tag 997 +func (m NewOrderSingle) GetTimeUnit() (f field.TimeUnitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoInstrumentParties gets NoInstrumentParties, Tag 1018 +func (m NewOrderSingle) GetNoInstrumentParties() (NoInstrumentPartiesRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoInstrumentPartiesRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetManualOrderIndicator gets ManualOrderIndicator, Tag 1028 +func (m NewOrderSingle) GetManualOrderIndicator() (f field.ManualOrderIndicatorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCustDirectedOrder gets CustDirectedOrder, Tag 1029 +func (m NewOrderSingle) GetCustDirectedOrder() (f field.CustDirectedOrderField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetReceivedDeptID gets ReceivedDeptID, Tag 1030 +func (m NewOrderSingle) GetReceivedDeptID() (f field.ReceivedDeptIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCustOrderHandlingInst gets CustOrderHandlingInst, Tag 1031 +func (m NewOrderSingle) GetCustOrderHandlingInst() (f field.CustOrderHandlingInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderHandlingInstSource gets OrderHandlingInstSource, Tag 1032 +func (m NewOrderSingle) GetOrderHandlingInstSource() (f field.OrderHandlingInstSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrmtAssignmentMethod gets InstrmtAssignmentMethod, Tag 1049 +func (m NewOrderSingle) GetInstrmtAssignmentMethod() (f field.InstrmtAssignmentMethodField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityTime gets MaturityTime, Tag 1079 +func (m NewOrderSingle) GetMaturityTime() (f field.MaturityTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRefOrderID gets RefOrderID, Tag 1080 +func (m NewOrderSingle) GetRefOrderID() (f field.RefOrderIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRefOrderIDSource gets RefOrderIDSource, Tag 1081 +func (m NewOrderSingle) GetRefOrderIDSource() (f field.RefOrderIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecondaryDisplayQty gets SecondaryDisplayQty, Tag 1082 +func (m NewOrderSingle) GetSecondaryDisplayQty() (f field.SecondaryDisplayQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDisplayWhen gets DisplayWhen, Tag 1083 +func (m NewOrderSingle) GetDisplayWhen() (f field.DisplayWhenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDisplayMethod gets DisplayMethod, Tag 1084 +func (m NewOrderSingle) GetDisplayMethod() (f field.DisplayMethodField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDisplayLowQty gets DisplayLowQty, Tag 1085 +func (m NewOrderSingle) GetDisplayLowQty() (f field.DisplayLowQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDisplayHighQty gets DisplayHighQty, Tag 1086 +func (m NewOrderSingle) GetDisplayHighQty() (f field.DisplayHighQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDisplayMinIncr gets DisplayMinIncr, Tag 1087 +func (m NewOrderSingle) GetDisplayMinIncr() (f field.DisplayMinIncrField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRefreshQty gets RefreshQty, Tag 1088 +func (m NewOrderSingle) GetRefreshQty() (f field.RefreshQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMatchIncrement gets MatchIncrement, Tag 1089 +func (m NewOrderSingle) GetMatchIncrement() (f field.MatchIncrementField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaxPriceLevels gets MaxPriceLevels, Tag 1090 +func (m NewOrderSingle) GetMaxPriceLevels() (f field.MaxPriceLevelsField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPreTradeAnonymity gets PreTradeAnonymity, Tag 1091 +func (m NewOrderSingle) GetPreTradeAnonymity() (f field.PreTradeAnonymityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPriceProtectionScope gets PriceProtectionScope, Tag 1092 +func (m NewOrderSingle) GetPriceProtectionScope() (f field.PriceProtectionScopeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegPriceType gets PegPriceType, Tag 1094 +func (m NewOrderSingle) GetPegPriceType() (f field.PegPriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegSecurityIDSource gets PegSecurityIDSource, Tag 1096 +func (m NewOrderSingle) GetPegSecurityIDSource() (f field.PegSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegSecurityID gets PegSecurityID, Tag 1097 +func (m NewOrderSingle) GetPegSecurityID() (f field.PegSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegSymbol gets PegSymbol, Tag 1098 +func (m NewOrderSingle) GetPegSymbol() (f field.PegSymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPegSecurityDesc gets PegSecurityDesc, Tag 1099 +func (m NewOrderSingle) GetPegSecurityDesc() (f field.PegSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerType gets TriggerType, Tag 1100 +func (m NewOrderSingle) GetTriggerType() (f field.TriggerTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerAction gets TriggerAction, Tag 1101 +func (m NewOrderSingle) GetTriggerAction() (f field.TriggerActionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerPrice gets TriggerPrice, Tag 1102 +func (m NewOrderSingle) GetTriggerPrice() (f field.TriggerPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerSymbol gets TriggerSymbol, Tag 1103 +func (m NewOrderSingle) GetTriggerSymbol() (f field.TriggerSymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerSecurityID gets TriggerSecurityID, Tag 1104 +func (m NewOrderSingle) GetTriggerSecurityID() (f field.TriggerSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerSecurityIDSource gets TriggerSecurityIDSource, Tag 1105 +func (m NewOrderSingle) GetTriggerSecurityIDSource() (f field.TriggerSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerSecurityDesc gets TriggerSecurityDesc, Tag 1106 +func (m NewOrderSingle) GetTriggerSecurityDesc() (f field.TriggerSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerPriceType gets TriggerPriceType, Tag 1107 +func (m NewOrderSingle) GetTriggerPriceType() (f field.TriggerPriceTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerPriceTypeScope gets TriggerPriceTypeScope, Tag 1108 +func (m NewOrderSingle) GetTriggerPriceTypeScope() (f field.TriggerPriceTypeScopeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerPriceDirection gets TriggerPriceDirection, Tag 1109 +func (m NewOrderSingle) GetTriggerPriceDirection() (f field.TriggerPriceDirectionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerNewPrice gets TriggerNewPrice, Tag 1110 +func (m NewOrderSingle) GetTriggerNewPrice() (f field.TriggerNewPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerOrderType gets TriggerOrderType, Tag 1111 +func (m NewOrderSingle) GetTriggerOrderType() (f field.TriggerOrderTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerNewQty gets TriggerNewQty, Tag 1112 +func (m NewOrderSingle) GetTriggerNewQty() (f field.TriggerNewQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerTradingSessionID gets TriggerTradingSessionID, Tag 1113 +func (m NewOrderSingle) GetTriggerTradingSessionID() (f field.TriggerTradingSessionIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTriggerTradingSessionSubID gets TriggerTradingSessionSubID, Tag 1114 +func (m NewOrderSingle) GetTriggerTradingSessionSubID() (f field.TriggerTradingSessionSubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetExDestinationIDSource gets ExDestinationIDSource, Tag 1133 +func (m NewOrderSingle) GetExDestinationIDSource() (f field.ExDestinationIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDisplayQty gets DisplayQty, Tag 1138 +func (m NewOrderSingle) GetDisplayQty() (f field.DisplayQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasAccount returns true if Account is present, Tag 1 +func (m NewOrderSingle) HasAccount() bool { + return m.Has(tag.Account) +} + +//HasClOrdID returns true if ClOrdID is present, Tag 11 +func (m NewOrderSingle) HasClOrdID() bool { + return m.Has(tag.ClOrdID) +} + +//HasCommission returns true if Commission is present, Tag 12 +func (m NewOrderSingle) HasCommission() bool { + return m.Has(tag.Commission) +} + +//HasCommType returns true if CommType is present, Tag 13 +func (m NewOrderSingle) HasCommType() bool { + return m.Has(tag.CommType) +} + +//HasCurrency returns true if Currency is present, Tag 15 +func (m NewOrderSingle) HasCurrency() bool { + return m.Has(tag.Currency) +} + +//HasExecInst returns true if ExecInst is present, Tag 18 +func (m NewOrderSingle) HasExecInst() bool { + return m.Has(tag.ExecInst) +} + +//HasHandlInst returns true if HandlInst is present, Tag 21 +func (m NewOrderSingle) HasHandlInst() bool { + return m.Has(tag.HandlInst) +} + +//HasSecurityIDSource returns true if SecurityIDSource is present, Tag 22 +func (m NewOrderSingle) HasSecurityIDSource() bool { + return m.Has(tag.SecurityIDSource) +} + +//HasIOIID returns true if IOIID is present, Tag 23 +func (m NewOrderSingle) HasIOIID() bool { + return m.Has(tag.IOIID) +} + +//HasOrderQty returns true if OrderQty is present, Tag 38 +func (m NewOrderSingle) HasOrderQty() bool { + return m.Has(tag.OrderQty) +} + +//HasOrdType returns true if OrdType is present, Tag 40 +func (m NewOrderSingle) HasOrdType() bool { + return m.Has(tag.OrdType) +} + +//HasPrice returns true if Price is present, Tag 44 +func (m NewOrderSingle) HasPrice() bool { + return m.Has(tag.Price) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m NewOrderSingle) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSide returns true if Side is present, Tag 54 +func (m NewOrderSingle) HasSide() bool { + return m.Has(tag.Side) +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m NewOrderSingle) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasText returns true if Text is present, Tag 58 +func (m NewOrderSingle) HasText() bool { + return m.Has(tag.Text) +} + +//HasTimeInForce returns true if TimeInForce is present, Tag 59 +func (m NewOrderSingle) HasTimeInForce() bool { + return m.Has(tag.TimeInForce) +} + +//HasTransactTime returns true if TransactTime is present, Tag 60 +func (m NewOrderSingle) HasTransactTime() bool { + return m.Has(tag.TransactTime) +} + +//HasSettlType returns true if SettlType is present, Tag 63 +func (m NewOrderSingle) HasSettlType() bool { + return m.Has(tag.SettlType) +} + +//HasSettlDate returns true if SettlDate is present, Tag 64 +func (m NewOrderSingle) HasSettlDate() bool { + return m.Has(tag.SettlDate) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m NewOrderSingle) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasAllocID returns true if AllocID is present, Tag 70 +func (m NewOrderSingle) HasAllocID() bool { + return m.Has(tag.AllocID) +} + +//HasTradeDate returns true if TradeDate is present, Tag 75 +func (m NewOrderSingle) HasTradeDate() bool { + return m.Has(tag.TradeDate) +} + +//HasPositionEffect returns true if PositionEffect is present, Tag 77 +func (m NewOrderSingle) HasPositionEffect() bool { + return m.Has(tag.PositionEffect) +} + +//HasNoAllocs returns true if NoAllocs is present, Tag 78 +func (m NewOrderSingle) HasNoAllocs() bool { + return m.Has(tag.NoAllocs) +} + +//HasProcessCode returns true if ProcessCode is present, Tag 81 +func (m NewOrderSingle) HasProcessCode() bool { + return m.Has(tag.ProcessCode) +} + +//HasStopPx returns true if StopPx is present, Tag 99 +func (m NewOrderSingle) HasStopPx() bool { + return m.Has(tag.StopPx) +} + +//HasExDestination returns true if ExDestination is present, Tag 100 +func (m NewOrderSingle) HasExDestination() bool { + return m.Has(tag.ExDestination) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m NewOrderSingle) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m NewOrderSingle) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasMinQty returns true if MinQty is present, Tag 110 +func (m NewOrderSingle) HasMinQty() bool { + return m.Has(tag.MinQty) +} + +//HasMaxFloor returns true if MaxFloor is present, Tag 111 +func (m NewOrderSingle) HasMaxFloor() bool { + return m.Has(tag.MaxFloor) +} + +//HasLocateReqd returns true if LocateReqd is present, Tag 114 +func (m NewOrderSingle) HasLocateReqd() bool { + return m.Has(tag.LocateReqd) +} + +//HasQuoteID returns true if QuoteID is present, Tag 117 +func (m NewOrderSingle) HasQuoteID() bool { + return m.Has(tag.QuoteID) +} + +//HasSettlCurrency returns true if SettlCurrency is present, Tag 120 +func (m NewOrderSingle) HasSettlCurrency() bool { + return m.Has(tag.SettlCurrency) +} + +//HasForexReq returns true if ForexReq is present, Tag 121 +func (m NewOrderSingle) HasForexReq() bool { + return m.Has(tag.ForexReq) +} + +//HasExpireTime returns true if ExpireTime is present, Tag 126 +func (m NewOrderSingle) HasExpireTime() bool { + return m.Has(tag.ExpireTime) +} + +//HasPrevClosePx returns true if PrevClosePx is present, Tag 140 +func (m NewOrderSingle) HasPrevClosePx() bool { + return m.Has(tag.PrevClosePx) +} + +//HasCashOrderQty returns true if CashOrderQty is present, Tag 152 +func (m NewOrderSingle) HasCashOrderQty() bool { + return m.Has(tag.CashOrderQty) +} + +//HasSecurityType returns true if SecurityType is present, Tag 167 +func (m NewOrderSingle) HasSecurityType() bool { + return m.Has(tag.SecurityType) +} + +//HasEffectiveTime returns true if EffectiveTime is present, Tag 168 +func (m NewOrderSingle) HasEffectiveTime() bool { + return m.Has(tag.EffectiveTime) +} + +//HasOrderQty2 returns true if OrderQty2 is present, Tag 192 +func (m NewOrderSingle) HasOrderQty2() bool { + return m.Has(tag.OrderQty2) +} + +//HasSettlDate2 returns true if SettlDate2 is present, Tag 193 +func (m NewOrderSingle) HasSettlDate2() bool { + return m.Has(tag.SettlDate2) +} + +//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200 +func (m NewOrderSingle) HasMaturityMonthYear() bool { + return m.Has(tag.MaturityMonthYear) +} + +//HasStrikePrice returns true if StrikePrice is present, Tag 202 +func (m NewOrderSingle) HasStrikePrice() bool { + return m.Has(tag.StrikePrice) +} + +//HasCoveredOrUncovered returns true if CoveredOrUncovered is present, Tag 203 +func (m NewOrderSingle) HasCoveredOrUncovered() bool { + return m.Has(tag.CoveredOrUncovered) +} + +//HasOptAttribute returns true if OptAttribute is present, Tag 206 +func (m NewOrderSingle) HasOptAttribute() bool { + return m.Has(tag.OptAttribute) +} + +//HasSecurityExchange returns true if SecurityExchange is present, Tag 207 +func (m NewOrderSingle) HasSecurityExchange() bool { + return m.Has(tag.SecurityExchange) +} + +//HasMaxShow returns true if MaxShow is present, Tag 210 +func (m NewOrderSingle) HasMaxShow() bool { + return m.Has(tag.MaxShow) +} + +//HasPegOffsetValue returns true if PegOffsetValue is present, Tag 211 +func (m NewOrderSingle) HasPegOffsetValue() bool { + return m.Has(tag.PegOffsetValue) +} + +//HasSpread returns true if Spread is present, Tag 218 +func (m NewOrderSingle) HasSpread() bool { + return m.Has(tag.Spread) +} + +//HasBenchmarkCurveCurrency returns true if BenchmarkCurveCurrency is present, Tag 220 +func (m NewOrderSingle) HasBenchmarkCurveCurrency() bool { + return m.Has(tag.BenchmarkCurveCurrency) +} + +//HasBenchmarkCurveName returns true if BenchmarkCurveName is present, Tag 221 +func (m NewOrderSingle) HasBenchmarkCurveName() bool { + return m.Has(tag.BenchmarkCurveName) +} + +//HasBenchmarkCurvePoint returns true if BenchmarkCurvePoint is present, Tag 222 +func (m NewOrderSingle) HasBenchmarkCurvePoint() bool { + return m.Has(tag.BenchmarkCurvePoint) +} + +//HasCouponRate returns true if CouponRate is present, Tag 223 +func (m NewOrderSingle) HasCouponRate() bool { + return m.Has(tag.CouponRate) +} + +//HasCouponPaymentDate returns true if CouponPaymentDate is present, Tag 224 +func (m NewOrderSingle) HasCouponPaymentDate() bool { + return m.Has(tag.CouponPaymentDate) +} + +//HasIssueDate returns true if IssueDate is present, Tag 225 +func (m NewOrderSingle) HasIssueDate() bool { + return m.Has(tag.IssueDate) +} + +//HasRepurchaseTerm returns true if RepurchaseTerm is present, Tag 226 +func (m NewOrderSingle) HasRepurchaseTerm() bool { + return m.Has(tag.RepurchaseTerm) +} + +//HasRepurchaseRate returns true if RepurchaseRate is present, Tag 227 +func (m NewOrderSingle) HasRepurchaseRate() bool { + return m.Has(tag.RepurchaseRate) +} + +//HasFactor returns true if Factor is present, Tag 228 +func (m NewOrderSingle) HasFactor() bool { + return m.Has(tag.Factor) +} + +//HasTradeOriginationDate returns true if TradeOriginationDate is present, Tag 229 +func (m NewOrderSingle) HasTradeOriginationDate() bool { + return m.Has(tag.TradeOriginationDate) +} + +//HasContractMultiplier returns true if ContractMultiplier is present, Tag 231 +func (m NewOrderSingle) HasContractMultiplier() bool { + return m.Has(tag.ContractMultiplier) +} + +//HasNoStipulations returns true if NoStipulations is present, Tag 232 +func (m NewOrderSingle) HasNoStipulations() bool { + return m.Has(tag.NoStipulations) +} + +//HasYieldType returns true if YieldType is present, Tag 235 +func (m NewOrderSingle) HasYieldType() bool { + return m.Has(tag.YieldType) +} + +//HasYield returns true if Yield is present, Tag 236 +func (m NewOrderSingle) HasYield() bool { + return m.Has(tag.Yield) +} + +//HasRepoCollateralSecurityType returns true if RepoCollateralSecurityType is present, Tag 239 +func (m NewOrderSingle) HasRepoCollateralSecurityType() bool { + return m.Has(tag.RepoCollateralSecurityType) +} + +//HasRedemptionDate returns true if RedemptionDate is present, Tag 240 +func (m NewOrderSingle) HasRedemptionDate() bool { + return m.Has(tag.RedemptionDate) +} + +//HasCreditRating returns true if CreditRating is present, Tag 255 +func (m NewOrderSingle) HasCreditRating() bool { + return m.Has(tag.CreditRating) +} + +//HasEncodedIssuerLen returns true if EncodedIssuerLen is present, Tag 348 +func (m NewOrderSingle) HasEncodedIssuerLen() bool { + return m.Has(tag.EncodedIssuerLen) +} + +//HasEncodedIssuer returns true if EncodedIssuer is present, Tag 349 +func (m NewOrderSingle) HasEncodedIssuer() bool { + return m.Has(tag.EncodedIssuer) +} + +//HasEncodedSecurityDescLen returns true if EncodedSecurityDescLen is present, Tag 350 +func (m NewOrderSingle) HasEncodedSecurityDescLen() bool { + return m.Has(tag.EncodedSecurityDescLen) +} + +//HasEncodedSecurityDesc returns true if EncodedSecurityDesc is present, Tag 351 +func (m NewOrderSingle) HasEncodedSecurityDesc() bool { + return m.Has(tag.EncodedSecurityDesc) +} + +//HasEncodedTextLen returns true if EncodedTextLen is present, Tag 354 +func (m NewOrderSingle) HasEncodedTextLen() bool { + return m.Has(tag.EncodedTextLen) +} + +//HasEncodedText returns true if EncodedText is present, Tag 355 +func (m NewOrderSingle) HasEncodedText() bool { + return m.Has(tag.EncodedText) +} + +//HasComplianceID returns true if ComplianceID is present, Tag 376 +func (m NewOrderSingle) HasComplianceID() bool { + return m.Has(tag.ComplianceID) +} + +//HasSolicitedFlag returns true if SolicitedFlag is present, Tag 377 +func (m NewOrderSingle) HasSolicitedFlag() bool { + return m.Has(tag.SolicitedFlag) +} + +//HasNoTradingSessions returns true if NoTradingSessions is present, Tag 386 +func (m NewOrderSingle) HasNoTradingSessions() bool { + return m.Has(tag.NoTradingSessions) +} + +//HasDiscretionInst returns true if DiscretionInst is present, Tag 388 +func (m NewOrderSingle) HasDiscretionInst() bool { + return m.Has(tag.DiscretionInst) +} + +//HasDiscretionOffsetValue returns true if DiscretionOffsetValue is present, Tag 389 +func (m NewOrderSingle) HasDiscretionOffsetValue() bool { + return m.Has(tag.DiscretionOffsetValue) +} + +//HasPriceType returns true if PriceType is present, Tag 423 +func (m NewOrderSingle) HasPriceType() bool { + return m.Has(tag.PriceType) +} + +//HasGTBookingInst returns true if GTBookingInst is present, Tag 427 +func (m NewOrderSingle) HasGTBookingInst() bool { + return m.Has(tag.GTBookingInst) +} + +//HasExpireDate returns true if ExpireDate is present, Tag 432 +func (m NewOrderSingle) HasExpireDate() bool { + return m.Has(tag.ExpireDate) +} + +//HasNoPartyIDs returns true if NoPartyIDs is present, Tag 453 +func (m NewOrderSingle) HasNoPartyIDs() bool { + return m.Has(tag.NoPartyIDs) +} + +//HasNoSecurityAltID returns true if NoSecurityAltID is present, Tag 454 +func (m NewOrderSingle) HasNoSecurityAltID() bool { + return m.Has(tag.NoSecurityAltID) +} + +//HasProduct returns true if Product is present, Tag 460 +func (m NewOrderSingle) HasProduct() bool { + return m.Has(tag.Product) +} + +//HasCFICode returns true if CFICode is present, Tag 461 +func (m NewOrderSingle) HasCFICode() bool { + return m.Has(tag.CFICode) +} + +//HasRoundingDirection returns true if RoundingDirection is present, Tag 468 +func (m NewOrderSingle) HasRoundingDirection() bool { + return m.Has(tag.RoundingDirection) +} + +//HasRoundingModulus returns true if RoundingModulus is present, Tag 469 +func (m NewOrderSingle) HasRoundingModulus() bool { + return m.Has(tag.RoundingModulus) +} + +//HasCountryOfIssue returns true if CountryOfIssue is present, Tag 470 +func (m NewOrderSingle) HasCountryOfIssue() bool { + return m.Has(tag.CountryOfIssue) +} + +//HasStateOrProvinceOfIssue returns true if StateOrProvinceOfIssue is present, Tag 471 +func (m NewOrderSingle) HasStateOrProvinceOfIssue() bool { + return m.Has(tag.StateOrProvinceOfIssue) +} + +//HasLocaleOfIssue returns true if LocaleOfIssue is present, Tag 472 +func (m NewOrderSingle) HasLocaleOfIssue() bool { + return m.Has(tag.LocaleOfIssue) +} + +//HasCommCurrency returns true if CommCurrency is present, Tag 479 +func (m NewOrderSingle) HasCommCurrency() bool { + return m.Has(tag.CommCurrency) +} + +//HasCancellationRights returns true if CancellationRights is present, Tag 480 +func (m NewOrderSingle) HasCancellationRights() bool { + return m.Has(tag.CancellationRights) +} + +//HasMoneyLaunderingStatus returns true if MoneyLaunderingStatus is present, Tag 481 +func (m NewOrderSingle) HasMoneyLaunderingStatus() bool { + return m.Has(tag.MoneyLaunderingStatus) +} + +//HasDesignation returns true if Designation is present, Tag 494 +func (m NewOrderSingle) HasDesignation() bool { + return m.Has(tag.Designation) +} + +//HasFundRenewWaiv returns true if FundRenewWaiv is present, Tag 497 +func (m NewOrderSingle) HasFundRenewWaiv() bool { + return m.Has(tag.FundRenewWaiv) +} + +//HasRegistID returns true if RegistID is present, Tag 513 +func (m NewOrderSingle) HasRegistID() bool { + return m.Has(tag.RegistID) +} + +//HasOrderPercent returns true if OrderPercent is present, Tag 516 +func (m NewOrderSingle) HasOrderPercent() bool { + return m.Has(tag.OrderPercent) +} + +//HasSecondaryClOrdID returns true if SecondaryClOrdID is present, Tag 526 +func (m NewOrderSingle) HasSecondaryClOrdID() bool { + return m.Has(tag.SecondaryClOrdID) +} + +//HasOrderCapacity returns true if OrderCapacity is present, Tag 528 +func (m NewOrderSingle) HasOrderCapacity() bool { + return m.Has(tag.OrderCapacity) +} + +//HasOrderRestrictions returns true if OrderRestrictions is present, Tag 529 +func (m NewOrderSingle) HasOrderRestrictions() bool { + return m.Has(tag.OrderRestrictions) +} + +//HasMaturityDate returns true if MaturityDate is present, Tag 541 +func (m NewOrderSingle) HasMaturityDate() bool { + return m.Has(tag.MaturityDate) +} + +//HasInstrRegistry returns true if InstrRegistry is present, Tag 543 +func (m NewOrderSingle) HasInstrRegistry() bool { + return m.Has(tag.InstrRegistry) +} + +//HasCashMargin returns true if CashMargin is present, Tag 544 +func (m NewOrderSingle) HasCashMargin() bool { + return m.Has(tag.CashMargin) +} + +//HasAccountType returns true if AccountType is present, Tag 581 +func (m NewOrderSingle) HasAccountType() bool { + return m.Has(tag.AccountType) +} + +//HasCustOrderCapacity returns true if CustOrderCapacity is present, Tag 582 +func (m NewOrderSingle) HasCustOrderCapacity() bool { + return m.Has(tag.CustOrderCapacity) +} + +//HasClOrdLinkID returns true if ClOrdLinkID is present, Tag 583 +func (m NewOrderSingle) HasClOrdLinkID() bool { + return m.Has(tag.ClOrdLinkID) +} + +//HasDayBookingInst returns true if DayBookingInst is present, Tag 589 +func (m NewOrderSingle) HasDayBookingInst() bool { + return m.Has(tag.DayBookingInst) +} + +//HasBookingUnit returns true if BookingUnit is present, Tag 590 +func (m NewOrderSingle) HasBookingUnit() bool { + return m.Has(tag.BookingUnit) +} + +//HasPreallocMethod returns true if PreallocMethod is present, Tag 591 +func (m NewOrderSingle) HasPreallocMethod() bool { + return m.Has(tag.PreallocMethod) +} + +//HasClearingFeeIndicator returns true if ClearingFeeIndicator is present, Tag 635 +func (m NewOrderSingle) HasClearingFeeIndicator() bool { + return m.Has(tag.ClearingFeeIndicator) +} + +//HasPrice2 returns true if Price2 is present, Tag 640 +func (m NewOrderSingle) HasPrice2() bool { + return m.Has(tag.Price2) +} + +//HasAcctIDSource returns true if AcctIDSource is present, Tag 660 +func (m NewOrderSingle) HasAcctIDSource() bool { + return m.Has(tag.AcctIDSource) +} + +//HasBenchmarkPrice returns true if BenchmarkPrice is present, Tag 662 +func (m NewOrderSingle) HasBenchmarkPrice() bool { + return m.Has(tag.BenchmarkPrice) +} + +//HasBenchmarkPriceType returns true if BenchmarkPriceType is present, Tag 663 +func (m NewOrderSingle) HasBenchmarkPriceType() bool { + return m.Has(tag.BenchmarkPriceType) +} + +//HasContractSettlMonth returns true if ContractSettlMonth is present, Tag 667 +func (m NewOrderSingle) HasContractSettlMonth() bool { + return m.Has(tag.ContractSettlMonth) +} + +//HasPool returns true if Pool is present, Tag 691 +func (m NewOrderSingle) HasPool() bool { + return m.Has(tag.Pool) +} + +//HasYieldRedemptionDate returns true if YieldRedemptionDate is present, Tag 696 +func (m NewOrderSingle) HasYieldRedemptionDate() bool { + return m.Has(tag.YieldRedemptionDate) +} + +//HasYieldRedemptionPrice returns true if YieldRedemptionPrice is present, Tag 697 +func (m NewOrderSingle) HasYieldRedemptionPrice() bool { + return m.Has(tag.YieldRedemptionPrice) +} + +//HasYieldRedemptionPriceType returns true if YieldRedemptionPriceType is present, Tag 698 +func (m NewOrderSingle) HasYieldRedemptionPriceType() bool { + return m.Has(tag.YieldRedemptionPriceType) +} + +//HasBenchmarkSecurityID returns true if BenchmarkSecurityID is present, Tag 699 +func (m NewOrderSingle) HasBenchmarkSecurityID() bool { + return m.Has(tag.BenchmarkSecurityID) +} + +//HasYieldCalcDate returns true if YieldCalcDate is present, Tag 701 +func (m NewOrderSingle) HasYieldCalcDate() bool { + return m.Has(tag.YieldCalcDate) +} + +//HasNoUnderlyings returns true if NoUnderlyings is present, Tag 711 +func (m NewOrderSingle) HasNoUnderlyings() bool { + return m.Has(tag.NoUnderlyings) +} + +//HasBenchmarkSecurityIDSource returns true if BenchmarkSecurityIDSource is present, Tag 761 +func (m NewOrderSingle) HasBenchmarkSecurityIDSource() bool { + return m.Has(tag.BenchmarkSecurityIDSource) +} + +//HasSecuritySubType returns true if SecuritySubType is present, Tag 762 +func (m NewOrderSingle) HasSecuritySubType() bool { + return m.Has(tag.SecuritySubType) +} + +//HasNoTrdRegTimestamps returns true if NoTrdRegTimestamps is present, Tag 768 +func (m NewOrderSingle) HasNoTrdRegTimestamps() bool { + return m.Has(tag.NoTrdRegTimestamps) +} + +//HasBookingType returns true if BookingType is present, Tag 775 +func (m NewOrderSingle) HasBookingType() bool { + return m.Has(tag.BookingType) +} + +//HasTerminationType returns true if TerminationType is present, Tag 788 +func (m NewOrderSingle) HasTerminationType() bool { + return m.Has(tag.TerminationType) +} + +//HasPegMoveType returns true if PegMoveType is present, Tag 835 +func (m NewOrderSingle) HasPegMoveType() bool { + return m.Has(tag.PegMoveType) +} + +//HasPegOffsetType returns true if PegOffsetType is present, Tag 836 +func (m NewOrderSingle) HasPegOffsetType() bool { + return m.Has(tag.PegOffsetType) +} + +//HasPegLimitType returns true if PegLimitType is present, Tag 837 +func (m NewOrderSingle) HasPegLimitType() bool { + return m.Has(tag.PegLimitType) +} + +//HasPegRoundDirection returns true if PegRoundDirection is present, Tag 838 +func (m NewOrderSingle) HasPegRoundDirection() bool { + return m.Has(tag.PegRoundDirection) +} + +//HasPegScope returns true if PegScope is present, Tag 840 +func (m NewOrderSingle) HasPegScope() bool { + return m.Has(tag.PegScope) +} + +//HasDiscretionMoveType returns true if DiscretionMoveType is present, Tag 841 +func (m NewOrderSingle) HasDiscretionMoveType() bool { + return m.Has(tag.DiscretionMoveType) +} + +//HasDiscretionOffsetType returns true if DiscretionOffsetType is present, Tag 842 +func (m NewOrderSingle) HasDiscretionOffsetType() bool { + return m.Has(tag.DiscretionOffsetType) +} + +//HasDiscretionLimitType returns true if DiscretionLimitType is present, Tag 843 +func (m NewOrderSingle) HasDiscretionLimitType() bool { + return m.Has(tag.DiscretionLimitType) +} + +//HasDiscretionRoundDirection returns true if DiscretionRoundDirection is present, Tag 844 +func (m NewOrderSingle) HasDiscretionRoundDirection() bool { + return m.Has(tag.DiscretionRoundDirection) +} + +//HasDiscretionScope returns true if DiscretionScope is present, Tag 846 +func (m NewOrderSingle) HasDiscretionScope() bool { + return m.Has(tag.DiscretionScope) +} + +//HasTargetStrategy returns true if TargetStrategy is present, Tag 847 +func (m NewOrderSingle) HasTargetStrategy() bool { + return m.Has(tag.TargetStrategy) +} + +//HasTargetStrategyParameters returns true if TargetStrategyParameters is present, Tag 848 +func (m NewOrderSingle) HasTargetStrategyParameters() bool { + return m.Has(tag.TargetStrategyParameters) +} + +//HasParticipationRate returns true if ParticipationRate is present, Tag 849 +func (m NewOrderSingle) HasParticipationRate() bool { + return m.Has(tag.ParticipationRate) +} + +//HasQtyType returns true if QtyType is present, Tag 854 +func (m NewOrderSingle) HasQtyType() bool { + return m.Has(tag.QtyType) +} + +//HasNoEvents returns true if NoEvents is present, Tag 864 +func (m NewOrderSingle) HasNoEvents() bool { + return m.Has(tag.NoEvents) +} + +//HasDatedDate returns true if DatedDate is present, Tag 873 +func (m NewOrderSingle) HasDatedDate() bool { + return m.Has(tag.DatedDate) +} + +//HasInterestAccrualDate returns true if InterestAccrualDate is present, Tag 874 +func (m NewOrderSingle) HasInterestAccrualDate() bool { + return m.Has(tag.InterestAccrualDate) +} + +//HasCPProgram returns true if CPProgram is present, Tag 875 +func (m NewOrderSingle) HasCPProgram() bool { + return m.Has(tag.CPProgram) +} + +//HasCPRegType returns true if CPRegType is present, Tag 876 +func (m NewOrderSingle) HasCPRegType() bool { + return m.Has(tag.CPRegType) +} + +//HasMarginRatio returns true if MarginRatio is present, Tag 898 +func (m NewOrderSingle) HasMarginRatio() bool { + return m.Has(tag.MarginRatio) +} + +//HasAgreementDesc returns true if AgreementDesc is present, Tag 913 +func (m NewOrderSingle) HasAgreementDesc() bool { + return m.Has(tag.AgreementDesc) +} + +//HasAgreementID returns true if AgreementID is present, Tag 914 +func (m NewOrderSingle) HasAgreementID() bool { + return m.Has(tag.AgreementID) +} + +//HasAgreementDate returns true if AgreementDate is present, Tag 915 +func (m NewOrderSingle) HasAgreementDate() bool { + return m.Has(tag.AgreementDate) +} + +//HasStartDate returns true if StartDate is present, Tag 916 +func (m NewOrderSingle) HasStartDate() bool { + return m.Has(tag.StartDate) +} + +//HasEndDate returns true if EndDate is present, Tag 917 +func (m NewOrderSingle) HasEndDate() bool { + return m.Has(tag.EndDate) +} + +//HasAgreementCurrency returns true if AgreementCurrency is present, Tag 918 +func (m NewOrderSingle) HasAgreementCurrency() bool { + return m.Has(tag.AgreementCurrency) +} + +//HasDeliveryType returns true if DeliveryType is present, Tag 919 +func (m NewOrderSingle) HasDeliveryType() bool { + return m.Has(tag.DeliveryType) +} + +//HasStrikeCurrency returns true if StrikeCurrency is present, Tag 947 +func (m NewOrderSingle) HasStrikeCurrency() bool { + return m.Has(tag.StrikeCurrency) +} + +//HasNoStrategyParameters returns true if NoStrategyParameters is present, Tag 957 +func (m NewOrderSingle) HasNoStrategyParameters() bool { + return m.Has(tag.NoStrategyParameters) +} + +//HasSecurityStatus returns true if SecurityStatus is present, Tag 965 +func (m NewOrderSingle) HasSecurityStatus() bool { + return m.Has(tag.SecurityStatus) +} + +//HasSettleOnOpenFlag returns true if SettleOnOpenFlag is present, Tag 966 +func (m NewOrderSingle) HasSettleOnOpenFlag() bool { + return m.Has(tag.SettleOnOpenFlag) +} + +//HasStrikeMultiplier returns true if StrikeMultiplier is present, Tag 967 +func (m NewOrderSingle) HasStrikeMultiplier() bool { + return m.Has(tag.StrikeMultiplier) +} + +//HasStrikeValue returns true if StrikeValue is present, Tag 968 +func (m NewOrderSingle) HasStrikeValue() bool { + return m.Has(tag.StrikeValue) +} + +//HasMinPriceIncrement returns true if MinPriceIncrement is present, Tag 969 +func (m NewOrderSingle) HasMinPriceIncrement() bool { + return m.Has(tag.MinPriceIncrement) +} + +//HasPositionLimit returns true if PositionLimit is present, Tag 970 +func (m NewOrderSingle) HasPositionLimit() bool { + return m.Has(tag.PositionLimit) +} + +//HasNTPositionLimit returns true if NTPositionLimit is present, Tag 971 +func (m NewOrderSingle) HasNTPositionLimit() bool { + return m.Has(tag.NTPositionLimit) +} + +//HasUnitOfMeasure returns true if UnitOfMeasure is present, Tag 996 +func (m NewOrderSingle) HasUnitOfMeasure() bool { + return m.Has(tag.UnitOfMeasure) +} + +//HasTimeUnit returns true if TimeUnit is present, Tag 997 +func (m NewOrderSingle) HasTimeUnit() bool { + return m.Has(tag.TimeUnit) +} + +//HasNoInstrumentParties returns true if NoInstrumentParties is present, Tag 1018 +func (m NewOrderSingle) HasNoInstrumentParties() bool { + return m.Has(tag.NoInstrumentParties) +} + +//HasManualOrderIndicator returns true if ManualOrderIndicator is present, Tag 1028 +func (m NewOrderSingle) HasManualOrderIndicator() bool { + return m.Has(tag.ManualOrderIndicator) +} + +//HasCustDirectedOrder returns true if CustDirectedOrder is present, Tag 1029 +func (m NewOrderSingle) HasCustDirectedOrder() bool { + return m.Has(tag.CustDirectedOrder) +} + +//HasReceivedDeptID returns true if ReceivedDeptID is present, Tag 1030 +func (m NewOrderSingle) HasReceivedDeptID() bool { + return m.Has(tag.ReceivedDeptID) +} + +//HasCustOrderHandlingInst returns true if CustOrderHandlingInst is present, Tag 1031 +func (m NewOrderSingle) HasCustOrderHandlingInst() bool { + return m.Has(tag.CustOrderHandlingInst) +} + +//HasOrderHandlingInstSource returns true if OrderHandlingInstSource is present, Tag 1032 +func (m NewOrderSingle) HasOrderHandlingInstSource() bool { + return m.Has(tag.OrderHandlingInstSource) +} + +//HasInstrmtAssignmentMethod returns true if InstrmtAssignmentMethod is present, Tag 1049 +func (m NewOrderSingle) HasInstrmtAssignmentMethod() bool { + return m.Has(tag.InstrmtAssignmentMethod) +} + +//HasMaturityTime returns true if MaturityTime is present, Tag 1079 +func (m NewOrderSingle) HasMaturityTime() bool { + return m.Has(tag.MaturityTime) +} + +//HasRefOrderID returns true if RefOrderID is present, Tag 1080 +func (m NewOrderSingle) HasRefOrderID() bool { + return m.Has(tag.RefOrderID) +} + +//HasRefOrderIDSource returns true if RefOrderIDSource is present, Tag 1081 +func (m NewOrderSingle) HasRefOrderIDSource() bool { + return m.Has(tag.RefOrderIDSource) +} + +//HasSecondaryDisplayQty returns true if SecondaryDisplayQty is present, Tag 1082 +func (m NewOrderSingle) HasSecondaryDisplayQty() bool { + return m.Has(tag.SecondaryDisplayQty) +} + +//HasDisplayWhen returns true if DisplayWhen is present, Tag 1083 +func (m NewOrderSingle) HasDisplayWhen() bool { + return m.Has(tag.DisplayWhen) +} + +//HasDisplayMethod returns true if DisplayMethod is present, Tag 1084 +func (m NewOrderSingle) HasDisplayMethod() bool { + return m.Has(tag.DisplayMethod) +} + +//HasDisplayLowQty returns true if DisplayLowQty is present, Tag 1085 +func (m NewOrderSingle) HasDisplayLowQty() bool { + return m.Has(tag.DisplayLowQty) +} + +//HasDisplayHighQty returns true if DisplayHighQty is present, Tag 1086 +func (m NewOrderSingle) HasDisplayHighQty() bool { + return m.Has(tag.DisplayHighQty) +} + +//HasDisplayMinIncr returns true if DisplayMinIncr is present, Tag 1087 +func (m NewOrderSingle) HasDisplayMinIncr() bool { + return m.Has(tag.DisplayMinIncr) +} + +//HasRefreshQty returns true if RefreshQty is present, Tag 1088 +func (m NewOrderSingle) HasRefreshQty() bool { + return m.Has(tag.RefreshQty) +} + +//HasMatchIncrement returns true if MatchIncrement is present, Tag 1089 +func (m NewOrderSingle) HasMatchIncrement() bool { + return m.Has(tag.MatchIncrement) +} + +//HasMaxPriceLevels returns true if MaxPriceLevels is present, Tag 1090 +func (m NewOrderSingle) HasMaxPriceLevels() bool { + return m.Has(tag.MaxPriceLevels) +} + +//HasPreTradeAnonymity returns true if PreTradeAnonymity is present, Tag 1091 +func (m NewOrderSingle) HasPreTradeAnonymity() bool { + return m.Has(tag.PreTradeAnonymity) +} + +//HasPriceProtectionScope returns true if PriceProtectionScope is present, Tag 1092 +func (m NewOrderSingle) HasPriceProtectionScope() bool { + return m.Has(tag.PriceProtectionScope) +} + +//HasPegPriceType returns true if PegPriceType is present, Tag 1094 +func (m NewOrderSingle) HasPegPriceType() bool { + return m.Has(tag.PegPriceType) +} + +//HasPegSecurityIDSource returns true if PegSecurityIDSource is present, Tag 1096 +func (m NewOrderSingle) HasPegSecurityIDSource() bool { + return m.Has(tag.PegSecurityIDSource) +} + +//HasPegSecurityID returns true if PegSecurityID is present, Tag 1097 +func (m NewOrderSingle) HasPegSecurityID() bool { + return m.Has(tag.PegSecurityID) +} + +//HasPegSymbol returns true if PegSymbol is present, Tag 1098 +func (m NewOrderSingle) HasPegSymbol() bool { + return m.Has(tag.PegSymbol) +} + +//HasPegSecurityDesc returns true if PegSecurityDesc is present, Tag 1099 +func (m NewOrderSingle) HasPegSecurityDesc() bool { + return m.Has(tag.PegSecurityDesc) +} + +//HasTriggerType returns true if TriggerType is present, Tag 1100 +func (m NewOrderSingle) HasTriggerType() bool { + return m.Has(tag.TriggerType) +} + +//HasTriggerAction returns true if TriggerAction is present, Tag 1101 +func (m NewOrderSingle) HasTriggerAction() bool { + return m.Has(tag.TriggerAction) +} + +//HasTriggerPrice returns true if TriggerPrice is present, Tag 1102 +func (m NewOrderSingle) HasTriggerPrice() bool { + return m.Has(tag.TriggerPrice) +} + +//HasTriggerSymbol returns true if TriggerSymbol is present, Tag 1103 +func (m NewOrderSingle) HasTriggerSymbol() bool { + return m.Has(tag.TriggerSymbol) +} + +//HasTriggerSecurityID returns true if TriggerSecurityID is present, Tag 1104 +func (m NewOrderSingle) HasTriggerSecurityID() bool { + return m.Has(tag.TriggerSecurityID) +} + +//HasTriggerSecurityIDSource returns true if TriggerSecurityIDSource is present, Tag 1105 +func (m NewOrderSingle) HasTriggerSecurityIDSource() bool { + return m.Has(tag.TriggerSecurityIDSource) +} + +//HasTriggerSecurityDesc returns true if TriggerSecurityDesc is present, Tag 1106 +func (m NewOrderSingle) HasTriggerSecurityDesc() bool { + return m.Has(tag.TriggerSecurityDesc) +} + +//HasTriggerPriceType returns true if TriggerPriceType is present, Tag 1107 +func (m NewOrderSingle) HasTriggerPriceType() bool { + return m.Has(tag.TriggerPriceType) +} + +//HasTriggerPriceTypeScope returns true if TriggerPriceTypeScope is present, Tag 1108 +func (m NewOrderSingle) HasTriggerPriceTypeScope() bool { + return m.Has(tag.TriggerPriceTypeScope) +} + +//HasTriggerPriceDirection returns true if TriggerPriceDirection is present, Tag 1109 +func (m NewOrderSingle) HasTriggerPriceDirection() bool { + return m.Has(tag.TriggerPriceDirection) +} + +//HasTriggerNewPrice returns true if TriggerNewPrice is present, Tag 1110 +func (m NewOrderSingle) HasTriggerNewPrice() bool { + return m.Has(tag.TriggerNewPrice) +} + +//HasTriggerOrderType returns true if TriggerOrderType is present, Tag 1111 +func (m NewOrderSingle) HasTriggerOrderType() bool { + return m.Has(tag.TriggerOrderType) +} + +//HasTriggerNewQty returns true if TriggerNewQty is present, Tag 1112 +func (m NewOrderSingle) HasTriggerNewQty() bool { + return m.Has(tag.TriggerNewQty) +} + +//HasTriggerTradingSessionID returns true if TriggerTradingSessionID is present, Tag 1113 +func (m NewOrderSingle) HasTriggerTradingSessionID() bool { + return m.Has(tag.TriggerTradingSessionID) +} + +//HasTriggerTradingSessionSubID returns true if TriggerTradingSessionSubID is present, Tag 1114 +func (m NewOrderSingle) HasTriggerTradingSessionSubID() bool { + return m.Has(tag.TriggerTradingSessionSubID) +} + +//HasExDestinationIDSource returns true if ExDestinationIDSource is present, Tag 1133 +func (m NewOrderSingle) HasExDestinationIDSource() bool { + return m.Has(tag.ExDestinationIDSource) +} + +//HasDisplayQty returns true if DisplayQty is present, Tag 1138 +func (m NewOrderSingle) HasDisplayQty() bool { + return m.Has(tag.DisplayQty) +} + +//NoAllocs is a repeating group element, Tag 78 +type NoAllocs struct { + quickfix.Group +} + +//SetAllocAccount sets AllocAccount, Tag 79 +func (m NoAllocs) SetAllocAccount(v string) { + m.Set(field.NewAllocAccount(v)) +} + +//SetAllocAcctIDSource sets AllocAcctIDSource, Tag 661 +func (m NoAllocs) SetAllocAcctIDSource(v int) { + m.Set(field.NewAllocAcctIDSource(v)) +} + +//SetAllocSettlCurrency sets AllocSettlCurrency, Tag 736 +func (m NoAllocs) SetAllocSettlCurrency(v string) { + m.Set(field.NewAllocSettlCurrency(v)) +} + +//SetIndividualAllocID sets IndividualAllocID, Tag 467 +func (m NoAllocs) SetIndividualAllocID(v string) { + m.Set(field.NewIndividualAllocID(v)) +} + +//SetNoNestedPartyIDs sets NoNestedPartyIDs, Tag 539 +func (m NoAllocs) SetNoNestedPartyIDs(f NoNestedPartyIDsRepeatingGroup) { + m.SetGroup(f) +} + +//SetAllocQty sets AllocQty, Tag 80 +func (m NoAllocs) SetAllocQty(v float64) { + m.Set(field.NewAllocQty(v)) +} + +//GetAllocAccount gets AllocAccount, Tag 79 +func (m NoAllocs) GetAllocAccount() (f field.AllocAccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAllocAcctIDSource gets AllocAcctIDSource, Tag 661 +func (m NoAllocs) GetAllocAcctIDSource() (f field.AllocAcctIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAllocSettlCurrency gets AllocSettlCurrency, Tag 736 +func (m NoAllocs) GetAllocSettlCurrency() (f field.AllocSettlCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIndividualAllocID gets IndividualAllocID, Tag 467 +func (m NoAllocs) GetIndividualAllocID() (f field.IndividualAllocIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoNestedPartyIDs gets NoNestedPartyIDs, Tag 539 +func (m NoAllocs) GetNoNestedPartyIDs() (NoNestedPartyIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoNestedPartyIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetAllocQty gets AllocQty, Tag 80 +func (m NoAllocs) GetAllocQty() (f field.AllocQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasAllocAccount returns true if AllocAccount is present, Tag 79 +func (m NoAllocs) HasAllocAccount() bool { + return m.Has(tag.AllocAccount) +} + +//HasAllocAcctIDSource returns true if AllocAcctIDSource is present, Tag 661 +func (m NoAllocs) HasAllocAcctIDSource() bool { + return m.Has(tag.AllocAcctIDSource) +} + +//HasAllocSettlCurrency returns true if AllocSettlCurrency is present, Tag 736 +func (m NoAllocs) HasAllocSettlCurrency() bool { + return m.Has(tag.AllocSettlCurrency) +} + +//HasIndividualAllocID returns true if IndividualAllocID is present, Tag 467 +func (m NoAllocs) HasIndividualAllocID() bool { + return m.Has(tag.IndividualAllocID) +} + +//HasNoNestedPartyIDs returns true if NoNestedPartyIDs is present, Tag 539 +func (m NoAllocs) HasNoNestedPartyIDs() bool { + return m.Has(tag.NoNestedPartyIDs) +} + +//HasAllocQty returns true if AllocQty is present, Tag 80 +func (m NoAllocs) HasAllocQty() bool { + return m.Has(tag.AllocQty) +} + +//NoNestedPartyIDs is a repeating group element, Tag 539 +type NoNestedPartyIDs struct { + quickfix.Group +} + +//SetNestedPartyID sets NestedPartyID, Tag 524 +func (m NoNestedPartyIDs) SetNestedPartyID(v string) { + m.Set(field.NewNestedPartyID(v)) +} + +//SetNestedPartyIDSource sets NestedPartyIDSource, Tag 525 +func (m NoNestedPartyIDs) SetNestedPartyIDSource(v string) { + m.Set(field.NewNestedPartyIDSource(v)) +} + +//SetNestedPartyRole sets NestedPartyRole, Tag 538 +func (m NoNestedPartyIDs) SetNestedPartyRole(v int) { + m.Set(field.NewNestedPartyRole(v)) +} + +//SetNoNestedPartySubIDs sets NoNestedPartySubIDs, Tag 804 +func (m NoNestedPartyIDs) SetNoNestedPartySubIDs(f NoNestedPartySubIDsRepeatingGroup) { + m.SetGroup(f) +} + +//GetNestedPartyID gets NestedPartyID, Tag 524 +func (m NoNestedPartyIDs) GetNestedPartyID() (f field.NestedPartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNestedPartyIDSource gets NestedPartyIDSource, Tag 525 +func (m NoNestedPartyIDs) GetNestedPartyIDSource() (f field.NestedPartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNestedPartyRole gets NestedPartyRole, Tag 538 +func (m NoNestedPartyIDs) GetNestedPartyRole() (f field.NestedPartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoNestedPartySubIDs gets NoNestedPartySubIDs, Tag 804 +func (m NoNestedPartyIDs) GetNoNestedPartySubIDs() (NoNestedPartySubIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoNestedPartySubIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasNestedPartyID returns true if NestedPartyID is present, Tag 524 +func (m NoNestedPartyIDs) HasNestedPartyID() bool { + return m.Has(tag.NestedPartyID) +} + +//HasNestedPartyIDSource returns true if NestedPartyIDSource is present, Tag 525 +func (m NoNestedPartyIDs) HasNestedPartyIDSource() bool { + return m.Has(tag.NestedPartyIDSource) +} + +//HasNestedPartyRole returns true if NestedPartyRole is present, Tag 538 +func (m NoNestedPartyIDs) HasNestedPartyRole() bool { + return m.Has(tag.NestedPartyRole) +} + +//HasNoNestedPartySubIDs returns true if NoNestedPartySubIDs is present, Tag 804 +func (m NoNestedPartyIDs) HasNoNestedPartySubIDs() bool { + return m.Has(tag.NoNestedPartySubIDs) +} + +//NoNestedPartySubIDs is a repeating group element, Tag 804 +type NoNestedPartySubIDs struct { + quickfix.Group +} + +//SetNestedPartySubID sets NestedPartySubID, Tag 545 +func (m NoNestedPartySubIDs) SetNestedPartySubID(v string) { + m.Set(field.NewNestedPartySubID(v)) +} + +//SetNestedPartySubIDType sets NestedPartySubIDType, Tag 805 +func (m NoNestedPartySubIDs) SetNestedPartySubIDType(v int) { + m.Set(field.NewNestedPartySubIDType(v)) +} + +//GetNestedPartySubID gets NestedPartySubID, Tag 545 +func (m NoNestedPartySubIDs) GetNestedPartySubID() (f field.NestedPartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNestedPartySubIDType gets NestedPartySubIDType, Tag 805 +func (m NoNestedPartySubIDs) GetNestedPartySubIDType() (f field.NestedPartySubIDTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasNestedPartySubID returns true if NestedPartySubID is present, Tag 545 +func (m NoNestedPartySubIDs) HasNestedPartySubID() bool { + return m.Has(tag.NestedPartySubID) +} + +//HasNestedPartySubIDType returns true if NestedPartySubIDType is present, Tag 805 +func (m NoNestedPartySubIDs) HasNestedPartySubIDType() bool { + return m.Has(tag.NestedPartySubIDType) +} + +//NoNestedPartySubIDsRepeatingGroup is a repeating group, Tag 804 +type NoNestedPartySubIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoNestedPartySubIDsRepeatingGroup returns an initialized, NoNestedPartySubIDsRepeatingGroup +func NewNoNestedPartySubIDsRepeatingGroup() NoNestedPartySubIDsRepeatingGroup { + return NoNestedPartySubIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoNestedPartySubIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.NestedPartySubID), quickfix.GroupElement(tag.NestedPartySubIDType)})} +} + +//Add create and append a new NoNestedPartySubIDs to this group +func (m NoNestedPartySubIDsRepeatingGroup) Add() NoNestedPartySubIDs { + g := m.RepeatingGroup.Add() + return NoNestedPartySubIDs{g} +} + +//Get returns the ith NoNestedPartySubIDs in the NoNestedPartySubIDsRepeatinGroup +func (m NoNestedPartySubIDsRepeatingGroup) Get(i int) NoNestedPartySubIDs { + return NoNestedPartySubIDs{m.RepeatingGroup.Get(i)} +} + +//NoNestedPartyIDsRepeatingGroup is a repeating group, Tag 539 +type NoNestedPartyIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoNestedPartyIDsRepeatingGroup returns an initialized, NoNestedPartyIDsRepeatingGroup +func NewNoNestedPartyIDsRepeatingGroup() NoNestedPartyIDsRepeatingGroup { + return NoNestedPartyIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoNestedPartyIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.NestedPartyID), quickfix.GroupElement(tag.NestedPartyIDSource), quickfix.GroupElement(tag.NestedPartyRole), NewNoNestedPartySubIDsRepeatingGroup()})} +} + +//Add create and append a new NoNestedPartyIDs to this group +func (m NoNestedPartyIDsRepeatingGroup) Add() NoNestedPartyIDs { + g := m.RepeatingGroup.Add() + return NoNestedPartyIDs{g} +} + +//Get returns the ith NoNestedPartyIDs in the NoNestedPartyIDsRepeatinGroup +func (m NoNestedPartyIDsRepeatingGroup) Get(i int) NoNestedPartyIDs { + return NoNestedPartyIDs{m.RepeatingGroup.Get(i)} +} + +//NoAllocsRepeatingGroup is a repeating group, Tag 78 +type NoAllocsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoAllocsRepeatingGroup returns an initialized, NoAllocsRepeatingGroup +func NewNoAllocsRepeatingGroup() NoAllocsRepeatingGroup { + return NoAllocsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoAllocs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.AllocAccount), quickfix.GroupElement(tag.AllocAcctIDSource), quickfix.GroupElement(tag.AllocSettlCurrency), quickfix.GroupElement(tag.IndividualAllocID), NewNoNestedPartyIDsRepeatingGroup(), quickfix.GroupElement(tag.AllocQty)})} +} + +//Add create and append a new NoAllocs to this group +func (m NoAllocsRepeatingGroup) Add() NoAllocs { + g := m.RepeatingGroup.Add() + return NoAllocs{g} +} + +//Get returns the ith NoAllocs in the NoAllocsRepeatinGroup +func (m NoAllocsRepeatingGroup) Get(i int) NoAllocs { + return NoAllocs{m.RepeatingGroup.Get(i)} +} + +//NoStipulations is a repeating group element, Tag 232 +type NoStipulations struct { + quickfix.Group +} + +//SetStipulationType sets StipulationType, Tag 233 +func (m NoStipulations) SetStipulationType(v string) { + m.Set(field.NewStipulationType(v)) +} + +//SetStipulationValue sets StipulationValue, Tag 234 +func (m NoStipulations) SetStipulationValue(v string) { + m.Set(field.NewStipulationValue(v)) +} + +//GetStipulationType gets StipulationType, Tag 233 +func (m NoStipulations) GetStipulationType() (f field.StipulationTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStipulationValue gets StipulationValue, Tag 234 +func (m NoStipulations) GetStipulationValue() (f field.StipulationValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasStipulationType returns true if StipulationType is present, Tag 233 +func (m NoStipulations) HasStipulationType() bool { + return m.Has(tag.StipulationType) +} + +//HasStipulationValue returns true if StipulationValue is present, Tag 234 +func (m NoStipulations) HasStipulationValue() bool { + return m.Has(tag.StipulationValue) +} + +//NoStipulationsRepeatingGroup is a repeating group, Tag 232 +type NoStipulationsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoStipulationsRepeatingGroup returns an initialized, NoStipulationsRepeatingGroup +func NewNoStipulationsRepeatingGroup() NoStipulationsRepeatingGroup { + return NoStipulationsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoStipulations, + quickfix.GroupTemplate{quickfix.GroupElement(tag.StipulationType), quickfix.GroupElement(tag.StipulationValue)})} +} + +//Add create and append a new NoStipulations to this group +func (m NoStipulationsRepeatingGroup) Add() NoStipulations { + g := m.RepeatingGroup.Add() + return NoStipulations{g} +} + +//Get returns the ith NoStipulations in the NoStipulationsRepeatinGroup +func (m NoStipulationsRepeatingGroup) Get(i int) NoStipulations { + return NoStipulations{m.RepeatingGroup.Get(i)} +} + +//NoTradingSessions is a repeating group element, Tag 386 +type NoTradingSessions struct { + quickfix.Group +} + +//SetTradingSessionID sets TradingSessionID, Tag 336 +func (m NoTradingSessions) SetTradingSessionID(v string) { + m.Set(field.NewTradingSessionID(v)) +} + +//SetTradingSessionSubID sets TradingSessionSubID, Tag 625 +func (m NoTradingSessions) SetTradingSessionSubID(v string) { + m.Set(field.NewTradingSessionSubID(v)) +} + +//GetTradingSessionID gets TradingSessionID, Tag 336 +func (m NoTradingSessions) GetTradingSessionID() (f field.TradingSessionIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTradingSessionSubID gets TradingSessionSubID, Tag 625 +func (m NoTradingSessions) GetTradingSessionSubID() (f field.TradingSessionSubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasTradingSessionID returns true if TradingSessionID is present, Tag 336 +func (m NoTradingSessions) HasTradingSessionID() bool { + return m.Has(tag.TradingSessionID) +} + +//HasTradingSessionSubID returns true if TradingSessionSubID is present, Tag 625 +func (m NoTradingSessions) HasTradingSessionSubID() bool { + return m.Has(tag.TradingSessionSubID) +} + +//NoTradingSessionsRepeatingGroup is a repeating group, Tag 386 +type NoTradingSessionsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoTradingSessionsRepeatingGroup returns an initialized, NoTradingSessionsRepeatingGroup +func NewNoTradingSessionsRepeatingGroup() NoTradingSessionsRepeatingGroup { + return NoTradingSessionsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoTradingSessions, + quickfix.GroupTemplate{quickfix.GroupElement(tag.TradingSessionID), quickfix.GroupElement(tag.TradingSessionSubID)})} +} + +//Add create and append a new NoTradingSessions to this group +func (m NoTradingSessionsRepeatingGroup) Add() NoTradingSessions { + g := m.RepeatingGroup.Add() + return NoTradingSessions{g} +} + +//Get returns the ith NoTradingSessions in the NoTradingSessionsRepeatinGroup +func (m NoTradingSessionsRepeatingGroup) Get(i int) NoTradingSessions { + return NoTradingSessions{m.RepeatingGroup.Get(i)} +} + +//NoPartyIDs is a repeating group element, Tag 453 +type NoPartyIDs struct { + quickfix.Group +} + +//SetPartyID sets PartyID, Tag 448 +func (m NoPartyIDs) SetPartyID(v string) { + m.Set(field.NewPartyID(v)) +} + +//SetPartyIDSource sets PartyIDSource, Tag 447 +func (m NoPartyIDs) SetPartyIDSource(v string) { + m.Set(field.NewPartyIDSource(v)) +} + +//SetPartyRole sets PartyRole, Tag 452 +func (m NoPartyIDs) SetPartyRole(v int) { + m.Set(field.NewPartyRole(v)) +} + +//SetNoPartySubIDs sets NoPartySubIDs, Tag 802 +func (m NoPartyIDs) SetNoPartySubIDs(f NoPartySubIDsRepeatingGroup) { + m.SetGroup(f) +} + +//GetPartyID gets PartyID, Tag 448 +func (m NoPartyIDs) GetPartyID() (f field.PartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartyIDSource gets PartyIDSource, Tag 447 +func (m NoPartyIDs) GetPartyIDSource() (f field.PartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartyRole gets PartyRole, Tag 452 +func (m NoPartyIDs) GetPartyRole() (f field.PartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoPartySubIDs gets NoPartySubIDs, Tag 802 +func (m NoPartyIDs) GetNoPartySubIDs() (NoPartySubIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoPartySubIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasPartyID returns true if PartyID is present, Tag 448 +func (m NoPartyIDs) HasPartyID() bool { + return m.Has(tag.PartyID) +} + +//HasPartyIDSource returns true if PartyIDSource is present, Tag 447 +func (m NoPartyIDs) HasPartyIDSource() bool { + return m.Has(tag.PartyIDSource) +} + +//HasPartyRole returns true if PartyRole is present, Tag 452 +func (m NoPartyIDs) HasPartyRole() bool { + return m.Has(tag.PartyRole) +} + +//HasNoPartySubIDs returns true if NoPartySubIDs is present, Tag 802 +func (m NoPartyIDs) HasNoPartySubIDs() bool { + return m.Has(tag.NoPartySubIDs) +} + +//NoPartySubIDs is a repeating group element, Tag 802 +type NoPartySubIDs struct { + quickfix.Group +} + +//SetPartySubID sets PartySubID, Tag 523 +func (m NoPartySubIDs) SetPartySubID(v string) { + m.Set(field.NewPartySubID(v)) +} + +//SetPartySubIDType sets PartySubIDType, Tag 803 +func (m NoPartySubIDs) SetPartySubIDType(v int) { + m.Set(field.NewPartySubIDType(v)) +} + +//GetPartySubID gets PartySubID, Tag 523 +func (m NoPartySubIDs) GetPartySubID() (f field.PartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartySubIDType gets PartySubIDType, Tag 803 +func (m NoPartySubIDs) GetPartySubIDType() (f field.PartySubIDTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasPartySubID returns true if PartySubID is present, Tag 523 +func (m NoPartySubIDs) HasPartySubID() bool { + return m.Has(tag.PartySubID) +} + +//HasPartySubIDType returns true if PartySubIDType is present, Tag 803 +func (m NoPartySubIDs) HasPartySubIDType() bool { + return m.Has(tag.PartySubIDType) +} + +//NoPartySubIDsRepeatingGroup is a repeating group, Tag 802 +type NoPartySubIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoPartySubIDsRepeatingGroup returns an initialized, NoPartySubIDsRepeatingGroup +func NewNoPartySubIDsRepeatingGroup() NoPartySubIDsRepeatingGroup { + return NoPartySubIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoPartySubIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.PartySubID), quickfix.GroupElement(tag.PartySubIDType)})} +} + +//Add create and append a new NoPartySubIDs to this group +func (m NoPartySubIDsRepeatingGroup) Add() NoPartySubIDs { + g := m.RepeatingGroup.Add() + return NoPartySubIDs{g} +} + +//Get returns the ith NoPartySubIDs in the NoPartySubIDsRepeatinGroup +func (m NoPartySubIDsRepeatingGroup) Get(i int) NoPartySubIDs { + return NoPartySubIDs{m.RepeatingGroup.Get(i)} +} + +//NoPartyIDsRepeatingGroup is a repeating group, Tag 453 +type NoPartyIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoPartyIDsRepeatingGroup returns an initialized, NoPartyIDsRepeatingGroup +func NewNoPartyIDsRepeatingGroup() NoPartyIDsRepeatingGroup { + return NoPartyIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoPartyIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.PartyID), quickfix.GroupElement(tag.PartyIDSource), quickfix.GroupElement(tag.PartyRole), NewNoPartySubIDsRepeatingGroup()})} +} + +//Add create and append a new NoPartyIDs to this group +func (m NoPartyIDsRepeatingGroup) Add() NoPartyIDs { + g := m.RepeatingGroup.Add() + return NoPartyIDs{g} +} + +//Get returns the ith NoPartyIDs in the NoPartyIDsRepeatinGroup +func (m NoPartyIDsRepeatingGroup) Get(i int) NoPartyIDs { + return NoPartyIDs{m.RepeatingGroup.Get(i)} +} + +//NoSecurityAltID is a repeating group element, Tag 454 +type NoSecurityAltID struct { + quickfix.Group +} + +//SetSecurityAltID sets SecurityAltID, Tag 455 +func (m NoSecurityAltID) SetSecurityAltID(v string) { + m.Set(field.NewSecurityAltID(v)) +} + +//SetSecurityAltIDSource sets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) SetSecurityAltIDSource(v string) { + m.Set(field.NewSecurityAltIDSource(v)) +} + +//GetSecurityAltID gets SecurityAltID, Tag 455 +func (m NoSecurityAltID) GetSecurityAltID() (f field.SecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityAltIDSource gets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) GetSecurityAltIDSource() (f field.SecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasSecurityAltID returns true if SecurityAltID is present, Tag 455 +func (m NoSecurityAltID) HasSecurityAltID() bool { + return m.Has(tag.SecurityAltID) +} + +//HasSecurityAltIDSource returns true if SecurityAltIDSource is present, Tag 456 +func (m NoSecurityAltID) HasSecurityAltIDSource() bool { + return m.Has(tag.SecurityAltIDSource) +} + +//NoSecurityAltIDRepeatingGroup is a repeating group, Tag 454 +type NoSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoSecurityAltIDRepeatingGroup returns an initialized, NoSecurityAltIDRepeatingGroup +func NewNoSecurityAltIDRepeatingGroup() NoSecurityAltIDRepeatingGroup { + return NoSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.SecurityAltID), quickfix.GroupElement(tag.SecurityAltIDSource)})} +} + +//Add create and append a new NoSecurityAltID to this group +func (m NoSecurityAltIDRepeatingGroup) Add() NoSecurityAltID { + g := m.RepeatingGroup.Add() + return NoSecurityAltID{g} +} + +//Get returns the ith NoSecurityAltID in the NoSecurityAltIDRepeatinGroup +func (m NoSecurityAltIDRepeatingGroup) Get(i int) NoSecurityAltID { + return NoSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyings is a repeating group element, Tag 711 +type NoUnderlyings struct { + quickfix.Group +} + +//SetUnderlyingSymbol sets UnderlyingSymbol, Tag 311 +func (m NoUnderlyings) SetUnderlyingSymbol(v string) { + m.Set(field.NewUnderlyingSymbol(v)) +} + +//SetUnderlyingSymbolSfx sets UnderlyingSymbolSfx, Tag 312 +func (m NoUnderlyings) SetUnderlyingSymbolSfx(v string) { + m.Set(field.NewUnderlyingSymbolSfx(v)) +} + +//SetUnderlyingSecurityID sets UnderlyingSecurityID, Tag 309 +func (m NoUnderlyings) SetUnderlyingSecurityID(v string) { + m.Set(field.NewUnderlyingSecurityID(v)) +} + +//SetUnderlyingSecurityIDSource sets UnderlyingSecurityIDSource, Tag 305 +func (m NoUnderlyings) SetUnderlyingSecurityIDSource(v string) { + m.Set(field.NewUnderlyingSecurityIDSource(v)) +} + +//SetNoUnderlyingSecurityAltID sets NoUnderlyingSecurityAltID, Tag 457 +func (m NoUnderlyings) SetNoUnderlyingSecurityAltID(f NoUnderlyingSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetUnderlyingProduct sets UnderlyingProduct, Tag 462 +func (m NoUnderlyings) SetUnderlyingProduct(v int) { + m.Set(field.NewUnderlyingProduct(v)) +} + +//SetUnderlyingCFICode sets UnderlyingCFICode, Tag 463 +func (m NoUnderlyings) SetUnderlyingCFICode(v string) { + m.Set(field.NewUnderlyingCFICode(v)) +} + +//SetUnderlyingSecurityType sets UnderlyingSecurityType, Tag 310 +func (m NoUnderlyings) SetUnderlyingSecurityType(v string) { + m.Set(field.NewUnderlyingSecurityType(v)) +} + +//SetUnderlyingSecuritySubType sets UnderlyingSecuritySubType, Tag 763 +func (m NoUnderlyings) SetUnderlyingSecuritySubType(v string) { + m.Set(field.NewUnderlyingSecuritySubType(v)) +} + +//SetUnderlyingMaturityMonthYear sets UnderlyingMaturityMonthYear, Tag 313 +func (m NoUnderlyings) SetUnderlyingMaturityMonthYear(v string) { + m.Set(field.NewUnderlyingMaturityMonthYear(v)) +} + +//SetUnderlyingMaturityDate sets UnderlyingMaturityDate, Tag 542 +func (m NoUnderlyings) SetUnderlyingMaturityDate(v string) { + m.Set(field.NewUnderlyingMaturityDate(v)) +} + +//SetUnderlyingCouponPaymentDate sets UnderlyingCouponPaymentDate, Tag 241 +func (m NoUnderlyings) SetUnderlyingCouponPaymentDate(v string) { + m.Set(field.NewUnderlyingCouponPaymentDate(v)) +} + +//SetUnderlyingIssueDate sets UnderlyingIssueDate, Tag 242 +func (m NoUnderlyings) SetUnderlyingIssueDate(v string) { + m.Set(field.NewUnderlyingIssueDate(v)) +} + +//SetUnderlyingRepoCollateralSecurityType sets UnderlyingRepoCollateralSecurityType, Tag 243 +func (m NoUnderlyings) SetUnderlyingRepoCollateralSecurityType(v int) { + m.Set(field.NewUnderlyingRepoCollateralSecurityType(v)) +} + +//SetUnderlyingRepurchaseTerm sets UnderlyingRepurchaseTerm, Tag 244 +func (m NoUnderlyings) SetUnderlyingRepurchaseTerm(v int) { + m.Set(field.NewUnderlyingRepurchaseTerm(v)) +} + +//SetUnderlyingRepurchaseRate sets UnderlyingRepurchaseRate, Tag 245 +func (m NoUnderlyings) SetUnderlyingRepurchaseRate(v float64) { + m.Set(field.NewUnderlyingRepurchaseRate(v)) +} + +//SetUnderlyingFactor sets UnderlyingFactor, Tag 246 +func (m NoUnderlyings) SetUnderlyingFactor(v float64) { + m.Set(field.NewUnderlyingFactor(v)) +} + +//SetUnderlyingCreditRating sets UnderlyingCreditRating, Tag 256 +func (m NoUnderlyings) SetUnderlyingCreditRating(v string) { + m.Set(field.NewUnderlyingCreditRating(v)) +} + +//SetUnderlyingInstrRegistry sets UnderlyingInstrRegistry, Tag 595 +func (m NoUnderlyings) SetUnderlyingInstrRegistry(v string) { + m.Set(field.NewUnderlyingInstrRegistry(v)) +} + +//SetUnderlyingCountryOfIssue sets UnderlyingCountryOfIssue, Tag 592 +func (m NoUnderlyings) SetUnderlyingCountryOfIssue(v string) { + m.Set(field.NewUnderlyingCountryOfIssue(v)) +} + +//SetUnderlyingStateOrProvinceOfIssue sets UnderlyingStateOrProvinceOfIssue, Tag 593 +func (m NoUnderlyings) SetUnderlyingStateOrProvinceOfIssue(v string) { + m.Set(field.NewUnderlyingStateOrProvinceOfIssue(v)) +} + +//SetUnderlyingLocaleOfIssue sets UnderlyingLocaleOfIssue, Tag 594 +func (m NoUnderlyings) SetUnderlyingLocaleOfIssue(v string) { + m.Set(field.NewUnderlyingLocaleOfIssue(v)) +} + +//SetUnderlyingRedemptionDate sets UnderlyingRedemptionDate, Tag 247 +func (m NoUnderlyings) SetUnderlyingRedemptionDate(v string) { + m.Set(field.NewUnderlyingRedemptionDate(v)) +} + +//SetUnderlyingStrikePrice sets UnderlyingStrikePrice, Tag 316 +func (m NoUnderlyings) SetUnderlyingStrikePrice(v float64) { + m.Set(field.NewUnderlyingStrikePrice(v)) +} + +//SetUnderlyingStrikeCurrency sets UnderlyingStrikeCurrency, Tag 941 +func (m NoUnderlyings) SetUnderlyingStrikeCurrency(v string) { + m.Set(field.NewUnderlyingStrikeCurrency(v)) +} + +//SetUnderlyingOptAttribute sets UnderlyingOptAttribute, Tag 317 +func (m NoUnderlyings) SetUnderlyingOptAttribute(v string) { + m.Set(field.NewUnderlyingOptAttribute(v)) +} + +//SetUnderlyingContractMultiplier sets UnderlyingContractMultiplier, Tag 436 +func (m NoUnderlyings) SetUnderlyingContractMultiplier(v float64) { + m.Set(field.NewUnderlyingContractMultiplier(v)) +} + +//SetUnderlyingCouponRate sets UnderlyingCouponRate, Tag 435 +func (m NoUnderlyings) SetUnderlyingCouponRate(v float64) { + m.Set(field.NewUnderlyingCouponRate(v)) +} + +//SetUnderlyingSecurityExchange sets UnderlyingSecurityExchange, Tag 308 +func (m NoUnderlyings) SetUnderlyingSecurityExchange(v string) { + m.Set(field.NewUnderlyingSecurityExchange(v)) +} + +//SetUnderlyingIssuer sets UnderlyingIssuer, Tag 306 +func (m NoUnderlyings) SetUnderlyingIssuer(v string) { + m.Set(field.NewUnderlyingIssuer(v)) +} + +//SetEncodedUnderlyingIssuerLen sets EncodedUnderlyingIssuerLen, Tag 362 +func (m NoUnderlyings) SetEncodedUnderlyingIssuerLen(v int) { + m.Set(field.NewEncodedUnderlyingIssuerLen(v)) +} + +//SetEncodedUnderlyingIssuer sets EncodedUnderlyingIssuer, Tag 363 +func (m NoUnderlyings) SetEncodedUnderlyingIssuer(v string) { + m.Set(field.NewEncodedUnderlyingIssuer(v)) +} + +//SetUnderlyingSecurityDesc sets UnderlyingSecurityDesc, Tag 307 +func (m NoUnderlyings) SetUnderlyingSecurityDesc(v string) { + m.Set(field.NewUnderlyingSecurityDesc(v)) +} + +//SetEncodedUnderlyingSecurityDescLen sets EncodedUnderlyingSecurityDescLen, Tag 364 +func (m NoUnderlyings) SetEncodedUnderlyingSecurityDescLen(v int) { + m.Set(field.NewEncodedUnderlyingSecurityDescLen(v)) +} + +//SetEncodedUnderlyingSecurityDesc sets EncodedUnderlyingSecurityDesc, Tag 365 +func (m NoUnderlyings) SetEncodedUnderlyingSecurityDesc(v string) { + m.Set(field.NewEncodedUnderlyingSecurityDesc(v)) +} + +//SetUnderlyingCPProgram sets UnderlyingCPProgram, Tag 877 +func (m NoUnderlyings) SetUnderlyingCPProgram(v string) { + m.Set(field.NewUnderlyingCPProgram(v)) +} + +//SetUnderlyingCPRegType sets UnderlyingCPRegType, Tag 878 +func (m NoUnderlyings) SetUnderlyingCPRegType(v string) { + m.Set(field.NewUnderlyingCPRegType(v)) +} + +//SetUnderlyingCurrency sets UnderlyingCurrency, Tag 318 +func (m NoUnderlyings) SetUnderlyingCurrency(v string) { + m.Set(field.NewUnderlyingCurrency(v)) +} + +//SetUnderlyingQty sets UnderlyingQty, Tag 879 +func (m NoUnderlyings) SetUnderlyingQty(v float64) { + m.Set(field.NewUnderlyingQty(v)) +} + +//SetUnderlyingPx sets UnderlyingPx, Tag 810 +func (m NoUnderlyings) SetUnderlyingPx(v float64) { + m.Set(field.NewUnderlyingPx(v)) +} + +//SetUnderlyingDirtyPrice sets UnderlyingDirtyPrice, Tag 882 +func (m NoUnderlyings) SetUnderlyingDirtyPrice(v float64) { + m.Set(field.NewUnderlyingDirtyPrice(v)) +} + +//SetUnderlyingEndPrice sets UnderlyingEndPrice, Tag 883 +func (m NoUnderlyings) SetUnderlyingEndPrice(v float64) { + m.Set(field.NewUnderlyingEndPrice(v)) +} + +//SetUnderlyingStartValue sets UnderlyingStartValue, Tag 884 +func (m NoUnderlyings) SetUnderlyingStartValue(v float64) { + m.Set(field.NewUnderlyingStartValue(v)) +} + +//SetUnderlyingCurrentValue sets UnderlyingCurrentValue, Tag 885 +func (m NoUnderlyings) SetUnderlyingCurrentValue(v float64) { + m.Set(field.NewUnderlyingCurrentValue(v)) +} + +//SetUnderlyingEndValue sets UnderlyingEndValue, Tag 886 +func (m NoUnderlyings) SetUnderlyingEndValue(v float64) { + m.Set(field.NewUnderlyingEndValue(v)) +} + +//SetNoUnderlyingStips sets NoUnderlyingStips, Tag 887 +func (m NoUnderlyings) SetNoUnderlyingStips(f NoUnderlyingStipsRepeatingGroup) { + m.SetGroup(f) +} + +//SetUnderlyingAllocationPercent sets UnderlyingAllocationPercent, Tag 972 +func (m NoUnderlyings) SetUnderlyingAllocationPercent(v float64) { + m.Set(field.NewUnderlyingAllocationPercent(v)) +} + +//SetUnderlyingSettlementType sets UnderlyingSettlementType, Tag 975 +func (m NoUnderlyings) SetUnderlyingSettlementType(v int) { + m.Set(field.NewUnderlyingSettlementType(v)) +} + +//SetUnderlyingCashAmount sets UnderlyingCashAmount, Tag 973 +func (m NoUnderlyings) SetUnderlyingCashAmount(v float64) { + m.Set(field.NewUnderlyingCashAmount(v)) +} + +//SetUnderlyingCashType sets UnderlyingCashType, Tag 974 +func (m NoUnderlyings) SetUnderlyingCashType(v string) { + m.Set(field.NewUnderlyingCashType(v)) +} + +//SetUnderlyingUnitOfMeasure sets UnderlyingUnitOfMeasure, Tag 998 +func (m NoUnderlyings) SetUnderlyingUnitOfMeasure(v string) { + m.Set(field.NewUnderlyingUnitOfMeasure(v)) +} + +//SetUnderlyingTimeUnit sets UnderlyingTimeUnit, Tag 1000 +func (m NoUnderlyings) SetUnderlyingTimeUnit(v string) { + m.Set(field.NewUnderlyingTimeUnit(v)) +} + +//SetUnderlyingCapValue sets UnderlyingCapValue, Tag 1038 +func (m NoUnderlyings) SetUnderlyingCapValue(v float64) { + m.Set(field.NewUnderlyingCapValue(v)) +} + +//SetNoUndlyInstrumentParties sets NoUndlyInstrumentParties, Tag 1058 +func (m NoUnderlyings) SetNoUndlyInstrumentParties(f NoUndlyInstrumentPartiesRepeatingGroup) { + m.SetGroup(f) +} + +//SetUnderlyingSettlMethod sets UnderlyingSettlMethod, Tag 1039 +func (m NoUnderlyings) SetUnderlyingSettlMethod(v string) { + m.Set(field.NewUnderlyingSettlMethod(v)) +} + +//SetUnderlyingAdjustedQuantity sets UnderlyingAdjustedQuantity, Tag 1044 +func (m NoUnderlyings) SetUnderlyingAdjustedQuantity(v float64) { + m.Set(field.NewUnderlyingAdjustedQuantity(v)) +} + +//SetUnderlyingFXRate sets UnderlyingFXRate, Tag 1045 +func (m NoUnderlyings) SetUnderlyingFXRate(v float64) { + m.Set(field.NewUnderlyingFXRate(v)) +} + +//SetUnderlyingFXRateCalc sets UnderlyingFXRateCalc, Tag 1046 +func (m NoUnderlyings) SetUnderlyingFXRateCalc(v string) { + m.Set(field.NewUnderlyingFXRateCalc(v)) +} + +//GetUnderlyingSymbol gets UnderlyingSymbol, Tag 311 +func (m NoUnderlyings) GetUnderlyingSymbol() (f field.UnderlyingSymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSymbolSfx gets UnderlyingSymbolSfx, Tag 312 +func (m NoUnderlyings) GetUnderlyingSymbolSfx() (f field.UnderlyingSymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityID gets UnderlyingSecurityID, Tag 309 +func (m NoUnderlyings) GetUnderlyingSecurityID() (f field.UnderlyingSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityIDSource gets UnderlyingSecurityIDSource, Tag 305 +func (m NoUnderlyings) GetUnderlyingSecurityIDSource() (f field.UnderlyingSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyingSecurityAltID gets NoUnderlyingSecurityAltID, Tag 457 +func (m NoUnderlyings) GetNoUnderlyingSecurityAltID() (NoUnderlyingSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetUnderlyingProduct gets UnderlyingProduct, Tag 462 +func (m NoUnderlyings) GetUnderlyingProduct() (f field.UnderlyingProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCFICode gets UnderlyingCFICode, Tag 463 +func (m NoUnderlyings) GetUnderlyingCFICode() (f field.UnderlyingCFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityType gets UnderlyingSecurityType, Tag 310 +func (m NoUnderlyings) GetUnderlyingSecurityType() (f field.UnderlyingSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecuritySubType gets UnderlyingSecuritySubType, Tag 763 +func (m NoUnderlyings) GetUnderlyingSecuritySubType() (f field.UnderlyingSecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingMaturityMonthYear gets UnderlyingMaturityMonthYear, Tag 313 +func (m NoUnderlyings) GetUnderlyingMaturityMonthYear() (f field.UnderlyingMaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingMaturityDate gets UnderlyingMaturityDate, Tag 542 +func (m NoUnderlyings) GetUnderlyingMaturityDate() (f field.UnderlyingMaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCouponPaymentDate gets UnderlyingCouponPaymentDate, Tag 241 +func (m NoUnderlyings) GetUnderlyingCouponPaymentDate() (f field.UnderlyingCouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingIssueDate gets UnderlyingIssueDate, Tag 242 +func (m NoUnderlyings) GetUnderlyingIssueDate() (f field.UnderlyingIssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepoCollateralSecurityType gets UnderlyingRepoCollateralSecurityType, Tag 243 +func (m NoUnderlyings) GetUnderlyingRepoCollateralSecurityType() (f field.UnderlyingRepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepurchaseTerm gets UnderlyingRepurchaseTerm, Tag 244 +func (m NoUnderlyings) GetUnderlyingRepurchaseTerm() (f field.UnderlyingRepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepurchaseRate gets UnderlyingRepurchaseRate, Tag 245 +func (m NoUnderlyings) GetUnderlyingRepurchaseRate() (f field.UnderlyingRepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingFactor gets UnderlyingFactor, Tag 246 +func (m NoUnderlyings) GetUnderlyingFactor() (f field.UnderlyingFactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCreditRating gets UnderlyingCreditRating, Tag 256 +func (m NoUnderlyings) GetUnderlyingCreditRating() (f field.UnderlyingCreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingInstrRegistry gets UnderlyingInstrRegistry, Tag 595 +func (m NoUnderlyings) GetUnderlyingInstrRegistry() (f field.UnderlyingInstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCountryOfIssue gets UnderlyingCountryOfIssue, Tag 592 +func (m NoUnderlyings) GetUnderlyingCountryOfIssue() (f field.UnderlyingCountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStateOrProvinceOfIssue gets UnderlyingStateOrProvinceOfIssue, Tag 593 +func (m NoUnderlyings) GetUnderlyingStateOrProvinceOfIssue() (f field.UnderlyingStateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingLocaleOfIssue gets UnderlyingLocaleOfIssue, Tag 594 +func (m NoUnderlyings) GetUnderlyingLocaleOfIssue() (f field.UnderlyingLocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRedemptionDate gets UnderlyingRedemptionDate, Tag 247 +func (m NoUnderlyings) GetUnderlyingRedemptionDate() (f field.UnderlyingRedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStrikePrice gets UnderlyingStrikePrice, Tag 316 +func (m NoUnderlyings) GetUnderlyingStrikePrice() (f field.UnderlyingStrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStrikeCurrency gets UnderlyingStrikeCurrency, Tag 941 +func (m NoUnderlyings) GetUnderlyingStrikeCurrency() (f field.UnderlyingStrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingOptAttribute gets UnderlyingOptAttribute, Tag 317 +func (m NoUnderlyings) GetUnderlyingOptAttribute() (f field.UnderlyingOptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingContractMultiplier gets UnderlyingContractMultiplier, Tag 436 +func (m NoUnderlyings) GetUnderlyingContractMultiplier() (f field.UnderlyingContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCouponRate gets UnderlyingCouponRate, Tag 435 +func (m NoUnderlyings) GetUnderlyingCouponRate() (f field.UnderlyingCouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityExchange gets UnderlyingSecurityExchange, Tag 308 +func (m NoUnderlyings) GetUnderlyingSecurityExchange() (f field.UnderlyingSecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingIssuer gets UnderlyingIssuer, Tag 306 +func (m NoUnderlyings) GetUnderlyingIssuer() (f field.UnderlyingIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingIssuerLen gets EncodedUnderlyingIssuerLen, Tag 362 +func (m NoUnderlyings) GetEncodedUnderlyingIssuerLen() (f field.EncodedUnderlyingIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingIssuer gets EncodedUnderlyingIssuer, Tag 363 +func (m NoUnderlyings) GetEncodedUnderlyingIssuer() (f field.EncodedUnderlyingIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityDesc gets UnderlyingSecurityDesc, Tag 307 +func (m NoUnderlyings) GetUnderlyingSecurityDesc() (f field.UnderlyingSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingSecurityDescLen gets EncodedUnderlyingSecurityDescLen, Tag 364 +func (m NoUnderlyings) GetEncodedUnderlyingSecurityDescLen() (f field.EncodedUnderlyingSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingSecurityDesc gets EncodedUnderlyingSecurityDesc, Tag 365 +func (m NoUnderlyings) GetEncodedUnderlyingSecurityDesc() (f field.EncodedUnderlyingSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCPProgram gets UnderlyingCPProgram, Tag 877 +func (m NoUnderlyings) GetUnderlyingCPProgram() (f field.UnderlyingCPProgramField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCPRegType gets UnderlyingCPRegType, Tag 878 +func (m NoUnderlyings) GetUnderlyingCPRegType() (f field.UnderlyingCPRegTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCurrency gets UnderlyingCurrency, Tag 318 +func (m NoUnderlyings) GetUnderlyingCurrency() (f field.UnderlyingCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingQty gets UnderlyingQty, Tag 879 +func (m NoUnderlyings) GetUnderlyingQty() (f field.UnderlyingQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingPx gets UnderlyingPx, Tag 810 +func (m NoUnderlyings) GetUnderlyingPx() (f field.UnderlyingPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingDirtyPrice gets UnderlyingDirtyPrice, Tag 882 +func (m NoUnderlyings) GetUnderlyingDirtyPrice() (f field.UnderlyingDirtyPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingEndPrice gets UnderlyingEndPrice, Tag 883 +func (m NoUnderlyings) GetUnderlyingEndPrice() (f field.UnderlyingEndPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStartValue gets UnderlyingStartValue, Tag 884 +func (m NoUnderlyings) GetUnderlyingStartValue() (f field.UnderlyingStartValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCurrentValue gets UnderlyingCurrentValue, Tag 885 +func (m NoUnderlyings) GetUnderlyingCurrentValue() (f field.UnderlyingCurrentValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingEndValue gets UnderlyingEndValue, Tag 886 +func (m NoUnderlyings) GetUnderlyingEndValue() (f field.UnderlyingEndValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyingStips gets NoUnderlyingStips, Tag 887 +func (m NoUnderlyings) GetNoUnderlyingStips() (NoUnderlyingStipsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingStipsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetUnderlyingAllocationPercent gets UnderlyingAllocationPercent, Tag 972 +func (m NoUnderlyings) GetUnderlyingAllocationPercent() (f field.UnderlyingAllocationPercentField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSettlementType gets UnderlyingSettlementType, Tag 975 +func (m NoUnderlyings) GetUnderlyingSettlementType() (f field.UnderlyingSettlementTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCashAmount gets UnderlyingCashAmount, Tag 973 +func (m NoUnderlyings) GetUnderlyingCashAmount() (f field.UnderlyingCashAmountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCashType gets UnderlyingCashType, Tag 974 +func (m NoUnderlyings) GetUnderlyingCashType() (f field.UnderlyingCashTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingUnitOfMeasure gets UnderlyingUnitOfMeasure, Tag 998 +func (m NoUnderlyings) GetUnderlyingUnitOfMeasure() (f field.UnderlyingUnitOfMeasureField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingTimeUnit gets UnderlyingTimeUnit, Tag 1000 +func (m NoUnderlyings) GetUnderlyingTimeUnit() (f field.UnderlyingTimeUnitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCapValue gets UnderlyingCapValue, Tag 1038 +func (m NoUnderlyings) GetUnderlyingCapValue() (f field.UnderlyingCapValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUndlyInstrumentParties gets NoUndlyInstrumentParties, Tag 1058 +func (m NoUnderlyings) GetNoUndlyInstrumentParties() (NoUndlyInstrumentPartiesRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUndlyInstrumentPartiesRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetUnderlyingSettlMethod gets UnderlyingSettlMethod, Tag 1039 +func (m NoUnderlyings) GetUnderlyingSettlMethod() (f field.UnderlyingSettlMethodField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingAdjustedQuantity gets UnderlyingAdjustedQuantity, Tag 1044 +func (m NoUnderlyings) GetUnderlyingAdjustedQuantity() (f field.UnderlyingAdjustedQuantityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingFXRate gets UnderlyingFXRate, Tag 1045 +func (m NoUnderlyings) GetUnderlyingFXRate() (f field.UnderlyingFXRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingFXRateCalc gets UnderlyingFXRateCalc, Tag 1046 +func (m NoUnderlyings) GetUnderlyingFXRateCalc() (f field.UnderlyingFXRateCalcField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingSymbol returns true if UnderlyingSymbol is present, Tag 311 +func (m NoUnderlyings) HasUnderlyingSymbol() bool { + return m.Has(tag.UnderlyingSymbol) +} + +//HasUnderlyingSymbolSfx returns true if UnderlyingSymbolSfx is present, Tag 312 +func (m NoUnderlyings) HasUnderlyingSymbolSfx() bool { + return m.Has(tag.UnderlyingSymbolSfx) +} + +//HasUnderlyingSecurityID returns true if UnderlyingSecurityID is present, Tag 309 +func (m NoUnderlyings) HasUnderlyingSecurityID() bool { + return m.Has(tag.UnderlyingSecurityID) +} + +//HasUnderlyingSecurityIDSource returns true if UnderlyingSecurityIDSource is present, Tag 305 +func (m NoUnderlyings) HasUnderlyingSecurityIDSource() bool { + return m.Has(tag.UnderlyingSecurityIDSource) +} + +//HasNoUnderlyingSecurityAltID returns true if NoUnderlyingSecurityAltID is present, Tag 457 +func (m NoUnderlyings) HasNoUnderlyingSecurityAltID() bool { + return m.Has(tag.NoUnderlyingSecurityAltID) +} + +//HasUnderlyingProduct returns true if UnderlyingProduct is present, Tag 462 +func (m NoUnderlyings) HasUnderlyingProduct() bool { + return m.Has(tag.UnderlyingProduct) +} + +//HasUnderlyingCFICode returns true if UnderlyingCFICode is present, Tag 463 +func (m NoUnderlyings) HasUnderlyingCFICode() bool { + return m.Has(tag.UnderlyingCFICode) +} + +//HasUnderlyingSecurityType returns true if UnderlyingSecurityType is present, Tag 310 +func (m NoUnderlyings) HasUnderlyingSecurityType() bool { + return m.Has(tag.UnderlyingSecurityType) +} + +//HasUnderlyingSecuritySubType returns true if UnderlyingSecuritySubType is present, Tag 763 +func (m NoUnderlyings) HasUnderlyingSecuritySubType() bool { + return m.Has(tag.UnderlyingSecuritySubType) +} + +//HasUnderlyingMaturityMonthYear returns true if UnderlyingMaturityMonthYear is present, Tag 313 +func (m NoUnderlyings) HasUnderlyingMaturityMonthYear() bool { + return m.Has(tag.UnderlyingMaturityMonthYear) +} + +//HasUnderlyingMaturityDate returns true if UnderlyingMaturityDate is present, Tag 542 +func (m NoUnderlyings) HasUnderlyingMaturityDate() bool { + return m.Has(tag.UnderlyingMaturityDate) +} + +//HasUnderlyingCouponPaymentDate returns true if UnderlyingCouponPaymentDate is present, Tag 241 +func (m NoUnderlyings) HasUnderlyingCouponPaymentDate() bool { + return m.Has(tag.UnderlyingCouponPaymentDate) +} + +//HasUnderlyingIssueDate returns true if UnderlyingIssueDate is present, Tag 242 +func (m NoUnderlyings) HasUnderlyingIssueDate() bool { + return m.Has(tag.UnderlyingIssueDate) +} + +//HasUnderlyingRepoCollateralSecurityType returns true if UnderlyingRepoCollateralSecurityType is present, Tag 243 +func (m NoUnderlyings) HasUnderlyingRepoCollateralSecurityType() bool { + return m.Has(tag.UnderlyingRepoCollateralSecurityType) +} + +//HasUnderlyingRepurchaseTerm returns true if UnderlyingRepurchaseTerm is present, Tag 244 +func (m NoUnderlyings) HasUnderlyingRepurchaseTerm() bool { + return m.Has(tag.UnderlyingRepurchaseTerm) +} + +//HasUnderlyingRepurchaseRate returns true if UnderlyingRepurchaseRate is present, Tag 245 +func (m NoUnderlyings) HasUnderlyingRepurchaseRate() bool { + return m.Has(tag.UnderlyingRepurchaseRate) +} + +//HasUnderlyingFactor returns true if UnderlyingFactor is present, Tag 246 +func (m NoUnderlyings) HasUnderlyingFactor() bool { + return m.Has(tag.UnderlyingFactor) +} + +//HasUnderlyingCreditRating returns true if UnderlyingCreditRating is present, Tag 256 +func (m NoUnderlyings) HasUnderlyingCreditRating() bool { + return m.Has(tag.UnderlyingCreditRating) +} + +//HasUnderlyingInstrRegistry returns true if UnderlyingInstrRegistry is present, Tag 595 +func (m NoUnderlyings) HasUnderlyingInstrRegistry() bool { + return m.Has(tag.UnderlyingInstrRegistry) +} + +//HasUnderlyingCountryOfIssue returns true if UnderlyingCountryOfIssue is present, Tag 592 +func (m NoUnderlyings) HasUnderlyingCountryOfIssue() bool { + return m.Has(tag.UnderlyingCountryOfIssue) +} + +//HasUnderlyingStateOrProvinceOfIssue returns true if UnderlyingStateOrProvinceOfIssue is present, Tag 593 +func (m NoUnderlyings) HasUnderlyingStateOrProvinceOfIssue() bool { + return m.Has(tag.UnderlyingStateOrProvinceOfIssue) +} + +//HasUnderlyingLocaleOfIssue returns true if UnderlyingLocaleOfIssue is present, Tag 594 +func (m NoUnderlyings) HasUnderlyingLocaleOfIssue() bool { + return m.Has(tag.UnderlyingLocaleOfIssue) +} + +//HasUnderlyingRedemptionDate returns true if UnderlyingRedemptionDate is present, Tag 247 +func (m NoUnderlyings) HasUnderlyingRedemptionDate() bool { + return m.Has(tag.UnderlyingRedemptionDate) +} + +//HasUnderlyingStrikePrice returns true if UnderlyingStrikePrice is present, Tag 316 +func (m NoUnderlyings) HasUnderlyingStrikePrice() bool { + return m.Has(tag.UnderlyingStrikePrice) +} + +//HasUnderlyingStrikeCurrency returns true if UnderlyingStrikeCurrency is present, Tag 941 +func (m NoUnderlyings) HasUnderlyingStrikeCurrency() bool { + return m.Has(tag.UnderlyingStrikeCurrency) +} + +//HasUnderlyingOptAttribute returns true if UnderlyingOptAttribute is present, Tag 317 +func (m NoUnderlyings) HasUnderlyingOptAttribute() bool { + return m.Has(tag.UnderlyingOptAttribute) +} + +//HasUnderlyingContractMultiplier returns true if UnderlyingContractMultiplier is present, Tag 436 +func (m NoUnderlyings) HasUnderlyingContractMultiplier() bool { + return m.Has(tag.UnderlyingContractMultiplier) +} + +//HasUnderlyingCouponRate returns true if UnderlyingCouponRate is present, Tag 435 +func (m NoUnderlyings) HasUnderlyingCouponRate() bool { + return m.Has(tag.UnderlyingCouponRate) +} + +//HasUnderlyingSecurityExchange returns true if UnderlyingSecurityExchange is present, Tag 308 +func (m NoUnderlyings) HasUnderlyingSecurityExchange() bool { + return m.Has(tag.UnderlyingSecurityExchange) +} + +//HasUnderlyingIssuer returns true if UnderlyingIssuer is present, Tag 306 +func (m NoUnderlyings) HasUnderlyingIssuer() bool { + return m.Has(tag.UnderlyingIssuer) +} + +//HasEncodedUnderlyingIssuerLen returns true if EncodedUnderlyingIssuerLen is present, Tag 362 +func (m NoUnderlyings) HasEncodedUnderlyingIssuerLen() bool { + return m.Has(tag.EncodedUnderlyingIssuerLen) +} + +//HasEncodedUnderlyingIssuer returns true if EncodedUnderlyingIssuer is present, Tag 363 +func (m NoUnderlyings) HasEncodedUnderlyingIssuer() bool { + return m.Has(tag.EncodedUnderlyingIssuer) +} + +//HasUnderlyingSecurityDesc returns true if UnderlyingSecurityDesc is present, Tag 307 +func (m NoUnderlyings) HasUnderlyingSecurityDesc() bool { + return m.Has(tag.UnderlyingSecurityDesc) +} + +//HasEncodedUnderlyingSecurityDescLen returns true if EncodedUnderlyingSecurityDescLen is present, Tag 364 +func (m NoUnderlyings) HasEncodedUnderlyingSecurityDescLen() bool { + return m.Has(tag.EncodedUnderlyingSecurityDescLen) +} + +//HasEncodedUnderlyingSecurityDesc returns true if EncodedUnderlyingSecurityDesc is present, Tag 365 +func (m NoUnderlyings) HasEncodedUnderlyingSecurityDesc() bool { + return m.Has(tag.EncodedUnderlyingSecurityDesc) +} + +//HasUnderlyingCPProgram returns true if UnderlyingCPProgram is present, Tag 877 +func (m NoUnderlyings) HasUnderlyingCPProgram() bool { + return m.Has(tag.UnderlyingCPProgram) +} + +//HasUnderlyingCPRegType returns true if UnderlyingCPRegType is present, Tag 878 +func (m NoUnderlyings) HasUnderlyingCPRegType() bool { + return m.Has(tag.UnderlyingCPRegType) +} + +//HasUnderlyingCurrency returns true if UnderlyingCurrency is present, Tag 318 +func (m NoUnderlyings) HasUnderlyingCurrency() bool { + return m.Has(tag.UnderlyingCurrency) +} + +//HasUnderlyingQty returns true if UnderlyingQty is present, Tag 879 +func (m NoUnderlyings) HasUnderlyingQty() bool { + return m.Has(tag.UnderlyingQty) +} + +//HasUnderlyingPx returns true if UnderlyingPx is present, Tag 810 +func (m NoUnderlyings) HasUnderlyingPx() bool { + return m.Has(tag.UnderlyingPx) +} + +//HasUnderlyingDirtyPrice returns true if UnderlyingDirtyPrice is present, Tag 882 +func (m NoUnderlyings) HasUnderlyingDirtyPrice() bool { + return m.Has(tag.UnderlyingDirtyPrice) +} + +//HasUnderlyingEndPrice returns true if UnderlyingEndPrice is present, Tag 883 +func (m NoUnderlyings) HasUnderlyingEndPrice() bool { + return m.Has(tag.UnderlyingEndPrice) +} + +//HasUnderlyingStartValue returns true if UnderlyingStartValue is present, Tag 884 +func (m NoUnderlyings) HasUnderlyingStartValue() bool { + return m.Has(tag.UnderlyingStartValue) +} + +//HasUnderlyingCurrentValue returns true if UnderlyingCurrentValue is present, Tag 885 +func (m NoUnderlyings) HasUnderlyingCurrentValue() bool { + return m.Has(tag.UnderlyingCurrentValue) +} + +//HasUnderlyingEndValue returns true if UnderlyingEndValue is present, Tag 886 +func (m NoUnderlyings) HasUnderlyingEndValue() bool { + return m.Has(tag.UnderlyingEndValue) +} + +//HasNoUnderlyingStips returns true if NoUnderlyingStips is present, Tag 887 +func (m NoUnderlyings) HasNoUnderlyingStips() bool { + return m.Has(tag.NoUnderlyingStips) +} + +//HasUnderlyingAllocationPercent returns true if UnderlyingAllocationPercent is present, Tag 972 +func (m NoUnderlyings) HasUnderlyingAllocationPercent() bool { + return m.Has(tag.UnderlyingAllocationPercent) +} + +//HasUnderlyingSettlementType returns true if UnderlyingSettlementType is present, Tag 975 +func (m NoUnderlyings) HasUnderlyingSettlementType() bool { + return m.Has(tag.UnderlyingSettlementType) +} + +//HasUnderlyingCashAmount returns true if UnderlyingCashAmount is present, Tag 973 +func (m NoUnderlyings) HasUnderlyingCashAmount() bool { + return m.Has(tag.UnderlyingCashAmount) +} + +//HasUnderlyingCashType returns true if UnderlyingCashType is present, Tag 974 +func (m NoUnderlyings) HasUnderlyingCashType() bool { + return m.Has(tag.UnderlyingCashType) +} + +//HasUnderlyingUnitOfMeasure returns true if UnderlyingUnitOfMeasure is present, Tag 998 +func (m NoUnderlyings) HasUnderlyingUnitOfMeasure() bool { + return m.Has(tag.UnderlyingUnitOfMeasure) +} + +//HasUnderlyingTimeUnit returns true if UnderlyingTimeUnit is present, Tag 1000 +func (m NoUnderlyings) HasUnderlyingTimeUnit() bool { + return m.Has(tag.UnderlyingTimeUnit) +} + +//HasUnderlyingCapValue returns true if UnderlyingCapValue is present, Tag 1038 +func (m NoUnderlyings) HasUnderlyingCapValue() bool { + return m.Has(tag.UnderlyingCapValue) +} + +//HasNoUndlyInstrumentParties returns true if NoUndlyInstrumentParties is present, Tag 1058 +func (m NoUnderlyings) HasNoUndlyInstrumentParties() bool { + return m.Has(tag.NoUndlyInstrumentParties) +} + +//HasUnderlyingSettlMethod returns true if UnderlyingSettlMethod is present, Tag 1039 +func (m NoUnderlyings) HasUnderlyingSettlMethod() bool { + return m.Has(tag.UnderlyingSettlMethod) +} + +//HasUnderlyingAdjustedQuantity returns true if UnderlyingAdjustedQuantity is present, Tag 1044 +func (m NoUnderlyings) HasUnderlyingAdjustedQuantity() bool { + return m.Has(tag.UnderlyingAdjustedQuantity) +} + +//HasUnderlyingFXRate returns true if UnderlyingFXRate is present, Tag 1045 +func (m NoUnderlyings) HasUnderlyingFXRate() bool { + return m.Has(tag.UnderlyingFXRate) +} + +//HasUnderlyingFXRateCalc returns true if UnderlyingFXRateCalc is present, Tag 1046 +func (m NoUnderlyings) HasUnderlyingFXRateCalc() bool { + return m.Has(tag.UnderlyingFXRateCalc) +} + +//NoUnderlyingSecurityAltID is a repeating group element, Tag 457 +type NoUnderlyingSecurityAltID struct { + quickfix.Group +} + +//SetUnderlyingSecurityAltID sets UnderlyingSecurityAltID, Tag 458 +func (m NoUnderlyingSecurityAltID) SetUnderlyingSecurityAltID(v string) { + m.Set(field.NewUnderlyingSecurityAltID(v)) +} + +//SetUnderlyingSecurityAltIDSource sets UnderlyingSecurityAltIDSource, Tag 459 +func (m NoUnderlyingSecurityAltID) SetUnderlyingSecurityAltIDSource(v string) { + m.Set(field.NewUnderlyingSecurityAltIDSource(v)) +} + +//GetUnderlyingSecurityAltID gets UnderlyingSecurityAltID, Tag 458 +func (m NoUnderlyingSecurityAltID) GetUnderlyingSecurityAltID() (f field.UnderlyingSecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityAltIDSource gets UnderlyingSecurityAltIDSource, Tag 459 +func (m NoUnderlyingSecurityAltID) GetUnderlyingSecurityAltIDSource() (f field.UnderlyingSecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingSecurityAltID returns true if UnderlyingSecurityAltID is present, Tag 458 +func (m NoUnderlyingSecurityAltID) HasUnderlyingSecurityAltID() bool { + return m.Has(tag.UnderlyingSecurityAltID) +} + +//HasUnderlyingSecurityAltIDSource returns true if UnderlyingSecurityAltIDSource is present, Tag 459 +func (m NoUnderlyingSecurityAltID) HasUnderlyingSecurityAltIDSource() bool { + return m.Has(tag.UnderlyingSecurityAltIDSource) +} + +//NoUnderlyingSecurityAltIDRepeatingGroup is a repeating group, Tag 457 +type NoUnderlyingSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingSecurityAltIDRepeatingGroup returns an initialized, NoUnderlyingSecurityAltIDRepeatingGroup +func NewNoUnderlyingSecurityAltIDRepeatingGroup() NoUnderlyingSecurityAltIDRepeatingGroup { + return NoUnderlyingSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyingSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingSecurityAltID), quickfix.GroupElement(tag.UnderlyingSecurityAltIDSource)})} +} + +//Add create and append a new NoUnderlyingSecurityAltID to this group +func (m NoUnderlyingSecurityAltIDRepeatingGroup) Add() NoUnderlyingSecurityAltID { + g := m.RepeatingGroup.Add() + return NoUnderlyingSecurityAltID{g} +} + +//Get returns the ith NoUnderlyingSecurityAltID in the NoUnderlyingSecurityAltIDRepeatinGroup +func (m NoUnderlyingSecurityAltIDRepeatingGroup) Get(i int) NoUnderlyingSecurityAltID { + return NoUnderlyingSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyingStips is a repeating group element, Tag 887 +type NoUnderlyingStips struct { + quickfix.Group +} + +//SetUnderlyingStipType sets UnderlyingStipType, Tag 888 +func (m NoUnderlyingStips) SetUnderlyingStipType(v string) { + m.Set(field.NewUnderlyingStipType(v)) +} + +//SetUnderlyingStipValue sets UnderlyingStipValue, Tag 889 +func (m NoUnderlyingStips) SetUnderlyingStipValue(v string) { + m.Set(field.NewUnderlyingStipValue(v)) +} + +//GetUnderlyingStipType gets UnderlyingStipType, Tag 888 +func (m NoUnderlyingStips) GetUnderlyingStipType() (f field.UnderlyingStipTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStipValue gets UnderlyingStipValue, Tag 889 +func (m NoUnderlyingStips) GetUnderlyingStipValue() (f field.UnderlyingStipValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingStipType returns true if UnderlyingStipType is present, Tag 888 +func (m NoUnderlyingStips) HasUnderlyingStipType() bool { + return m.Has(tag.UnderlyingStipType) +} + +//HasUnderlyingStipValue returns true if UnderlyingStipValue is present, Tag 889 +func (m NoUnderlyingStips) HasUnderlyingStipValue() bool { + return m.Has(tag.UnderlyingStipValue) +} + +//NoUnderlyingStipsRepeatingGroup is a repeating group, Tag 887 +type NoUnderlyingStipsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingStipsRepeatingGroup returns an initialized, NoUnderlyingStipsRepeatingGroup +func NewNoUnderlyingStipsRepeatingGroup() NoUnderlyingStipsRepeatingGroup { + return NoUnderlyingStipsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyingStips, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingStipType), quickfix.GroupElement(tag.UnderlyingStipValue)})} +} + +//Add create and append a new NoUnderlyingStips to this group +func (m NoUnderlyingStipsRepeatingGroup) Add() NoUnderlyingStips { + g := m.RepeatingGroup.Add() + return NoUnderlyingStips{g} +} + +//Get returns the ith NoUnderlyingStips in the NoUnderlyingStipsRepeatinGroup +func (m NoUnderlyingStipsRepeatingGroup) Get(i int) NoUnderlyingStips { + return NoUnderlyingStips{m.RepeatingGroup.Get(i)} +} + +//NoUndlyInstrumentParties is a repeating group element, Tag 1058 +type NoUndlyInstrumentParties struct { + quickfix.Group +} + +//SetUndlyInstrumentPartyID sets UndlyInstrumentPartyID, Tag 1059 +func (m NoUndlyInstrumentParties) SetUndlyInstrumentPartyID(v string) { + m.Set(field.NewUndlyInstrumentPartyID(v)) +} + +//SetUndlyInstrumentPartyIDSource sets UndlyInstrumentPartyIDSource, Tag 1060 +func (m NoUndlyInstrumentParties) SetUndlyInstrumentPartyIDSource(v string) { + m.Set(field.NewUndlyInstrumentPartyIDSource(v)) +} + +//SetUndlyInstrumentPartyRole sets UndlyInstrumentPartyRole, Tag 1061 +func (m NoUndlyInstrumentParties) SetUndlyInstrumentPartyRole(v int) { + m.Set(field.NewUndlyInstrumentPartyRole(v)) +} + +//SetNoUndlyInstrumentPartySubIDs sets NoUndlyInstrumentPartySubIDs, Tag 1062 +func (m NoUndlyInstrumentParties) SetNoUndlyInstrumentPartySubIDs(f NoUndlyInstrumentPartySubIDsRepeatingGroup) { + m.SetGroup(f) +} + +//GetUndlyInstrumentPartyID gets UndlyInstrumentPartyID, Tag 1059 +func (m NoUndlyInstrumentParties) GetUndlyInstrumentPartyID() (f field.UndlyInstrumentPartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUndlyInstrumentPartyIDSource gets UndlyInstrumentPartyIDSource, Tag 1060 +func (m NoUndlyInstrumentParties) GetUndlyInstrumentPartyIDSource() (f field.UndlyInstrumentPartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUndlyInstrumentPartyRole gets UndlyInstrumentPartyRole, Tag 1061 +func (m NoUndlyInstrumentParties) GetUndlyInstrumentPartyRole() (f field.UndlyInstrumentPartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUndlyInstrumentPartySubIDs gets NoUndlyInstrumentPartySubIDs, Tag 1062 +func (m NoUndlyInstrumentParties) GetNoUndlyInstrumentPartySubIDs() (NoUndlyInstrumentPartySubIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUndlyInstrumentPartySubIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasUndlyInstrumentPartyID returns true if UndlyInstrumentPartyID is present, Tag 1059 +func (m NoUndlyInstrumentParties) HasUndlyInstrumentPartyID() bool { + return m.Has(tag.UndlyInstrumentPartyID) +} + +//HasUndlyInstrumentPartyIDSource returns true if UndlyInstrumentPartyIDSource is present, Tag 1060 +func (m NoUndlyInstrumentParties) HasUndlyInstrumentPartyIDSource() bool { + return m.Has(tag.UndlyInstrumentPartyIDSource) +} + +//HasUndlyInstrumentPartyRole returns true if UndlyInstrumentPartyRole is present, Tag 1061 +func (m NoUndlyInstrumentParties) HasUndlyInstrumentPartyRole() bool { + return m.Has(tag.UndlyInstrumentPartyRole) +} + +//HasNoUndlyInstrumentPartySubIDs returns true if NoUndlyInstrumentPartySubIDs is present, Tag 1062 +func (m NoUndlyInstrumentParties) HasNoUndlyInstrumentPartySubIDs() bool { + return m.Has(tag.NoUndlyInstrumentPartySubIDs) +} + +//NoUndlyInstrumentPartySubIDs is a repeating group element, Tag 1062 +type NoUndlyInstrumentPartySubIDs struct { + quickfix.Group +} + +//SetUndlyInstrumentPartySubID sets UndlyInstrumentPartySubID, Tag 1063 +func (m NoUndlyInstrumentPartySubIDs) SetUndlyInstrumentPartySubID(v string) { + m.Set(field.NewUndlyInstrumentPartySubID(v)) +} + +//SetUndlyInstrumentPartySubIDType sets UndlyInstrumentPartySubIDType, Tag 1064 +func (m NoUndlyInstrumentPartySubIDs) SetUndlyInstrumentPartySubIDType(v int) { + m.Set(field.NewUndlyInstrumentPartySubIDType(v)) +} + +//GetUndlyInstrumentPartySubID gets UndlyInstrumentPartySubID, Tag 1063 +func (m NoUndlyInstrumentPartySubIDs) GetUndlyInstrumentPartySubID() (f field.UndlyInstrumentPartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUndlyInstrumentPartySubIDType gets UndlyInstrumentPartySubIDType, Tag 1064 +func (m NoUndlyInstrumentPartySubIDs) GetUndlyInstrumentPartySubIDType() (f field.UndlyInstrumentPartySubIDTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUndlyInstrumentPartySubID returns true if UndlyInstrumentPartySubID is present, Tag 1063 +func (m NoUndlyInstrumentPartySubIDs) HasUndlyInstrumentPartySubID() bool { + return m.Has(tag.UndlyInstrumentPartySubID) +} + +//HasUndlyInstrumentPartySubIDType returns true if UndlyInstrumentPartySubIDType is present, Tag 1064 +func (m NoUndlyInstrumentPartySubIDs) HasUndlyInstrumentPartySubIDType() bool { + return m.Has(tag.UndlyInstrumentPartySubIDType) +} + +//NoUndlyInstrumentPartySubIDsRepeatingGroup is a repeating group, Tag 1062 +type NoUndlyInstrumentPartySubIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUndlyInstrumentPartySubIDsRepeatingGroup returns an initialized, NoUndlyInstrumentPartySubIDsRepeatingGroup +func NewNoUndlyInstrumentPartySubIDsRepeatingGroup() NoUndlyInstrumentPartySubIDsRepeatingGroup { + return NoUndlyInstrumentPartySubIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUndlyInstrumentPartySubIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UndlyInstrumentPartySubID), quickfix.GroupElement(tag.UndlyInstrumentPartySubIDType)})} +} + +//Add create and append a new NoUndlyInstrumentPartySubIDs to this group +func (m NoUndlyInstrumentPartySubIDsRepeatingGroup) Add() NoUndlyInstrumentPartySubIDs { + g := m.RepeatingGroup.Add() + return NoUndlyInstrumentPartySubIDs{g} +} + +//Get returns the ith NoUndlyInstrumentPartySubIDs in the NoUndlyInstrumentPartySubIDsRepeatinGroup +func (m NoUndlyInstrumentPartySubIDsRepeatingGroup) Get(i int) NoUndlyInstrumentPartySubIDs { + return NoUndlyInstrumentPartySubIDs{m.RepeatingGroup.Get(i)} +} + +//NoUndlyInstrumentPartiesRepeatingGroup is a repeating group, Tag 1058 +type NoUndlyInstrumentPartiesRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUndlyInstrumentPartiesRepeatingGroup returns an initialized, NoUndlyInstrumentPartiesRepeatingGroup +func NewNoUndlyInstrumentPartiesRepeatingGroup() NoUndlyInstrumentPartiesRepeatingGroup { + return NoUndlyInstrumentPartiesRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUndlyInstrumentParties, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UndlyInstrumentPartyID), quickfix.GroupElement(tag.UndlyInstrumentPartyIDSource), quickfix.GroupElement(tag.UndlyInstrumentPartyRole), NewNoUndlyInstrumentPartySubIDsRepeatingGroup()})} +} + +//Add create and append a new NoUndlyInstrumentParties to this group +func (m NoUndlyInstrumentPartiesRepeatingGroup) Add() NoUndlyInstrumentParties { + g := m.RepeatingGroup.Add() + return NoUndlyInstrumentParties{g} +} + +//Get returns the ith NoUndlyInstrumentParties in the NoUndlyInstrumentPartiesRepeatinGroup +func (m NoUndlyInstrumentPartiesRepeatingGroup) Get(i int) NoUndlyInstrumentParties { + return NoUndlyInstrumentParties{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyingsRepeatingGroup is a repeating group, Tag 711 +type NoUnderlyingsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingsRepeatingGroup returns an initialized, NoUnderlyingsRepeatingGroup +func NewNoUnderlyingsRepeatingGroup() NoUnderlyingsRepeatingGroup { + return NoUnderlyingsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyings, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingSymbol), quickfix.GroupElement(tag.UnderlyingSymbolSfx), quickfix.GroupElement(tag.UnderlyingSecurityID), quickfix.GroupElement(tag.UnderlyingSecurityIDSource), NewNoUnderlyingSecurityAltIDRepeatingGroup(), quickfix.GroupElement(tag.UnderlyingProduct), quickfix.GroupElement(tag.UnderlyingCFICode), quickfix.GroupElement(tag.UnderlyingSecurityType), quickfix.GroupElement(tag.UnderlyingSecuritySubType), quickfix.GroupElement(tag.UnderlyingMaturityMonthYear), quickfix.GroupElement(tag.UnderlyingMaturityDate), quickfix.GroupElement(tag.UnderlyingCouponPaymentDate), quickfix.GroupElement(tag.UnderlyingIssueDate), quickfix.GroupElement(tag.UnderlyingRepoCollateralSecurityType), quickfix.GroupElement(tag.UnderlyingRepurchaseTerm), quickfix.GroupElement(tag.UnderlyingRepurchaseRate), quickfix.GroupElement(tag.UnderlyingFactor), quickfix.GroupElement(tag.UnderlyingCreditRating), quickfix.GroupElement(tag.UnderlyingInstrRegistry), quickfix.GroupElement(tag.UnderlyingCountryOfIssue), quickfix.GroupElement(tag.UnderlyingStateOrProvinceOfIssue), quickfix.GroupElement(tag.UnderlyingLocaleOfIssue), quickfix.GroupElement(tag.UnderlyingRedemptionDate), quickfix.GroupElement(tag.UnderlyingStrikePrice), quickfix.GroupElement(tag.UnderlyingStrikeCurrency), quickfix.GroupElement(tag.UnderlyingOptAttribute), quickfix.GroupElement(tag.UnderlyingContractMultiplier), quickfix.GroupElement(tag.UnderlyingCouponRate), quickfix.GroupElement(tag.UnderlyingSecurityExchange), quickfix.GroupElement(tag.UnderlyingIssuer), quickfix.GroupElement(tag.EncodedUnderlyingIssuerLen), quickfix.GroupElement(tag.EncodedUnderlyingIssuer), quickfix.GroupElement(tag.UnderlyingSecurityDesc), quickfix.GroupElement(tag.EncodedUnderlyingSecurityDescLen), quickfix.GroupElement(tag.EncodedUnderlyingSecurityDesc), quickfix.GroupElement(tag.UnderlyingCPProgram), quickfix.GroupElement(tag.UnderlyingCPRegType), quickfix.GroupElement(tag.UnderlyingCurrency), quickfix.GroupElement(tag.UnderlyingQty), quickfix.GroupElement(tag.UnderlyingPx), quickfix.GroupElement(tag.UnderlyingDirtyPrice), quickfix.GroupElement(tag.UnderlyingEndPrice), quickfix.GroupElement(tag.UnderlyingStartValue), quickfix.GroupElement(tag.UnderlyingCurrentValue), quickfix.GroupElement(tag.UnderlyingEndValue), NewNoUnderlyingStipsRepeatingGroup(), quickfix.GroupElement(tag.UnderlyingAllocationPercent), quickfix.GroupElement(tag.UnderlyingSettlementType), quickfix.GroupElement(tag.UnderlyingCashAmount), quickfix.GroupElement(tag.UnderlyingCashType), quickfix.GroupElement(tag.UnderlyingUnitOfMeasure), quickfix.GroupElement(tag.UnderlyingTimeUnit), quickfix.GroupElement(tag.UnderlyingCapValue), NewNoUndlyInstrumentPartiesRepeatingGroup(), quickfix.GroupElement(tag.UnderlyingSettlMethod), quickfix.GroupElement(tag.UnderlyingAdjustedQuantity), quickfix.GroupElement(tag.UnderlyingFXRate), quickfix.GroupElement(tag.UnderlyingFXRateCalc)})} +} + +//Add create and append a new NoUnderlyings to this group +func (m NoUnderlyingsRepeatingGroup) Add() NoUnderlyings { + g := m.RepeatingGroup.Add() + return NoUnderlyings{g} +} + +//Get returns the ith NoUnderlyings in the NoUnderlyingsRepeatinGroup +func (m NoUnderlyingsRepeatingGroup) Get(i int) NoUnderlyings { + return NoUnderlyings{m.RepeatingGroup.Get(i)} +} + +//NoTrdRegTimestamps is a repeating group element, Tag 768 +type NoTrdRegTimestamps struct { + quickfix.Group +} + +//SetTrdRegTimestamp sets TrdRegTimestamp, Tag 769 +func (m NoTrdRegTimestamps) SetTrdRegTimestamp(v time.Time) { + m.Set(field.NewTrdRegTimestamp(v)) +} + +//SetTrdRegTimestampType sets TrdRegTimestampType, Tag 770 +func (m NoTrdRegTimestamps) SetTrdRegTimestampType(v int) { + m.Set(field.NewTrdRegTimestampType(v)) +} + +//SetTrdRegTimestampOrigin sets TrdRegTimestampOrigin, Tag 771 +func (m NoTrdRegTimestamps) SetTrdRegTimestampOrigin(v string) { + m.Set(field.NewTrdRegTimestampOrigin(v)) +} + +//SetDeskType sets DeskType, Tag 1033 +func (m NoTrdRegTimestamps) SetDeskType(v string) { + m.Set(field.NewDeskType(v)) +} + +//SetDeskTypeSource sets DeskTypeSource, Tag 1034 +func (m NoTrdRegTimestamps) SetDeskTypeSource(v int) { + m.Set(field.NewDeskTypeSource(v)) +} + +//SetDeskOrderHandlingInst sets DeskOrderHandlingInst, Tag 1035 +func (m NoTrdRegTimestamps) SetDeskOrderHandlingInst(v string) { + m.Set(field.NewDeskOrderHandlingInst(v)) +} + +//GetTrdRegTimestamp gets TrdRegTimestamp, Tag 769 +func (m NoTrdRegTimestamps) GetTrdRegTimestamp() (f field.TrdRegTimestampField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTrdRegTimestampType gets TrdRegTimestampType, Tag 770 +func (m NoTrdRegTimestamps) GetTrdRegTimestampType() (f field.TrdRegTimestampTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTrdRegTimestampOrigin gets TrdRegTimestampOrigin, Tag 771 +func (m NoTrdRegTimestamps) GetTrdRegTimestampOrigin() (f field.TrdRegTimestampOriginField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDeskType gets DeskType, Tag 1033 +func (m NoTrdRegTimestamps) GetDeskType() (f field.DeskTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDeskTypeSource gets DeskTypeSource, Tag 1034 +func (m NoTrdRegTimestamps) GetDeskTypeSource() (f field.DeskTypeSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDeskOrderHandlingInst gets DeskOrderHandlingInst, Tag 1035 +func (m NoTrdRegTimestamps) GetDeskOrderHandlingInst() (f field.DeskOrderHandlingInstField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasTrdRegTimestamp returns true if TrdRegTimestamp is present, Tag 769 +func (m NoTrdRegTimestamps) HasTrdRegTimestamp() bool { + return m.Has(tag.TrdRegTimestamp) +} + +//HasTrdRegTimestampType returns true if TrdRegTimestampType is present, Tag 770 +func (m NoTrdRegTimestamps) HasTrdRegTimestampType() bool { + return m.Has(tag.TrdRegTimestampType) +} + +//HasTrdRegTimestampOrigin returns true if TrdRegTimestampOrigin is present, Tag 771 +func (m NoTrdRegTimestamps) HasTrdRegTimestampOrigin() bool { + return m.Has(tag.TrdRegTimestampOrigin) +} + +//HasDeskType returns true if DeskType is present, Tag 1033 +func (m NoTrdRegTimestamps) HasDeskType() bool { + return m.Has(tag.DeskType) +} + +//HasDeskTypeSource returns true if DeskTypeSource is present, Tag 1034 +func (m NoTrdRegTimestamps) HasDeskTypeSource() bool { + return m.Has(tag.DeskTypeSource) +} + +//HasDeskOrderHandlingInst returns true if DeskOrderHandlingInst is present, Tag 1035 +func (m NoTrdRegTimestamps) HasDeskOrderHandlingInst() bool { + return m.Has(tag.DeskOrderHandlingInst) +} + +//NoTrdRegTimestampsRepeatingGroup is a repeating group, Tag 768 +type NoTrdRegTimestampsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoTrdRegTimestampsRepeatingGroup returns an initialized, NoTrdRegTimestampsRepeatingGroup +func NewNoTrdRegTimestampsRepeatingGroup() NoTrdRegTimestampsRepeatingGroup { + return NoTrdRegTimestampsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoTrdRegTimestamps, + quickfix.GroupTemplate{quickfix.GroupElement(tag.TrdRegTimestamp), quickfix.GroupElement(tag.TrdRegTimestampType), quickfix.GroupElement(tag.TrdRegTimestampOrigin), quickfix.GroupElement(tag.DeskType), quickfix.GroupElement(tag.DeskTypeSource), quickfix.GroupElement(tag.DeskOrderHandlingInst)})} +} + +//Add create and append a new NoTrdRegTimestamps to this group +func (m NoTrdRegTimestampsRepeatingGroup) Add() NoTrdRegTimestamps { + g := m.RepeatingGroup.Add() + return NoTrdRegTimestamps{g} +} + +//Get returns the ith NoTrdRegTimestamps in the NoTrdRegTimestampsRepeatinGroup +func (m NoTrdRegTimestampsRepeatingGroup) Get(i int) NoTrdRegTimestamps { + return NoTrdRegTimestamps{m.RepeatingGroup.Get(i)} +} + +//NoEvents is a repeating group element, Tag 864 +type NoEvents struct { + quickfix.Group +} + +//SetEventType sets EventType, Tag 865 +func (m NoEvents) SetEventType(v int) { + m.Set(field.NewEventType(v)) +} + +//SetEventDate sets EventDate, Tag 866 +func (m NoEvents) SetEventDate(v string) { + m.Set(field.NewEventDate(v)) +} + +//SetEventPx sets EventPx, Tag 867 +func (m NoEvents) SetEventPx(v float64) { + m.Set(field.NewEventPx(v)) +} + +//SetEventText sets EventText, Tag 868 +func (m NoEvents) SetEventText(v string) { + m.Set(field.NewEventText(v)) +} + +//GetEventType gets EventType, Tag 865 +func (m NoEvents) GetEventType() (f field.EventTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventDate gets EventDate, Tag 866 +func (m NoEvents) GetEventDate() (f field.EventDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventPx gets EventPx, Tag 867 +func (m NoEvents) GetEventPx() (f field.EventPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventText gets EventText, Tag 868 +func (m NoEvents) GetEventText() (f field.EventTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasEventType returns true if EventType is present, Tag 865 +func (m NoEvents) HasEventType() bool { + return m.Has(tag.EventType) +} + +//HasEventDate returns true if EventDate is present, Tag 866 +func (m NoEvents) HasEventDate() bool { + return m.Has(tag.EventDate) +} + +//HasEventPx returns true if EventPx is present, Tag 867 +func (m NoEvents) HasEventPx() bool { + return m.Has(tag.EventPx) +} + +//HasEventText returns true if EventText is present, Tag 868 +func (m NoEvents) HasEventText() bool { + return m.Has(tag.EventText) +} + +//NoEventsRepeatingGroup is a repeating group, Tag 864 +type NoEventsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoEventsRepeatingGroup returns an initialized, NoEventsRepeatingGroup +func NewNoEventsRepeatingGroup() NoEventsRepeatingGroup { + return NoEventsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoEvents, + quickfix.GroupTemplate{quickfix.GroupElement(tag.EventType), quickfix.GroupElement(tag.EventDate), quickfix.GroupElement(tag.EventPx), quickfix.GroupElement(tag.EventText)})} +} + +//Add create and append a new NoEvents to this group +func (m NoEventsRepeatingGroup) Add() NoEvents { + g := m.RepeatingGroup.Add() + return NoEvents{g} +} + +//Get returns the ith NoEvents in the NoEventsRepeatinGroup +func (m NoEventsRepeatingGroup) Get(i int) NoEvents { + return NoEvents{m.RepeatingGroup.Get(i)} +} + +//NoStrategyParameters is a repeating group element, Tag 957 +type NoStrategyParameters struct { + quickfix.Group +} + +//SetStrategyParameterName sets StrategyParameterName, Tag 958 +func (m NoStrategyParameters) SetStrategyParameterName(v string) { + m.Set(field.NewStrategyParameterName(v)) +} + +//SetStrategyParameterType sets StrategyParameterType, Tag 959 +func (m NoStrategyParameters) SetStrategyParameterType(v int) { + m.Set(field.NewStrategyParameterType(v)) +} + +//SetStrategyParameterValue sets StrategyParameterValue, Tag 960 +func (m NoStrategyParameters) SetStrategyParameterValue(v string) { + m.Set(field.NewStrategyParameterValue(v)) +} + +//GetStrategyParameterName gets StrategyParameterName, Tag 958 +func (m NoStrategyParameters) GetStrategyParameterName() (f field.StrategyParameterNameField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrategyParameterType gets StrategyParameterType, Tag 959 +func (m NoStrategyParameters) GetStrategyParameterType() (f field.StrategyParameterTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrategyParameterValue gets StrategyParameterValue, Tag 960 +func (m NoStrategyParameters) GetStrategyParameterValue() (f field.StrategyParameterValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasStrategyParameterName returns true if StrategyParameterName is present, Tag 958 +func (m NoStrategyParameters) HasStrategyParameterName() bool { + return m.Has(tag.StrategyParameterName) +} + +//HasStrategyParameterType returns true if StrategyParameterType is present, Tag 959 +func (m NoStrategyParameters) HasStrategyParameterType() bool { + return m.Has(tag.StrategyParameterType) +} + +//HasStrategyParameterValue returns true if StrategyParameterValue is present, Tag 960 +func (m NoStrategyParameters) HasStrategyParameterValue() bool { + return m.Has(tag.StrategyParameterValue) +} + +//NoStrategyParametersRepeatingGroup is a repeating group, Tag 957 +type NoStrategyParametersRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoStrategyParametersRepeatingGroup returns an initialized, NoStrategyParametersRepeatingGroup +func NewNoStrategyParametersRepeatingGroup() NoStrategyParametersRepeatingGroup { + return NoStrategyParametersRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoStrategyParameters, + quickfix.GroupTemplate{quickfix.GroupElement(tag.StrategyParameterName), quickfix.GroupElement(tag.StrategyParameterType), quickfix.GroupElement(tag.StrategyParameterValue)})} +} + +//Add create and append a new NoStrategyParameters to this group +func (m NoStrategyParametersRepeatingGroup) Add() NoStrategyParameters { + g := m.RepeatingGroup.Add() + return NoStrategyParameters{g} +} + +//Get returns the ith NoStrategyParameters in the NoStrategyParametersRepeatinGroup +func (m NoStrategyParametersRepeatingGroup) Get(i int) NoStrategyParameters { + return NoStrategyParameters{m.RepeatingGroup.Get(i)} +} + +//NoInstrumentParties is a repeating group element, Tag 1018 +type NoInstrumentParties struct { + quickfix.Group +} + +//SetInstrumentPartyID sets InstrumentPartyID, Tag 1019 +func (m NoInstrumentParties) SetInstrumentPartyID(v string) { + m.Set(field.NewInstrumentPartyID(v)) +} + +//SetInstrumentPartyIDSource sets InstrumentPartyIDSource, Tag 1050 +func (m NoInstrumentParties) SetInstrumentPartyIDSource(v string) { + m.Set(field.NewInstrumentPartyIDSource(v)) +} + +//SetInstrumentPartyRole sets InstrumentPartyRole, Tag 1051 +func (m NoInstrumentParties) SetInstrumentPartyRole(v int) { + m.Set(field.NewInstrumentPartyRole(v)) +} + +//SetNoInstrumentPartySubIDs sets NoInstrumentPartySubIDs, Tag 1052 +func (m NoInstrumentParties) SetNoInstrumentPartySubIDs(f NoInstrumentPartySubIDsRepeatingGroup) { + m.SetGroup(f) +} + +//GetInstrumentPartyID gets InstrumentPartyID, Tag 1019 +func (m NoInstrumentParties) GetInstrumentPartyID() (f field.InstrumentPartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrumentPartyIDSource gets InstrumentPartyIDSource, Tag 1050 +func (m NoInstrumentParties) GetInstrumentPartyIDSource() (f field.InstrumentPartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrumentPartyRole gets InstrumentPartyRole, Tag 1051 +func (m NoInstrumentParties) GetInstrumentPartyRole() (f field.InstrumentPartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoInstrumentPartySubIDs gets NoInstrumentPartySubIDs, Tag 1052 +func (m NoInstrumentParties) GetNoInstrumentPartySubIDs() (NoInstrumentPartySubIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoInstrumentPartySubIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasInstrumentPartyID returns true if InstrumentPartyID is present, Tag 1019 +func (m NoInstrumentParties) HasInstrumentPartyID() bool { + return m.Has(tag.InstrumentPartyID) +} + +//HasInstrumentPartyIDSource returns true if InstrumentPartyIDSource is present, Tag 1050 +func (m NoInstrumentParties) HasInstrumentPartyIDSource() bool { + return m.Has(tag.InstrumentPartyIDSource) +} + +//HasInstrumentPartyRole returns true if InstrumentPartyRole is present, Tag 1051 +func (m NoInstrumentParties) HasInstrumentPartyRole() bool { + return m.Has(tag.InstrumentPartyRole) +} + +//HasNoInstrumentPartySubIDs returns true if NoInstrumentPartySubIDs is present, Tag 1052 +func (m NoInstrumentParties) HasNoInstrumentPartySubIDs() bool { + return m.Has(tag.NoInstrumentPartySubIDs) +} + +//NoInstrumentPartySubIDs is a repeating group element, Tag 1052 +type NoInstrumentPartySubIDs struct { + quickfix.Group +} + +//SetInstrumentPartySubID sets InstrumentPartySubID, Tag 1053 +func (m NoInstrumentPartySubIDs) SetInstrumentPartySubID(v string) { + m.Set(field.NewInstrumentPartySubID(v)) +} + +//SetInstrumentPartySubIDType sets InstrumentPartySubIDType, Tag 1054 +func (m NoInstrumentPartySubIDs) SetInstrumentPartySubIDType(v int) { + m.Set(field.NewInstrumentPartySubIDType(v)) +} + +//GetInstrumentPartySubID gets InstrumentPartySubID, Tag 1053 +func (m NoInstrumentPartySubIDs) GetInstrumentPartySubID() (f field.InstrumentPartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrumentPartySubIDType gets InstrumentPartySubIDType, Tag 1054 +func (m NoInstrumentPartySubIDs) GetInstrumentPartySubIDType() (f field.InstrumentPartySubIDTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasInstrumentPartySubID returns true if InstrumentPartySubID is present, Tag 1053 +func (m NoInstrumentPartySubIDs) HasInstrumentPartySubID() bool { + return m.Has(tag.InstrumentPartySubID) +} + +//HasInstrumentPartySubIDType returns true if InstrumentPartySubIDType is present, Tag 1054 +func (m NoInstrumentPartySubIDs) HasInstrumentPartySubIDType() bool { + return m.Has(tag.InstrumentPartySubIDType) +} + +//NoInstrumentPartySubIDsRepeatingGroup is a repeating group, Tag 1052 +type NoInstrumentPartySubIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoInstrumentPartySubIDsRepeatingGroup returns an initialized, NoInstrumentPartySubIDsRepeatingGroup +func NewNoInstrumentPartySubIDsRepeatingGroup() NoInstrumentPartySubIDsRepeatingGroup { + return NoInstrumentPartySubIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoInstrumentPartySubIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.InstrumentPartySubID), quickfix.GroupElement(tag.InstrumentPartySubIDType)})} +} + +//Add create and append a new NoInstrumentPartySubIDs to this group +func (m NoInstrumentPartySubIDsRepeatingGroup) Add() NoInstrumentPartySubIDs { + g := m.RepeatingGroup.Add() + return NoInstrumentPartySubIDs{g} +} + +//Get returns the ith NoInstrumentPartySubIDs in the NoInstrumentPartySubIDsRepeatinGroup +func (m NoInstrumentPartySubIDsRepeatingGroup) Get(i int) NoInstrumentPartySubIDs { + return NoInstrumentPartySubIDs{m.RepeatingGroup.Get(i)} +} + +//NoInstrumentPartiesRepeatingGroup is a repeating group, Tag 1018 +type NoInstrumentPartiesRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoInstrumentPartiesRepeatingGroup returns an initialized, NoInstrumentPartiesRepeatingGroup +func NewNoInstrumentPartiesRepeatingGroup() NoInstrumentPartiesRepeatingGroup { + return NoInstrumentPartiesRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoInstrumentParties, + quickfix.GroupTemplate{quickfix.GroupElement(tag.InstrumentPartyID), quickfix.GroupElement(tag.InstrumentPartyIDSource), quickfix.GroupElement(tag.InstrumentPartyRole), NewNoInstrumentPartySubIDsRepeatingGroup()})} +} + +//Add create and append a new NoInstrumentParties to this group +func (m NoInstrumentPartiesRepeatingGroup) Add() NoInstrumentParties { + g := m.RepeatingGroup.Add() + return NoInstrumentParties{g} +} + +//Get returns the ith NoInstrumentParties in the NoInstrumentPartiesRepeatinGroup +func (m NoInstrumentPartiesRepeatingGroup) Get(i int) NoInstrumentParties { + return NoInstrumentParties{m.RepeatingGroup.Get(i)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix50/ordercancelrequest/OrderCancelRequest.generated.go b/vendor/github.com/quickfixgo/quickfix/fix50/ordercancelrequest/OrderCancelRequest.generated.go new file mode 100644 index 0000000..ee355da --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix50/ordercancelrequest/OrderCancelRequest.generated.go @@ -0,0 +1,3136 @@ +package ordercancelrequest + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/fixt11" + "github.com/quickfixgo/quickfix/tag" +) + +//OrderCancelRequest is the fix50 OrderCancelRequest type, MsgType = F +type OrderCancelRequest struct { + fixt11.Header + quickfix.Body + fixt11.Trailer + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time +} + +//FromMessage creates a OrderCancelRequest from a quickfix.Message instance +func FromMessage(m quickfix.Message) OrderCancelRequest { + return OrderCancelRequest{ + Header: fixt11.Header{Header: m.Header}, + Body: m.Body, + Trailer: fixt11.Trailer{Trailer: m.Trailer}, + ReceiveTime: m.ReceiveTime, + } +} + +//ToMessage returns a quickfix.Message instance +func (m OrderCancelRequest) ToMessage() quickfix.Message { + return quickfix.Message{ + Header: m.Header.Header, + Body: m.Body, + Trailer: m.Trailer.Trailer, + ReceiveTime: m.ReceiveTime, + } +} + +//New returns a OrderCancelRequest initialized with the required fields for OrderCancelRequest +func New(origclordid field.OrigClOrdIDField, clordid field.ClOrdIDField, side field.SideField, transacttime field.TransactTimeField) (m OrderCancelRequest) { + m.Header = fixt11.NewHeader() + m.Init() + m.Trailer.Init() + + m.Header.Set(field.NewMsgType("F")) + m.Set(origclordid) + m.Set(clordid) + m.Set(side) + m.Set(transacttime) + + return +} + +//A RouteOut is the callback type that should be implemented for routing Message +type RouteOut func(msg OrderCancelRequest, sessionID quickfix.SessionID) quickfix.MessageRejectError + +//Route returns the beginstring, message type, and MessageRoute for this Message type +func Route(router RouteOut) (string, string, quickfix.MessageRoute) { + r := func(msg quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError { + return router(FromMessage(msg), sessionID) + } + return "7", "F", r +} + +//SetAccount sets Account, Tag 1 +func (m OrderCancelRequest) SetAccount(v string) { + m.Set(field.NewAccount(v)) +} + +//SetClOrdID sets ClOrdID, Tag 11 +func (m OrderCancelRequest) SetClOrdID(v string) { + m.Set(field.NewClOrdID(v)) +} + +//SetSecurityIDSource sets SecurityIDSource, Tag 22 +func (m OrderCancelRequest) SetSecurityIDSource(v string) { + m.Set(field.NewSecurityIDSource(v)) +} + +//SetOrderID sets OrderID, Tag 37 +func (m OrderCancelRequest) SetOrderID(v string) { + m.Set(field.NewOrderID(v)) +} + +//SetOrderQty sets OrderQty, Tag 38 +func (m OrderCancelRequest) SetOrderQty(v float64) { + m.Set(field.NewOrderQty(v)) +} + +//SetOrigClOrdID sets OrigClOrdID, Tag 41 +func (m OrderCancelRequest) SetOrigClOrdID(v string) { + m.Set(field.NewOrigClOrdID(v)) +} + +//SetSecurityID sets SecurityID, Tag 48 +func (m OrderCancelRequest) SetSecurityID(v string) { + m.Set(field.NewSecurityID(v)) +} + +//SetSide sets Side, Tag 54 +func (m OrderCancelRequest) SetSide(v string) { + m.Set(field.NewSide(v)) +} + +//SetSymbol sets Symbol, Tag 55 +func (m OrderCancelRequest) SetSymbol(v string) { + m.Set(field.NewSymbol(v)) +} + +//SetText sets Text, Tag 58 +func (m OrderCancelRequest) SetText(v string) { + m.Set(field.NewText(v)) +} + +//SetTransactTime sets TransactTime, Tag 60 +func (m OrderCancelRequest) SetTransactTime(v time.Time) { + m.Set(field.NewTransactTime(v)) +} + +//SetSymbolSfx sets SymbolSfx, Tag 65 +func (m OrderCancelRequest) SetSymbolSfx(v string) { + m.Set(field.NewSymbolSfx(v)) +} + +//SetListID sets ListID, Tag 66 +func (m OrderCancelRequest) SetListID(v string) { + m.Set(field.NewListID(v)) +} + +//SetIssuer sets Issuer, Tag 106 +func (m OrderCancelRequest) SetIssuer(v string) { + m.Set(field.NewIssuer(v)) +} + +//SetSecurityDesc sets SecurityDesc, Tag 107 +func (m OrderCancelRequest) SetSecurityDesc(v string) { + m.Set(field.NewSecurityDesc(v)) +} + +//SetCashOrderQty sets CashOrderQty, Tag 152 +func (m OrderCancelRequest) SetCashOrderQty(v float64) { + m.Set(field.NewCashOrderQty(v)) +} + +//SetSecurityType sets SecurityType, Tag 167 +func (m OrderCancelRequest) SetSecurityType(v string) { + m.Set(field.NewSecurityType(v)) +} + +//SetMaturityMonthYear sets MaturityMonthYear, Tag 200 +func (m OrderCancelRequest) SetMaturityMonthYear(v string) { + m.Set(field.NewMaturityMonthYear(v)) +} + +//SetStrikePrice sets StrikePrice, Tag 202 +func (m OrderCancelRequest) SetStrikePrice(v float64) { + m.Set(field.NewStrikePrice(v)) +} + +//SetOptAttribute sets OptAttribute, Tag 206 +func (m OrderCancelRequest) SetOptAttribute(v string) { + m.Set(field.NewOptAttribute(v)) +} + +//SetSecurityExchange sets SecurityExchange, Tag 207 +func (m OrderCancelRequest) SetSecurityExchange(v string) { + m.Set(field.NewSecurityExchange(v)) +} + +//SetCouponRate sets CouponRate, Tag 223 +func (m OrderCancelRequest) SetCouponRate(v float64) { + m.Set(field.NewCouponRate(v)) +} + +//SetCouponPaymentDate sets CouponPaymentDate, Tag 224 +func (m OrderCancelRequest) SetCouponPaymentDate(v string) { + m.Set(field.NewCouponPaymentDate(v)) +} + +//SetIssueDate sets IssueDate, Tag 225 +func (m OrderCancelRequest) SetIssueDate(v string) { + m.Set(field.NewIssueDate(v)) +} + +//SetRepurchaseTerm sets RepurchaseTerm, Tag 226 +func (m OrderCancelRequest) SetRepurchaseTerm(v int) { + m.Set(field.NewRepurchaseTerm(v)) +} + +//SetRepurchaseRate sets RepurchaseRate, Tag 227 +func (m OrderCancelRequest) SetRepurchaseRate(v float64) { + m.Set(field.NewRepurchaseRate(v)) +} + +//SetFactor sets Factor, Tag 228 +func (m OrderCancelRequest) SetFactor(v float64) { + m.Set(field.NewFactor(v)) +} + +//SetContractMultiplier sets ContractMultiplier, Tag 231 +func (m OrderCancelRequest) SetContractMultiplier(v float64) { + m.Set(field.NewContractMultiplier(v)) +} + +//SetRepoCollateralSecurityType sets RepoCollateralSecurityType, Tag 239 +func (m OrderCancelRequest) SetRepoCollateralSecurityType(v int) { + m.Set(field.NewRepoCollateralSecurityType(v)) +} + +//SetRedemptionDate sets RedemptionDate, Tag 240 +func (m OrderCancelRequest) SetRedemptionDate(v string) { + m.Set(field.NewRedemptionDate(v)) +} + +//SetCreditRating sets CreditRating, Tag 255 +func (m OrderCancelRequest) SetCreditRating(v string) { + m.Set(field.NewCreditRating(v)) +} + +//SetEncodedIssuerLen sets EncodedIssuerLen, Tag 348 +func (m OrderCancelRequest) SetEncodedIssuerLen(v int) { + m.Set(field.NewEncodedIssuerLen(v)) +} + +//SetEncodedIssuer sets EncodedIssuer, Tag 349 +func (m OrderCancelRequest) SetEncodedIssuer(v string) { + m.Set(field.NewEncodedIssuer(v)) +} + +//SetEncodedSecurityDescLen sets EncodedSecurityDescLen, Tag 350 +func (m OrderCancelRequest) SetEncodedSecurityDescLen(v int) { + m.Set(field.NewEncodedSecurityDescLen(v)) +} + +//SetEncodedSecurityDesc sets EncodedSecurityDesc, Tag 351 +func (m OrderCancelRequest) SetEncodedSecurityDesc(v string) { + m.Set(field.NewEncodedSecurityDesc(v)) +} + +//SetEncodedTextLen sets EncodedTextLen, Tag 354 +func (m OrderCancelRequest) SetEncodedTextLen(v int) { + m.Set(field.NewEncodedTextLen(v)) +} + +//SetEncodedText sets EncodedText, Tag 355 +func (m OrderCancelRequest) SetEncodedText(v string) { + m.Set(field.NewEncodedText(v)) +} + +//SetComplianceID sets ComplianceID, Tag 376 +func (m OrderCancelRequest) SetComplianceID(v string) { + m.Set(field.NewComplianceID(v)) +} + +//SetNoPartyIDs sets NoPartyIDs, Tag 453 +func (m OrderCancelRequest) SetNoPartyIDs(f NoPartyIDsRepeatingGroup) { + m.SetGroup(f) +} + +//SetNoSecurityAltID sets NoSecurityAltID, Tag 454 +func (m OrderCancelRequest) SetNoSecurityAltID(f NoSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetProduct sets Product, Tag 460 +func (m OrderCancelRequest) SetProduct(v int) { + m.Set(field.NewProduct(v)) +} + +//SetCFICode sets CFICode, Tag 461 +func (m OrderCancelRequest) SetCFICode(v string) { + m.Set(field.NewCFICode(v)) +} + +//SetRoundingDirection sets RoundingDirection, Tag 468 +func (m OrderCancelRequest) SetRoundingDirection(v string) { + m.Set(field.NewRoundingDirection(v)) +} + +//SetRoundingModulus sets RoundingModulus, Tag 469 +func (m OrderCancelRequest) SetRoundingModulus(v float64) { + m.Set(field.NewRoundingModulus(v)) +} + +//SetCountryOfIssue sets CountryOfIssue, Tag 470 +func (m OrderCancelRequest) SetCountryOfIssue(v string) { + m.Set(field.NewCountryOfIssue(v)) +} + +//SetStateOrProvinceOfIssue sets StateOrProvinceOfIssue, Tag 471 +func (m OrderCancelRequest) SetStateOrProvinceOfIssue(v string) { + m.Set(field.NewStateOrProvinceOfIssue(v)) +} + +//SetLocaleOfIssue sets LocaleOfIssue, Tag 472 +func (m OrderCancelRequest) SetLocaleOfIssue(v string) { + m.Set(field.NewLocaleOfIssue(v)) +} + +//SetOrderPercent sets OrderPercent, Tag 516 +func (m OrderCancelRequest) SetOrderPercent(v float64) { + m.Set(field.NewOrderPercent(v)) +} + +//SetSecondaryClOrdID sets SecondaryClOrdID, Tag 526 +func (m OrderCancelRequest) SetSecondaryClOrdID(v string) { + m.Set(field.NewSecondaryClOrdID(v)) +} + +//SetMaturityDate sets MaturityDate, Tag 541 +func (m OrderCancelRequest) SetMaturityDate(v string) { + m.Set(field.NewMaturityDate(v)) +} + +//SetInstrRegistry sets InstrRegistry, Tag 543 +func (m OrderCancelRequest) SetInstrRegistry(v string) { + m.Set(field.NewInstrRegistry(v)) +} + +//SetAccountType sets AccountType, Tag 581 +func (m OrderCancelRequest) SetAccountType(v int) { + m.Set(field.NewAccountType(v)) +} + +//SetClOrdLinkID sets ClOrdLinkID, Tag 583 +func (m OrderCancelRequest) SetClOrdLinkID(v string) { + m.Set(field.NewClOrdLinkID(v)) +} + +//SetOrigOrdModTime sets OrigOrdModTime, Tag 586 +func (m OrderCancelRequest) SetOrigOrdModTime(v time.Time) { + m.Set(field.NewOrigOrdModTime(v)) +} + +//SetAcctIDSource sets AcctIDSource, Tag 660 +func (m OrderCancelRequest) SetAcctIDSource(v int) { + m.Set(field.NewAcctIDSource(v)) +} + +//SetContractSettlMonth sets ContractSettlMonth, Tag 667 +func (m OrderCancelRequest) SetContractSettlMonth(v string) { + m.Set(field.NewContractSettlMonth(v)) +} + +//SetPool sets Pool, Tag 691 +func (m OrderCancelRequest) SetPool(v string) { + m.Set(field.NewPool(v)) +} + +//SetNoUnderlyings sets NoUnderlyings, Tag 711 +func (m OrderCancelRequest) SetNoUnderlyings(f NoUnderlyingsRepeatingGroup) { + m.SetGroup(f) +} + +//SetSecuritySubType sets SecuritySubType, Tag 762 +func (m OrderCancelRequest) SetSecuritySubType(v string) { + m.Set(field.NewSecuritySubType(v)) +} + +//SetTerminationType sets TerminationType, Tag 788 +func (m OrderCancelRequest) SetTerminationType(v int) { + m.Set(field.NewTerminationType(v)) +} + +//SetNoEvents sets NoEvents, Tag 864 +func (m OrderCancelRequest) SetNoEvents(f NoEventsRepeatingGroup) { + m.SetGroup(f) +} + +//SetDatedDate sets DatedDate, Tag 873 +func (m OrderCancelRequest) SetDatedDate(v string) { + m.Set(field.NewDatedDate(v)) +} + +//SetInterestAccrualDate sets InterestAccrualDate, Tag 874 +func (m OrderCancelRequest) SetInterestAccrualDate(v string) { + m.Set(field.NewInterestAccrualDate(v)) +} + +//SetCPProgram sets CPProgram, Tag 875 +func (m OrderCancelRequest) SetCPProgram(v int) { + m.Set(field.NewCPProgram(v)) +} + +//SetCPRegType sets CPRegType, Tag 876 +func (m OrderCancelRequest) SetCPRegType(v string) { + m.Set(field.NewCPRegType(v)) +} + +//SetMarginRatio sets MarginRatio, Tag 898 +func (m OrderCancelRequest) SetMarginRatio(v float64) { + m.Set(field.NewMarginRatio(v)) +} + +//SetAgreementDesc sets AgreementDesc, Tag 913 +func (m OrderCancelRequest) SetAgreementDesc(v string) { + m.Set(field.NewAgreementDesc(v)) +} + +//SetAgreementID sets AgreementID, Tag 914 +func (m OrderCancelRequest) SetAgreementID(v string) { + m.Set(field.NewAgreementID(v)) +} + +//SetAgreementDate sets AgreementDate, Tag 915 +func (m OrderCancelRequest) SetAgreementDate(v string) { + m.Set(field.NewAgreementDate(v)) +} + +//SetStartDate sets StartDate, Tag 916 +func (m OrderCancelRequest) SetStartDate(v string) { + m.Set(field.NewStartDate(v)) +} + +//SetEndDate sets EndDate, Tag 917 +func (m OrderCancelRequest) SetEndDate(v string) { + m.Set(field.NewEndDate(v)) +} + +//SetAgreementCurrency sets AgreementCurrency, Tag 918 +func (m OrderCancelRequest) SetAgreementCurrency(v string) { + m.Set(field.NewAgreementCurrency(v)) +} + +//SetDeliveryType sets DeliveryType, Tag 919 +func (m OrderCancelRequest) SetDeliveryType(v int) { + m.Set(field.NewDeliveryType(v)) +} + +//SetStrikeCurrency sets StrikeCurrency, Tag 947 +func (m OrderCancelRequest) SetStrikeCurrency(v string) { + m.Set(field.NewStrikeCurrency(v)) +} + +//SetSecurityStatus sets SecurityStatus, Tag 965 +func (m OrderCancelRequest) SetSecurityStatus(v string) { + m.Set(field.NewSecurityStatus(v)) +} + +//SetSettleOnOpenFlag sets SettleOnOpenFlag, Tag 966 +func (m OrderCancelRequest) SetSettleOnOpenFlag(v string) { + m.Set(field.NewSettleOnOpenFlag(v)) +} + +//SetStrikeMultiplier sets StrikeMultiplier, Tag 967 +func (m OrderCancelRequest) SetStrikeMultiplier(v float64) { + m.Set(field.NewStrikeMultiplier(v)) +} + +//SetStrikeValue sets StrikeValue, Tag 968 +func (m OrderCancelRequest) SetStrikeValue(v float64) { + m.Set(field.NewStrikeValue(v)) +} + +//SetMinPriceIncrement sets MinPriceIncrement, Tag 969 +func (m OrderCancelRequest) SetMinPriceIncrement(v float64) { + m.Set(field.NewMinPriceIncrement(v)) +} + +//SetPositionLimit sets PositionLimit, Tag 970 +func (m OrderCancelRequest) SetPositionLimit(v int) { + m.Set(field.NewPositionLimit(v)) +} + +//SetNTPositionLimit sets NTPositionLimit, Tag 971 +func (m OrderCancelRequest) SetNTPositionLimit(v int) { + m.Set(field.NewNTPositionLimit(v)) +} + +//SetUnitOfMeasure sets UnitOfMeasure, Tag 996 +func (m OrderCancelRequest) SetUnitOfMeasure(v string) { + m.Set(field.NewUnitOfMeasure(v)) +} + +//SetTimeUnit sets TimeUnit, Tag 997 +func (m OrderCancelRequest) SetTimeUnit(v string) { + m.Set(field.NewTimeUnit(v)) +} + +//SetNoInstrumentParties sets NoInstrumentParties, Tag 1018 +func (m OrderCancelRequest) SetNoInstrumentParties(f NoInstrumentPartiesRepeatingGroup) { + m.SetGroup(f) +} + +//SetInstrmtAssignmentMethod sets InstrmtAssignmentMethod, Tag 1049 +func (m OrderCancelRequest) SetInstrmtAssignmentMethod(v string) { + m.Set(field.NewInstrmtAssignmentMethod(v)) +} + +//SetMaturityTime sets MaturityTime, Tag 1079 +func (m OrderCancelRequest) SetMaturityTime(v string) { + m.Set(field.NewMaturityTime(v)) +} + +//GetAccount gets Account, Tag 1 +func (m OrderCancelRequest) GetAccount() (f field.AccountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdID gets ClOrdID, Tag 11 +func (m OrderCancelRequest) GetClOrdID() (f field.ClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityIDSource gets SecurityIDSource, Tag 22 +func (m OrderCancelRequest) GetSecurityIDSource() (f field.SecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderID gets OrderID, Tag 37 +func (m OrderCancelRequest) GetOrderID() (f field.OrderIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderQty gets OrderQty, Tag 38 +func (m OrderCancelRequest) GetOrderQty() (f field.OrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrigClOrdID gets OrigClOrdID, Tag 41 +func (m OrderCancelRequest) GetOrigClOrdID() (f field.OrigClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityID gets SecurityID, Tag 48 +func (m OrderCancelRequest) GetSecurityID() (f field.SecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSide gets Side, Tag 54 +func (m OrderCancelRequest) GetSide() (f field.SideField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbol gets Symbol, Tag 55 +func (m OrderCancelRequest) GetSymbol() (f field.SymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetText gets Text, Tag 58 +func (m OrderCancelRequest) GetText() (f field.TextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTransactTime gets TransactTime, Tag 60 +func (m OrderCancelRequest) GetTransactTime() (f field.TransactTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSymbolSfx gets SymbolSfx, Tag 65 +func (m OrderCancelRequest) GetSymbolSfx() (f field.SymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetListID gets ListID, Tag 66 +func (m OrderCancelRequest) GetListID() (f field.ListIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssuer gets Issuer, Tag 106 +func (m OrderCancelRequest) GetIssuer() (f field.IssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityDesc gets SecurityDesc, Tag 107 +func (m OrderCancelRequest) GetSecurityDesc() (f field.SecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCashOrderQty gets CashOrderQty, Tag 152 +func (m OrderCancelRequest) GetCashOrderQty() (f field.CashOrderQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityType gets SecurityType, Tag 167 +func (m OrderCancelRequest) GetSecurityType() (f field.SecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityMonthYear gets MaturityMonthYear, Tag 200 +func (m OrderCancelRequest) GetMaturityMonthYear() (f field.MaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikePrice gets StrikePrice, Tag 202 +func (m OrderCancelRequest) GetStrikePrice() (f field.StrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOptAttribute gets OptAttribute, Tag 206 +func (m OrderCancelRequest) GetOptAttribute() (f field.OptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityExchange gets SecurityExchange, Tag 207 +func (m OrderCancelRequest) GetSecurityExchange() (f field.SecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponRate gets CouponRate, Tag 223 +func (m OrderCancelRequest) GetCouponRate() (f field.CouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCouponPaymentDate gets CouponPaymentDate, Tag 224 +func (m OrderCancelRequest) GetCouponPaymentDate() (f field.CouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetIssueDate gets IssueDate, Tag 225 +func (m OrderCancelRequest) GetIssueDate() (f field.IssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseTerm gets RepurchaseTerm, Tag 226 +func (m OrderCancelRequest) GetRepurchaseTerm() (f field.RepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepurchaseRate gets RepurchaseRate, Tag 227 +func (m OrderCancelRequest) GetRepurchaseRate() (f field.RepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetFactor gets Factor, Tag 228 +func (m OrderCancelRequest) GetFactor() (f field.FactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractMultiplier gets ContractMultiplier, Tag 231 +func (m OrderCancelRequest) GetContractMultiplier() (f field.ContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRepoCollateralSecurityType gets RepoCollateralSecurityType, Tag 239 +func (m OrderCancelRequest) GetRepoCollateralSecurityType() (f field.RepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRedemptionDate gets RedemptionDate, Tag 240 +func (m OrderCancelRequest) GetRedemptionDate() (f field.RedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCreditRating gets CreditRating, Tag 255 +func (m OrderCancelRequest) GetCreditRating() (f field.CreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuerLen gets EncodedIssuerLen, Tag 348 +func (m OrderCancelRequest) GetEncodedIssuerLen() (f field.EncodedIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedIssuer gets EncodedIssuer, Tag 349 +func (m OrderCancelRequest) GetEncodedIssuer() (f field.EncodedIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDescLen gets EncodedSecurityDescLen, Tag 350 +func (m OrderCancelRequest) GetEncodedSecurityDescLen() (f field.EncodedSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedSecurityDesc gets EncodedSecurityDesc, Tag 351 +func (m OrderCancelRequest) GetEncodedSecurityDesc() (f field.EncodedSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedTextLen gets EncodedTextLen, Tag 354 +func (m OrderCancelRequest) GetEncodedTextLen() (f field.EncodedTextLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedText gets EncodedText, Tag 355 +func (m OrderCancelRequest) GetEncodedText() (f field.EncodedTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetComplianceID gets ComplianceID, Tag 376 +func (m OrderCancelRequest) GetComplianceID() (f field.ComplianceIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoPartyIDs gets NoPartyIDs, Tag 453 +func (m OrderCancelRequest) GetNoPartyIDs() (NoPartyIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoPartyIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetNoSecurityAltID gets NoSecurityAltID, Tag 454 +func (m OrderCancelRequest) GetNoSecurityAltID() (NoSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetProduct gets Product, Tag 460 +func (m OrderCancelRequest) GetProduct() (f field.ProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCFICode gets CFICode, Tag 461 +func (m OrderCancelRequest) GetCFICode() (f field.CFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRoundingDirection gets RoundingDirection, Tag 468 +func (m OrderCancelRequest) GetRoundingDirection() (f field.RoundingDirectionField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetRoundingModulus gets RoundingModulus, Tag 469 +func (m OrderCancelRequest) GetRoundingModulus() (f field.RoundingModulusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCountryOfIssue gets CountryOfIssue, Tag 470 +func (m OrderCancelRequest) GetCountryOfIssue() (f field.CountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStateOrProvinceOfIssue gets StateOrProvinceOfIssue, Tag 471 +func (m OrderCancelRequest) GetStateOrProvinceOfIssue() (f field.StateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetLocaleOfIssue gets LocaleOfIssue, Tag 472 +func (m OrderCancelRequest) GetLocaleOfIssue() (f field.LocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrderPercent gets OrderPercent, Tag 516 +func (m OrderCancelRequest) GetOrderPercent() (f field.OrderPercentField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecondaryClOrdID gets SecondaryClOrdID, Tag 526 +func (m OrderCancelRequest) GetSecondaryClOrdID() (f field.SecondaryClOrdIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityDate gets MaturityDate, Tag 541 +func (m OrderCancelRequest) GetMaturityDate() (f field.MaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrRegistry gets InstrRegistry, Tag 543 +func (m OrderCancelRequest) GetInstrRegistry() (f field.InstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAccountType gets AccountType, Tag 581 +func (m OrderCancelRequest) GetAccountType() (f field.AccountTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetClOrdLinkID gets ClOrdLinkID, Tag 583 +func (m OrderCancelRequest) GetClOrdLinkID() (f field.ClOrdLinkIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetOrigOrdModTime gets OrigOrdModTime, Tag 586 +func (m OrderCancelRequest) GetOrigOrdModTime() (f field.OrigOrdModTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAcctIDSource gets AcctIDSource, Tag 660 +func (m OrderCancelRequest) GetAcctIDSource() (f field.AcctIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetContractSettlMonth gets ContractSettlMonth, Tag 667 +func (m OrderCancelRequest) GetContractSettlMonth() (f field.ContractSettlMonthField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPool gets Pool, Tag 691 +func (m OrderCancelRequest) GetPool() (f field.PoolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyings gets NoUnderlyings, Tag 711 +func (m OrderCancelRequest) GetNoUnderlyings() (NoUnderlyingsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetSecuritySubType gets SecuritySubType, Tag 762 +func (m OrderCancelRequest) GetSecuritySubType() (f field.SecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTerminationType gets TerminationType, Tag 788 +func (m OrderCancelRequest) GetTerminationType() (f field.TerminationTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoEvents gets NoEvents, Tag 864 +func (m OrderCancelRequest) GetNoEvents() (NoEventsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoEventsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetDatedDate gets DatedDate, Tag 873 +func (m OrderCancelRequest) GetDatedDate() (f field.DatedDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInterestAccrualDate gets InterestAccrualDate, Tag 874 +func (m OrderCancelRequest) GetInterestAccrualDate() (f field.InterestAccrualDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCPProgram gets CPProgram, Tag 875 +func (m OrderCancelRequest) GetCPProgram() (f field.CPProgramField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetCPRegType gets CPRegType, Tag 876 +func (m OrderCancelRequest) GetCPRegType() (f field.CPRegTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMarginRatio gets MarginRatio, Tag 898 +func (m OrderCancelRequest) GetMarginRatio() (f field.MarginRatioField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementDesc gets AgreementDesc, Tag 913 +func (m OrderCancelRequest) GetAgreementDesc() (f field.AgreementDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementID gets AgreementID, Tag 914 +func (m OrderCancelRequest) GetAgreementID() (f field.AgreementIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementDate gets AgreementDate, Tag 915 +func (m OrderCancelRequest) GetAgreementDate() (f field.AgreementDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStartDate gets StartDate, Tag 916 +func (m OrderCancelRequest) GetStartDate() (f field.StartDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEndDate gets EndDate, Tag 917 +func (m OrderCancelRequest) GetEndDate() (f field.EndDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetAgreementCurrency gets AgreementCurrency, Tag 918 +func (m OrderCancelRequest) GetAgreementCurrency() (f field.AgreementCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetDeliveryType gets DeliveryType, Tag 919 +func (m OrderCancelRequest) GetDeliveryType() (f field.DeliveryTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikeCurrency gets StrikeCurrency, Tag 947 +func (m OrderCancelRequest) GetStrikeCurrency() (f field.StrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityStatus gets SecurityStatus, Tag 965 +func (m OrderCancelRequest) GetSecurityStatus() (f field.SecurityStatusField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSettleOnOpenFlag gets SettleOnOpenFlag, Tag 966 +func (m OrderCancelRequest) GetSettleOnOpenFlag() (f field.SettleOnOpenFlagField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikeMultiplier gets StrikeMultiplier, Tag 967 +func (m OrderCancelRequest) GetStrikeMultiplier() (f field.StrikeMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetStrikeValue gets StrikeValue, Tag 968 +func (m OrderCancelRequest) GetStrikeValue() (f field.StrikeValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMinPriceIncrement gets MinPriceIncrement, Tag 969 +func (m OrderCancelRequest) GetMinPriceIncrement() (f field.MinPriceIncrementField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPositionLimit gets PositionLimit, Tag 970 +func (m OrderCancelRequest) GetPositionLimit() (f field.PositionLimitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNTPositionLimit gets NTPositionLimit, Tag 971 +func (m OrderCancelRequest) GetNTPositionLimit() (f field.NTPositionLimitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnitOfMeasure gets UnitOfMeasure, Tag 996 +func (m OrderCancelRequest) GetUnitOfMeasure() (f field.UnitOfMeasureField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetTimeUnit gets TimeUnit, Tag 997 +func (m OrderCancelRequest) GetTimeUnit() (f field.TimeUnitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoInstrumentParties gets NoInstrumentParties, Tag 1018 +func (m OrderCancelRequest) GetNoInstrumentParties() (NoInstrumentPartiesRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoInstrumentPartiesRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetInstrmtAssignmentMethod gets InstrmtAssignmentMethod, Tag 1049 +func (m OrderCancelRequest) GetInstrmtAssignmentMethod() (f field.InstrmtAssignmentMethodField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetMaturityTime gets MaturityTime, Tag 1079 +func (m OrderCancelRequest) GetMaturityTime() (f field.MaturityTimeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasAccount returns true if Account is present, Tag 1 +func (m OrderCancelRequest) HasAccount() bool { + return m.Has(tag.Account) +} + +//HasClOrdID returns true if ClOrdID is present, Tag 11 +func (m OrderCancelRequest) HasClOrdID() bool { + return m.Has(tag.ClOrdID) +} + +//HasSecurityIDSource returns true if SecurityIDSource is present, Tag 22 +func (m OrderCancelRequest) HasSecurityIDSource() bool { + return m.Has(tag.SecurityIDSource) +} + +//HasOrderID returns true if OrderID is present, Tag 37 +func (m OrderCancelRequest) HasOrderID() bool { + return m.Has(tag.OrderID) +} + +//HasOrderQty returns true if OrderQty is present, Tag 38 +func (m OrderCancelRequest) HasOrderQty() bool { + return m.Has(tag.OrderQty) +} + +//HasOrigClOrdID returns true if OrigClOrdID is present, Tag 41 +func (m OrderCancelRequest) HasOrigClOrdID() bool { + return m.Has(tag.OrigClOrdID) +} + +//HasSecurityID returns true if SecurityID is present, Tag 48 +func (m OrderCancelRequest) HasSecurityID() bool { + return m.Has(tag.SecurityID) +} + +//HasSide returns true if Side is present, Tag 54 +func (m OrderCancelRequest) HasSide() bool { + return m.Has(tag.Side) +} + +//HasSymbol returns true if Symbol is present, Tag 55 +func (m OrderCancelRequest) HasSymbol() bool { + return m.Has(tag.Symbol) +} + +//HasText returns true if Text is present, Tag 58 +func (m OrderCancelRequest) HasText() bool { + return m.Has(tag.Text) +} + +//HasTransactTime returns true if TransactTime is present, Tag 60 +func (m OrderCancelRequest) HasTransactTime() bool { + return m.Has(tag.TransactTime) +} + +//HasSymbolSfx returns true if SymbolSfx is present, Tag 65 +func (m OrderCancelRequest) HasSymbolSfx() bool { + return m.Has(tag.SymbolSfx) +} + +//HasListID returns true if ListID is present, Tag 66 +func (m OrderCancelRequest) HasListID() bool { + return m.Has(tag.ListID) +} + +//HasIssuer returns true if Issuer is present, Tag 106 +func (m OrderCancelRequest) HasIssuer() bool { + return m.Has(tag.Issuer) +} + +//HasSecurityDesc returns true if SecurityDesc is present, Tag 107 +func (m OrderCancelRequest) HasSecurityDesc() bool { + return m.Has(tag.SecurityDesc) +} + +//HasCashOrderQty returns true if CashOrderQty is present, Tag 152 +func (m OrderCancelRequest) HasCashOrderQty() bool { + return m.Has(tag.CashOrderQty) +} + +//HasSecurityType returns true if SecurityType is present, Tag 167 +func (m OrderCancelRequest) HasSecurityType() bool { + return m.Has(tag.SecurityType) +} + +//HasMaturityMonthYear returns true if MaturityMonthYear is present, Tag 200 +func (m OrderCancelRequest) HasMaturityMonthYear() bool { + return m.Has(tag.MaturityMonthYear) +} + +//HasStrikePrice returns true if StrikePrice is present, Tag 202 +func (m OrderCancelRequest) HasStrikePrice() bool { + return m.Has(tag.StrikePrice) +} + +//HasOptAttribute returns true if OptAttribute is present, Tag 206 +func (m OrderCancelRequest) HasOptAttribute() bool { + return m.Has(tag.OptAttribute) +} + +//HasSecurityExchange returns true if SecurityExchange is present, Tag 207 +func (m OrderCancelRequest) HasSecurityExchange() bool { + return m.Has(tag.SecurityExchange) +} + +//HasCouponRate returns true if CouponRate is present, Tag 223 +func (m OrderCancelRequest) HasCouponRate() bool { + return m.Has(tag.CouponRate) +} + +//HasCouponPaymentDate returns true if CouponPaymentDate is present, Tag 224 +func (m OrderCancelRequest) HasCouponPaymentDate() bool { + return m.Has(tag.CouponPaymentDate) +} + +//HasIssueDate returns true if IssueDate is present, Tag 225 +func (m OrderCancelRequest) HasIssueDate() bool { + return m.Has(tag.IssueDate) +} + +//HasRepurchaseTerm returns true if RepurchaseTerm is present, Tag 226 +func (m OrderCancelRequest) HasRepurchaseTerm() bool { + return m.Has(tag.RepurchaseTerm) +} + +//HasRepurchaseRate returns true if RepurchaseRate is present, Tag 227 +func (m OrderCancelRequest) HasRepurchaseRate() bool { + return m.Has(tag.RepurchaseRate) +} + +//HasFactor returns true if Factor is present, Tag 228 +func (m OrderCancelRequest) HasFactor() bool { + return m.Has(tag.Factor) +} + +//HasContractMultiplier returns true if ContractMultiplier is present, Tag 231 +func (m OrderCancelRequest) HasContractMultiplier() bool { + return m.Has(tag.ContractMultiplier) +} + +//HasRepoCollateralSecurityType returns true if RepoCollateralSecurityType is present, Tag 239 +func (m OrderCancelRequest) HasRepoCollateralSecurityType() bool { + return m.Has(tag.RepoCollateralSecurityType) +} + +//HasRedemptionDate returns true if RedemptionDate is present, Tag 240 +func (m OrderCancelRequest) HasRedemptionDate() bool { + return m.Has(tag.RedemptionDate) +} + +//HasCreditRating returns true if CreditRating is present, Tag 255 +func (m OrderCancelRequest) HasCreditRating() bool { + return m.Has(tag.CreditRating) +} + +//HasEncodedIssuerLen returns true if EncodedIssuerLen is present, Tag 348 +func (m OrderCancelRequest) HasEncodedIssuerLen() bool { + return m.Has(tag.EncodedIssuerLen) +} + +//HasEncodedIssuer returns true if EncodedIssuer is present, Tag 349 +func (m OrderCancelRequest) HasEncodedIssuer() bool { + return m.Has(tag.EncodedIssuer) +} + +//HasEncodedSecurityDescLen returns true if EncodedSecurityDescLen is present, Tag 350 +func (m OrderCancelRequest) HasEncodedSecurityDescLen() bool { + return m.Has(tag.EncodedSecurityDescLen) +} + +//HasEncodedSecurityDesc returns true if EncodedSecurityDesc is present, Tag 351 +func (m OrderCancelRequest) HasEncodedSecurityDesc() bool { + return m.Has(tag.EncodedSecurityDesc) +} + +//HasEncodedTextLen returns true if EncodedTextLen is present, Tag 354 +func (m OrderCancelRequest) HasEncodedTextLen() bool { + return m.Has(tag.EncodedTextLen) +} + +//HasEncodedText returns true if EncodedText is present, Tag 355 +func (m OrderCancelRequest) HasEncodedText() bool { + return m.Has(tag.EncodedText) +} + +//HasComplianceID returns true if ComplianceID is present, Tag 376 +func (m OrderCancelRequest) HasComplianceID() bool { + return m.Has(tag.ComplianceID) +} + +//HasNoPartyIDs returns true if NoPartyIDs is present, Tag 453 +func (m OrderCancelRequest) HasNoPartyIDs() bool { + return m.Has(tag.NoPartyIDs) +} + +//HasNoSecurityAltID returns true if NoSecurityAltID is present, Tag 454 +func (m OrderCancelRequest) HasNoSecurityAltID() bool { + return m.Has(tag.NoSecurityAltID) +} + +//HasProduct returns true if Product is present, Tag 460 +func (m OrderCancelRequest) HasProduct() bool { + return m.Has(tag.Product) +} + +//HasCFICode returns true if CFICode is present, Tag 461 +func (m OrderCancelRequest) HasCFICode() bool { + return m.Has(tag.CFICode) +} + +//HasRoundingDirection returns true if RoundingDirection is present, Tag 468 +func (m OrderCancelRequest) HasRoundingDirection() bool { + return m.Has(tag.RoundingDirection) +} + +//HasRoundingModulus returns true if RoundingModulus is present, Tag 469 +func (m OrderCancelRequest) HasRoundingModulus() bool { + return m.Has(tag.RoundingModulus) +} + +//HasCountryOfIssue returns true if CountryOfIssue is present, Tag 470 +func (m OrderCancelRequest) HasCountryOfIssue() bool { + return m.Has(tag.CountryOfIssue) +} + +//HasStateOrProvinceOfIssue returns true if StateOrProvinceOfIssue is present, Tag 471 +func (m OrderCancelRequest) HasStateOrProvinceOfIssue() bool { + return m.Has(tag.StateOrProvinceOfIssue) +} + +//HasLocaleOfIssue returns true if LocaleOfIssue is present, Tag 472 +func (m OrderCancelRequest) HasLocaleOfIssue() bool { + return m.Has(tag.LocaleOfIssue) +} + +//HasOrderPercent returns true if OrderPercent is present, Tag 516 +func (m OrderCancelRequest) HasOrderPercent() bool { + return m.Has(tag.OrderPercent) +} + +//HasSecondaryClOrdID returns true if SecondaryClOrdID is present, Tag 526 +func (m OrderCancelRequest) HasSecondaryClOrdID() bool { + return m.Has(tag.SecondaryClOrdID) +} + +//HasMaturityDate returns true if MaturityDate is present, Tag 541 +func (m OrderCancelRequest) HasMaturityDate() bool { + return m.Has(tag.MaturityDate) +} + +//HasInstrRegistry returns true if InstrRegistry is present, Tag 543 +func (m OrderCancelRequest) HasInstrRegistry() bool { + return m.Has(tag.InstrRegistry) +} + +//HasAccountType returns true if AccountType is present, Tag 581 +func (m OrderCancelRequest) HasAccountType() bool { + return m.Has(tag.AccountType) +} + +//HasClOrdLinkID returns true if ClOrdLinkID is present, Tag 583 +func (m OrderCancelRequest) HasClOrdLinkID() bool { + return m.Has(tag.ClOrdLinkID) +} + +//HasOrigOrdModTime returns true if OrigOrdModTime is present, Tag 586 +func (m OrderCancelRequest) HasOrigOrdModTime() bool { + return m.Has(tag.OrigOrdModTime) +} + +//HasAcctIDSource returns true if AcctIDSource is present, Tag 660 +func (m OrderCancelRequest) HasAcctIDSource() bool { + return m.Has(tag.AcctIDSource) +} + +//HasContractSettlMonth returns true if ContractSettlMonth is present, Tag 667 +func (m OrderCancelRequest) HasContractSettlMonth() bool { + return m.Has(tag.ContractSettlMonth) +} + +//HasPool returns true if Pool is present, Tag 691 +func (m OrderCancelRequest) HasPool() bool { + return m.Has(tag.Pool) +} + +//HasNoUnderlyings returns true if NoUnderlyings is present, Tag 711 +func (m OrderCancelRequest) HasNoUnderlyings() bool { + return m.Has(tag.NoUnderlyings) +} + +//HasSecuritySubType returns true if SecuritySubType is present, Tag 762 +func (m OrderCancelRequest) HasSecuritySubType() bool { + return m.Has(tag.SecuritySubType) +} + +//HasTerminationType returns true if TerminationType is present, Tag 788 +func (m OrderCancelRequest) HasTerminationType() bool { + return m.Has(tag.TerminationType) +} + +//HasNoEvents returns true if NoEvents is present, Tag 864 +func (m OrderCancelRequest) HasNoEvents() bool { + return m.Has(tag.NoEvents) +} + +//HasDatedDate returns true if DatedDate is present, Tag 873 +func (m OrderCancelRequest) HasDatedDate() bool { + return m.Has(tag.DatedDate) +} + +//HasInterestAccrualDate returns true if InterestAccrualDate is present, Tag 874 +func (m OrderCancelRequest) HasInterestAccrualDate() bool { + return m.Has(tag.InterestAccrualDate) +} + +//HasCPProgram returns true if CPProgram is present, Tag 875 +func (m OrderCancelRequest) HasCPProgram() bool { + return m.Has(tag.CPProgram) +} + +//HasCPRegType returns true if CPRegType is present, Tag 876 +func (m OrderCancelRequest) HasCPRegType() bool { + return m.Has(tag.CPRegType) +} + +//HasMarginRatio returns true if MarginRatio is present, Tag 898 +func (m OrderCancelRequest) HasMarginRatio() bool { + return m.Has(tag.MarginRatio) +} + +//HasAgreementDesc returns true if AgreementDesc is present, Tag 913 +func (m OrderCancelRequest) HasAgreementDesc() bool { + return m.Has(tag.AgreementDesc) +} + +//HasAgreementID returns true if AgreementID is present, Tag 914 +func (m OrderCancelRequest) HasAgreementID() bool { + return m.Has(tag.AgreementID) +} + +//HasAgreementDate returns true if AgreementDate is present, Tag 915 +func (m OrderCancelRequest) HasAgreementDate() bool { + return m.Has(tag.AgreementDate) +} + +//HasStartDate returns true if StartDate is present, Tag 916 +func (m OrderCancelRequest) HasStartDate() bool { + return m.Has(tag.StartDate) +} + +//HasEndDate returns true if EndDate is present, Tag 917 +func (m OrderCancelRequest) HasEndDate() bool { + return m.Has(tag.EndDate) +} + +//HasAgreementCurrency returns true if AgreementCurrency is present, Tag 918 +func (m OrderCancelRequest) HasAgreementCurrency() bool { + return m.Has(tag.AgreementCurrency) +} + +//HasDeliveryType returns true if DeliveryType is present, Tag 919 +func (m OrderCancelRequest) HasDeliveryType() bool { + return m.Has(tag.DeliveryType) +} + +//HasStrikeCurrency returns true if StrikeCurrency is present, Tag 947 +func (m OrderCancelRequest) HasStrikeCurrency() bool { + return m.Has(tag.StrikeCurrency) +} + +//HasSecurityStatus returns true if SecurityStatus is present, Tag 965 +func (m OrderCancelRequest) HasSecurityStatus() bool { + return m.Has(tag.SecurityStatus) +} + +//HasSettleOnOpenFlag returns true if SettleOnOpenFlag is present, Tag 966 +func (m OrderCancelRequest) HasSettleOnOpenFlag() bool { + return m.Has(tag.SettleOnOpenFlag) +} + +//HasStrikeMultiplier returns true if StrikeMultiplier is present, Tag 967 +func (m OrderCancelRequest) HasStrikeMultiplier() bool { + return m.Has(tag.StrikeMultiplier) +} + +//HasStrikeValue returns true if StrikeValue is present, Tag 968 +func (m OrderCancelRequest) HasStrikeValue() bool { + return m.Has(tag.StrikeValue) +} + +//HasMinPriceIncrement returns true if MinPriceIncrement is present, Tag 969 +func (m OrderCancelRequest) HasMinPriceIncrement() bool { + return m.Has(tag.MinPriceIncrement) +} + +//HasPositionLimit returns true if PositionLimit is present, Tag 970 +func (m OrderCancelRequest) HasPositionLimit() bool { + return m.Has(tag.PositionLimit) +} + +//HasNTPositionLimit returns true if NTPositionLimit is present, Tag 971 +func (m OrderCancelRequest) HasNTPositionLimit() bool { + return m.Has(tag.NTPositionLimit) +} + +//HasUnitOfMeasure returns true if UnitOfMeasure is present, Tag 996 +func (m OrderCancelRequest) HasUnitOfMeasure() bool { + return m.Has(tag.UnitOfMeasure) +} + +//HasTimeUnit returns true if TimeUnit is present, Tag 997 +func (m OrderCancelRequest) HasTimeUnit() bool { + return m.Has(tag.TimeUnit) +} + +//HasNoInstrumentParties returns true if NoInstrumentParties is present, Tag 1018 +func (m OrderCancelRequest) HasNoInstrumentParties() bool { + return m.Has(tag.NoInstrumentParties) +} + +//HasInstrmtAssignmentMethod returns true if InstrmtAssignmentMethod is present, Tag 1049 +func (m OrderCancelRequest) HasInstrmtAssignmentMethod() bool { + return m.Has(tag.InstrmtAssignmentMethod) +} + +//HasMaturityTime returns true if MaturityTime is present, Tag 1079 +func (m OrderCancelRequest) HasMaturityTime() bool { + return m.Has(tag.MaturityTime) +} + +//NoPartyIDs is a repeating group element, Tag 453 +type NoPartyIDs struct { + quickfix.Group +} + +//SetPartyID sets PartyID, Tag 448 +func (m NoPartyIDs) SetPartyID(v string) { + m.Set(field.NewPartyID(v)) +} + +//SetPartyIDSource sets PartyIDSource, Tag 447 +func (m NoPartyIDs) SetPartyIDSource(v string) { + m.Set(field.NewPartyIDSource(v)) +} + +//SetPartyRole sets PartyRole, Tag 452 +func (m NoPartyIDs) SetPartyRole(v int) { + m.Set(field.NewPartyRole(v)) +} + +//SetNoPartySubIDs sets NoPartySubIDs, Tag 802 +func (m NoPartyIDs) SetNoPartySubIDs(f NoPartySubIDsRepeatingGroup) { + m.SetGroup(f) +} + +//GetPartyID gets PartyID, Tag 448 +func (m NoPartyIDs) GetPartyID() (f field.PartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartyIDSource gets PartyIDSource, Tag 447 +func (m NoPartyIDs) GetPartyIDSource() (f field.PartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartyRole gets PartyRole, Tag 452 +func (m NoPartyIDs) GetPartyRole() (f field.PartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoPartySubIDs gets NoPartySubIDs, Tag 802 +func (m NoPartyIDs) GetNoPartySubIDs() (NoPartySubIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoPartySubIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasPartyID returns true if PartyID is present, Tag 448 +func (m NoPartyIDs) HasPartyID() bool { + return m.Has(tag.PartyID) +} + +//HasPartyIDSource returns true if PartyIDSource is present, Tag 447 +func (m NoPartyIDs) HasPartyIDSource() bool { + return m.Has(tag.PartyIDSource) +} + +//HasPartyRole returns true if PartyRole is present, Tag 452 +func (m NoPartyIDs) HasPartyRole() bool { + return m.Has(tag.PartyRole) +} + +//HasNoPartySubIDs returns true if NoPartySubIDs is present, Tag 802 +func (m NoPartyIDs) HasNoPartySubIDs() bool { + return m.Has(tag.NoPartySubIDs) +} + +//NoPartySubIDs is a repeating group element, Tag 802 +type NoPartySubIDs struct { + quickfix.Group +} + +//SetPartySubID sets PartySubID, Tag 523 +func (m NoPartySubIDs) SetPartySubID(v string) { + m.Set(field.NewPartySubID(v)) +} + +//SetPartySubIDType sets PartySubIDType, Tag 803 +func (m NoPartySubIDs) SetPartySubIDType(v int) { + m.Set(field.NewPartySubIDType(v)) +} + +//GetPartySubID gets PartySubID, Tag 523 +func (m NoPartySubIDs) GetPartySubID() (f field.PartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetPartySubIDType gets PartySubIDType, Tag 803 +func (m NoPartySubIDs) GetPartySubIDType() (f field.PartySubIDTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasPartySubID returns true if PartySubID is present, Tag 523 +func (m NoPartySubIDs) HasPartySubID() bool { + return m.Has(tag.PartySubID) +} + +//HasPartySubIDType returns true if PartySubIDType is present, Tag 803 +func (m NoPartySubIDs) HasPartySubIDType() bool { + return m.Has(tag.PartySubIDType) +} + +//NoPartySubIDsRepeatingGroup is a repeating group, Tag 802 +type NoPartySubIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoPartySubIDsRepeatingGroup returns an initialized, NoPartySubIDsRepeatingGroup +func NewNoPartySubIDsRepeatingGroup() NoPartySubIDsRepeatingGroup { + return NoPartySubIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoPartySubIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.PartySubID), quickfix.GroupElement(tag.PartySubIDType)})} +} + +//Add create and append a new NoPartySubIDs to this group +func (m NoPartySubIDsRepeatingGroup) Add() NoPartySubIDs { + g := m.RepeatingGroup.Add() + return NoPartySubIDs{g} +} + +//Get returns the ith NoPartySubIDs in the NoPartySubIDsRepeatinGroup +func (m NoPartySubIDsRepeatingGroup) Get(i int) NoPartySubIDs { + return NoPartySubIDs{m.RepeatingGroup.Get(i)} +} + +//NoPartyIDsRepeatingGroup is a repeating group, Tag 453 +type NoPartyIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoPartyIDsRepeatingGroup returns an initialized, NoPartyIDsRepeatingGroup +func NewNoPartyIDsRepeatingGroup() NoPartyIDsRepeatingGroup { + return NoPartyIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoPartyIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.PartyID), quickfix.GroupElement(tag.PartyIDSource), quickfix.GroupElement(tag.PartyRole), NewNoPartySubIDsRepeatingGroup()})} +} + +//Add create and append a new NoPartyIDs to this group +func (m NoPartyIDsRepeatingGroup) Add() NoPartyIDs { + g := m.RepeatingGroup.Add() + return NoPartyIDs{g} +} + +//Get returns the ith NoPartyIDs in the NoPartyIDsRepeatinGroup +func (m NoPartyIDsRepeatingGroup) Get(i int) NoPartyIDs { + return NoPartyIDs{m.RepeatingGroup.Get(i)} +} + +//NoSecurityAltID is a repeating group element, Tag 454 +type NoSecurityAltID struct { + quickfix.Group +} + +//SetSecurityAltID sets SecurityAltID, Tag 455 +func (m NoSecurityAltID) SetSecurityAltID(v string) { + m.Set(field.NewSecurityAltID(v)) +} + +//SetSecurityAltIDSource sets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) SetSecurityAltIDSource(v string) { + m.Set(field.NewSecurityAltIDSource(v)) +} + +//GetSecurityAltID gets SecurityAltID, Tag 455 +func (m NoSecurityAltID) GetSecurityAltID() (f field.SecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetSecurityAltIDSource gets SecurityAltIDSource, Tag 456 +func (m NoSecurityAltID) GetSecurityAltIDSource() (f field.SecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasSecurityAltID returns true if SecurityAltID is present, Tag 455 +func (m NoSecurityAltID) HasSecurityAltID() bool { + return m.Has(tag.SecurityAltID) +} + +//HasSecurityAltIDSource returns true if SecurityAltIDSource is present, Tag 456 +func (m NoSecurityAltID) HasSecurityAltIDSource() bool { + return m.Has(tag.SecurityAltIDSource) +} + +//NoSecurityAltIDRepeatingGroup is a repeating group, Tag 454 +type NoSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoSecurityAltIDRepeatingGroup returns an initialized, NoSecurityAltIDRepeatingGroup +func NewNoSecurityAltIDRepeatingGroup() NoSecurityAltIDRepeatingGroup { + return NoSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.SecurityAltID), quickfix.GroupElement(tag.SecurityAltIDSource)})} +} + +//Add create and append a new NoSecurityAltID to this group +func (m NoSecurityAltIDRepeatingGroup) Add() NoSecurityAltID { + g := m.RepeatingGroup.Add() + return NoSecurityAltID{g} +} + +//Get returns the ith NoSecurityAltID in the NoSecurityAltIDRepeatinGroup +func (m NoSecurityAltIDRepeatingGroup) Get(i int) NoSecurityAltID { + return NoSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyings is a repeating group element, Tag 711 +type NoUnderlyings struct { + quickfix.Group +} + +//SetUnderlyingSymbol sets UnderlyingSymbol, Tag 311 +func (m NoUnderlyings) SetUnderlyingSymbol(v string) { + m.Set(field.NewUnderlyingSymbol(v)) +} + +//SetUnderlyingSymbolSfx sets UnderlyingSymbolSfx, Tag 312 +func (m NoUnderlyings) SetUnderlyingSymbolSfx(v string) { + m.Set(field.NewUnderlyingSymbolSfx(v)) +} + +//SetUnderlyingSecurityID sets UnderlyingSecurityID, Tag 309 +func (m NoUnderlyings) SetUnderlyingSecurityID(v string) { + m.Set(field.NewUnderlyingSecurityID(v)) +} + +//SetUnderlyingSecurityIDSource sets UnderlyingSecurityIDSource, Tag 305 +func (m NoUnderlyings) SetUnderlyingSecurityIDSource(v string) { + m.Set(field.NewUnderlyingSecurityIDSource(v)) +} + +//SetNoUnderlyingSecurityAltID sets NoUnderlyingSecurityAltID, Tag 457 +func (m NoUnderlyings) SetNoUnderlyingSecurityAltID(f NoUnderlyingSecurityAltIDRepeatingGroup) { + m.SetGroup(f) +} + +//SetUnderlyingProduct sets UnderlyingProduct, Tag 462 +func (m NoUnderlyings) SetUnderlyingProduct(v int) { + m.Set(field.NewUnderlyingProduct(v)) +} + +//SetUnderlyingCFICode sets UnderlyingCFICode, Tag 463 +func (m NoUnderlyings) SetUnderlyingCFICode(v string) { + m.Set(field.NewUnderlyingCFICode(v)) +} + +//SetUnderlyingSecurityType sets UnderlyingSecurityType, Tag 310 +func (m NoUnderlyings) SetUnderlyingSecurityType(v string) { + m.Set(field.NewUnderlyingSecurityType(v)) +} + +//SetUnderlyingSecuritySubType sets UnderlyingSecuritySubType, Tag 763 +func (m NoUnderlyings) SetUnderlyingSecuritySubType(v string) { + m.Set(field.NewUnderlyingSecuritySubType(v)) +} + +//SetUnderlyingMaturityMonthYear sets UnderlyingMaturityMonthYear, Tag 313 +func (m NoUnderlyings) SetUnderlyingMaturityMonthYear(v string) { + m.Set(field.NewUnderlyingMaturityMonthYear(v)) +} + +//SetUnderlyingMaturityDate sets UnderlyingMaturityDate, Tag 542 +func (m NoUnderlyings) SetUnderlyingMaturityDate(v string) { + m.Set(field.NewUnderlyingMaturityDate(v)) +} + +//SetUnderlyingCouponPaymentDate sets UnderlyingCouponPaymentDate, Tag 241 +func (m NoUnderlyings) SetUnderlyingCouponPaymentDate(v string) { + m.Set(field.NewUnderlyingCouponPaymentDate(v)) +} + +//SetUnderlyingIssueDate sets UnderlyingIssueDate, Tag 242 +func (m NoUnderlyings) SetUnderlyingIssueDate(v string) { + m.Set(field.NewUnderlyingIssueDate(v)) +} + +//SetUnderlyingRepoCollateralSecurityType sets UnderlyingRepoCollateralSecurityType, Tag 243 +func (m NoUnderlyings) SetUnderlyingRepoCollateralSecurityType(v int) { + m.Set(field.NewUnderlyingRepoCollateralSecurityType(v)) +} + +//SetUnderlyingRepurchaseTerm sets UnderlyingRepurchaseTerm, Tag 244 +func (m NoUnderlyings) SetUnderlyingRepurchaseTerm(v int) { + m.Set(field.NewUnderlyingRepurchaseTerm(v)) +} + +//SetUnderlyingRepurchaseRate sets UnderlyingRepurchaseRate, Tag 245 +func (m NoUnderlyings) SetUnderlyingRepurchaseRate(v float64) { + m.Set(field.NewUnderlyingRepurchaseRate(v)) +} + +//SetUnderlyingFactor sets UnderlyingFactor, Tag 246 +func (m NoUnderlyings) SetUnderlyingFactor(v float64) { + m.Set(field.NewUnderlyingFactor(v)) +} + +//SetUnderlyingCreditRating sets UnderlyingCreditRating, Tag 256 +func (m NoUnderlyings) SetUnderlyingCreditRating(v string) { + m.Set(field.NewUnderlyingCreditRating(v)) +} + +//SetUnderlyingInstrRegistry sets UnderlyingInstrRegistry, Tag 595 +func (m NoUnderlyings) SetUnderlyingInstrRegistry(v string) { + m.Set(field.NewUnderlyingInstrRegistry(v)) +} + +//SetUnderlyingCountryOfIssue sets UnderlyingCountryOfIssue, Tag 592 +func (m NoUnderlyings) SetUnderlyingCountryOfIssue(v string) { + m.Set(field.NewUnderlyingCountryOfIssue(v)) +} + +//SetUnderlyingStateOrProvinceOfIssue sets UnderlyingStateOrProvinceOfIssue, Tag 593 +func (m NoUnderlyings) SetUnderlyingStateOrProvinceOfIssue(v string) { + m.Set(field.NewUnderlyingStateOrProvinceOfIssue(v)) +} + +//SetUnderlyingLocaleOfIssue sets UnderlyingLocaleOfIssue, Tag 594 +func (m NoUnderlyings) SetUnderlyingLocaleOfIssue(v string) { + m.Set(field.NewUnderlyingLocaleOfIssue(v)) +} + +//SetUnderlyingRedemptionDate sets UnderlyingRedemptionDate, Tag 247 +func (m NoUnderlyings) SetUnderlyingRedemptionDate(v string) { + m.Set(field.NewUnderlyingRedemptionDate(v)) +} + +//SetUnderlyingStrikePrice sets UnderlyingStrikePrice, Tag 316 +func (m NoUnderlyings) SetUnderlyingStrikePrice(v float64) { + m.Set(field.NewUnderlyingStrikePrice(v)) +} + +//SetUnderlyingStrikeCurrency sets UnderlyingStrikeCurrency, Tag 941 +func (m NoUnderlyings) SetUnderlyingStrikeCurrency(v string) { + m.Set(field.NewUnderlyingStrikeCurrency(v)) +} + +//SetUnderlyingOptAttribute sets UnderlyingOptAttribute, Tag 317 +func (m NoUnderlyings) SetUnderlyingOptAttribute(v string) { + m.Set(field.NewUnderlyingOptAttribute(v)) +} + +//SetUnderlyingContractMultiplier sets UnderlyingContractMultiplier, Tag 436 +func (m NoUnderlyings) SetUnderlyingContractMultiplier(v float64) { + m.Set(field.NewUnderlyingContractMultiplier(v)) +} + +//SetUnderlyingCouponRate sets UnderlyingCouponRate, Tag 435 +func (m NoUnderlyings) SetUnderlyingCouponRate(v float64) { + m.Set(field.NewUnderlyingCouponRate(v)) +} + +//SetUnderlyingSecurityExchange sets UnderlyingSecurityExchange, Tag 308 +func (m NoUnderlyings) SetUnderlyingSecurityExchange(v string) { + m.Set(field.NewUnderlyingSecurityExchange(v)) +} + +//SetUnderlyingIssuer sets UnderlyingIssuer, Tag 306 +func (m NoUnderlyings) SetUnderlyingIssuer(v string) { + m.Set(field.NewUnderlyingIssuer(v)) +} + +//SetEncodedUnderlyingIssuerLen sets EncodedUnderlyingIssuerLen, Tag 362 +func (m NoUnderlyings) SetEncodedUnderlyingIssuerLen(v int) { + m.Set(field.NewEncodedUnderlyingIssuerLen(v)) +} + +//SetEncodedUnderlyingIssuer sets EncodedUnderlyingIssuer, Tag 363 +func (m NoUnderlyings) SetEncodedUnderlyingIssuer(v string) { + m.Set(field.NewEncodedUnderlyingIssuer(v)) +} + +//SetUnderlyingSecurityDesc sets UnderlyingSecurityDesc, Tag 307 +func (m NoUnderlyings) SetUnderlyingSecurityDesc(v string) { + m.Set(field.NewUnderlyingSecurityDesc(v)) +} + +//SetEncodedUnderlyingSecurityDescLen sets EncodedUnderlyingSecurityDescLen, Tag 364 +func (m NoUnderlyings) SetEncodedUnderlyingSecurityDescLen(v int) { + m.Set(field.NewEncodedUnderlyingSecurityDescLen(v)) +} + +//SetEncodedUnderlyingSecurityDesc sets EncodedUnderlyingSecurityDesc, Tag 365 +func (m NoUnderlyings) SetEncodedUnderlyingSecurityDesc(v string) { + m.Set(field.NewEncodedUnderlyingSecurityDesc(v)) +} + +//SetUnderlyingCPProgram sets UnderlyingCPProgram, Tag 877 +func (m NoUnderlyings) SetUnderlyingCPProgram(v string) { + m.Set(field.NewUnderlyingCPProgram(v)) +} + +//SetUnderlyingCPRegType sets UnderlyingCPRegType, Tag 878 +func (m NoUnderlyings) SetUnderlyingCPRegType(v string) { + m.Set(field.NewUnderlyingCPRegType(v)) +} + +//SetUnderlyingCurrency sets UnderlyingCurrency, Tag 318 +func (m NoUnderlyings) SetUnderlyingCurrency(v string) { + m.Set(field.NewUnderlyingCurrency(v)) +} + +//SetUnderlyingQty sets UnderlyingQty, Tag 879 +func (m NoUnderlyings) SetUnderlyingQty(v float64) { + m.Set(field.NewUnderlyingQty(v)) +} + +//SetUnderlyingPx sets UnderlyingPx, Tag 810 +func (m NoUnderlyings) SetUnderlyingPx(v float64) { + m.Set(field.NewUnderlyingPx(v)) +} + +//SetUnderlyingDirtyPrice sets UnderlyingDirtyPrice, Tag 882 +func (m NoUnderlyings) SetUnderlyingDirtyPrice(v float64) { + m.Set(field.NewUnderlyingDirtyPrice(v)) +} + +//SetUnderlyingEndPrice sets UnderlyingEndPrice, Tag 883 +func (m NoUnderlyings) SetUnderlyingEndPrice(v float64) { + m.Set(field.NewUnderlyingEndPrice(v)) +} + +//SetUnderlyingStartValue sets UnderlyingStartValue, Tag 884 +func (m NoUnderlyings) SetUnderlyingStartValue(v float64) { + m.Set(field.NewUnderlyingStartValue(v)) +} + +//SetUnderlyingCurrentValue sets UnderlyingCurrentValue, Tag 885 +func (m NoUnderlyings) SetUnderlyingCurrentValue(v float64) { + m.Set(field.NewUnderlyingCurrentValue(v)) +} + +//SetUnderlyingEndValue sets UnderlyingEndValue, Tag 886 +func (m NoUnderlyings) SetUnderlyingEndValue(v float64) { + m.Set(field.NewUnderlyingEndValue(v)) +} + +//SetNoUnderlyingStips sets NoUnderlyingStips, Tag 887 +func (m NoUnderlyings) SetNoUnderlyingStips(f NoUnderlyingStipsRepeatingGroup) { + m.SetGroup(f) +} + +//SetUnderlyingAllocationPercent sets UnderlyingAllocationPercent, Tag 972 +func (m NoUnderlyings) SetUnderlyingAllocationPercent(v float64) { + m.Set(field.NewUnderlyingAllocationPercent(v)) +} + +//SetUnderlyingSettlementType sets UnderlyingSettlementType, Tag 975 +func (m NoUnderlyings) SetUnderlyingSettlementType(v int) { + m.Set(field.NewUnderlyingSettlementType(v)) +} + +//SetUnderlyingCashAmount sets UnderlyingCashAmount, Tag 973 +func (m NoUnderlyings) SetUnderlyingCashAmount(v float64) { + m.Set(field.NewUnderlyingCashAmount(v)) +} + +//SetUnderlyingCashType sets UnderlyingCashType, Tag 974 +func (m NoUnderlyings) SetUnderlyingCashType(v string) { + m.Set(field.NewUnderlyingCashType(v)) +} + +//SetUnderlyingUnitOfMeasure sets UnderlyingUnitOfMeasure, Tag 998 +func (m NoUnderlyings) SetUnderlyingUnitOfMeasure(v string) { + m.Set(field.NewUnderlyingUnitOfMeasure(v)) +} + +//SetUnderlyingTimeUnit sets UnderlyingTimeUnit, Tag 1000 +func (m NoUnderlyings) SetUnderlyingTimeUnit(v string) { + m.Set(field.NewUnderlyingTimeUnit(v)) +} + +//SetUnderlyingCapValue sets UnderlyingCapValue, Tag 1038 +func (m NoUnderlyings) SetUnderlyingCapValue(v float64) { + m.Set(field.NewUnderlyingCapValue(v)) +} + +//SetNoUndlyInstrumentParties sets NoUndlyInstrumentParties, Tag 1058 +func (m NoUnderlyings) SetNoUndlyInstrumentParties(f NoUndlyInstrumentPartiesRepeatingGroup) { + m.SetGroup(f) +} + +//SetUnderlyingSettlMethod sets UnderlyingSettlMethod, Tag 1039 +func (m NoUnderlyings) SetUnderlyingSettlMethod(v string) { + m.Set(field.NewUnderlyingSettlMethod(v)) +} + +//SetUnderlyingAdjustedQuantity sets UnderlyingAdjustedQuantity, Tag 1044 +func (m NoUnderlyings) SetUnderlyingAdjustedQuantity(v float64) { + m.Set(field.NewUnderlyingAdjustedQuantity(v)) +} + +//SetUnderlyingFXRate sets UnderlyingFXRate, Tag 1045 +func (m NoUnderlyings) SetUnderlyingFXRate(v float64) { + m.Set(field.NewUnderlyingFXRate(v)) +} + +//SetUnderlyingFXRateCalc sets UnderlyingFXRateCalc, Tag 1046 +func (m NoUnderlyings) SetUnderlyingFXRateCalc(v string) { + m.Set(field.NewUnderlyingFXRateCalc(v)) +} + +//GetUnderlyingSymbol gets UnderlyingSymbol, Tag 311 +func (m NoUnderlyings) GetUnderlyingSymbol() (f field.UnderlyingSymbolField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSymbolSfx gets UnderlyingSymbolSfx, Tag 312 +func (m NoUnderlyings) GetUnderlyingSymbolSfx() (f field.UnderlyingSymbolSfxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityID gets UnderlyingSecurityID, Tag 309 +func (m NoUnderlyings) GetUnderlyingSecurityID() (f field.UnderlyingSecurityIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityIDSource gets UnderlyingSecurityIDSource, Tag 305 +func (m NoUnderlyings) GetUnderlyingSecurityIDSource() (f field.UnderlyingSecurityIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyingSecurityAltID gets NoUnderlyingSecurityAltID, Tag 457 +func (m NoUnderlyings) GetNoUnderlyingSecurityAltID() (NoUnderlyingSecurityAltIDRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingSecurityAltIDRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetUnderlyingProduct gets UnderlyingProduct, Tag 462 +func (m NoUnderlyings) GetUnderlyingProduct() (f field.UnderlyingProductField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCFICode gets UnderlyingCFICode, Tag 463 +func (m NoUnderlyings) GetUnderlyingCFICode() (f field.UnderlyingCFICodeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityType gets UnderlyingSecurityType, Tag 310 +func (m NoUnderlyings) GetUnderlyingSecurityType() (f field.UnderlyingSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecuritySubType gets UnderlyingSecuritySubType, Tag 763 +func (m NoUnderlyings) GetUnderlyingSecuritySubType() (f field.UnderlyingSecuritySubTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingMaturityMonthYear gets UnderlyingMaturityMonthYear, Tag 313 +func (m NoUnderlyings) GetUnderlyingMaturityMonthYear() (f field.UnderlyingMaturityMonthYearField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingMaturityDate gets UnderlyingMaturityDate, Tag 542 +func (m NoUnderlyings) GetUnderlyingMaturityDate() (f field.UnderlyingMaturityDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCouponPaymentDate gets UnderlyingCouponPaymentDate, Tag 241 +func (m NoUnderlyings) GetUnderlyingCouponPaymentDate() (f field.UnderlyingCouponPaymentDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingIssueDate gets UnderlyingIssueDate, Tag 242 +func (m NoUnderlyings) GetUnderlyingIssueDate() (f field.UnderlyingIssueDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepoCollateralSecurityType gets UnderlyingRepoCollateralSecurityType, Tag 243 +func (m NoUnderlyings) GetUnderlyingRepoCollateralSecurityType() (f field.UnderlyingRepoCollateralSecurityTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepurchaseTerm gets UnderlyingRepurchaseTerm, Tag 244 +func (m NoUnderlyings) GetUnderlyingRepurchaseTerm() (f field.UnderlyingRepurchaseTermField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRepurchaseRate gets UnderlyingRepurchaseRate, Tag 245 +func (m NoUnderlyings) GetUnderlyingRepurchaseRate() (f field.UnderlyingRepurchaseRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingFactor gets UnderlyingFactor, Tag 246 +func (m NoUnderlyings) GetUnderlyingFactor() (f field.UnderlyingFactorField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCreditRating gets UnderlyingCreditRating, Tag 256 +func (m NoUnderlyings) GetUnderlyingCreditRating() (f field.UnderlyingCreditRatingField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingInstrRegistry gets UnderlyingInstrRegistry, Tag 595 +func (m NoUnderlyings) GetUnderlyingInstrRegistry() (f field.UnderlyingInstrRegistryField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCountryOfIssue gets UnderlyingCountryOfIssue, Tag 592 +func (m NoUnderlyings) GetUnderlyingCountryOfIssue() (f field.UnderlyingCountryOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStateOrProvinceOfIssue gets UnderlyingStateOrProvinceOfIssue, Tag 593 +func (m NoUnderlyings) GetUnderlyingStateOrProvinceOfIssue() (f field.UnderlyingStateOrProvinceOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingLocaleOfIssue gets UnderlyingLocaleOfIssue, Tag 594 +func (m NoUnderlyings) GetUnderlyingLocaleOfIssue() (f field.UnderlyingLocaleOfIssueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingRedemptionDate gets UnderlyingRedemptionDate, Tag 247 +func (m NoUnderlyings) GetUnderlyingRedemptionDate() (f field.UnderlyingRedemptionDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStrikePrice gets UnderlyingStrikePrice, Tag 316 +func (m NoUnderlyings) GetUnderlyingStrikePrice() (f field.UnderlyingStrikePriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStrikeCurrency gets UnderlyingStrikeCurrency, Tag 941 +func (m NoUnderlyings) GetUnderlyingStrikeCurrency() (f field.UnderlyingStrikeCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingOptAttribute gets UnderlyingOptAttribute, Tag 317 +func (m NoUnderlyings) GetUnderlyingOptAttribute() (f field.UnderlyingOptAttributeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingContractMultiplier gets UnderlyingContractMultiplier, Tag 436 +func (m NoUnderlyings) GetUnderlyingContractMultiplier() (f field.UnderlyingContractMultiplierField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCouponRate gets UnderlyingCouponRate, Tag 435 +func (m NoUnderlyings) GetUnderlyingCouponRate() (f field.UnderlyingCouponRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityExchange gets UnderlyingSecurityExchange, Tag 308 +func (m NoUnderlyings) GetUnderlyingSecurityExchange() (f field.UnderlyingSecurityExchangeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingIssuer gets UnderlyingIssuer, Tag 306 +func (m NoUnderlyings) GetUnderlyingIssuer() (f field.UnderlyingIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingIssuerLen gets EncodedUnderlyingIssuerLen, Tag 362 +func (m NoUnderlyings) GetEncodedUnderlyingIssuerLen() (f field.EncodedUnderlyingIssuerLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingIssuer gets EncodedUnderlyingIssuer, Tag 363 +func (m NoUnderlyings) GetEncodedUnderlyingIssuer() (f field.EncodedUnderlyingIssuerField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityDesc gets UnderlyingSecurityDesc, Tag 307 +func (m NoUnderlyings) GetUnderlyingSecurityDesc() (f field.UnderlyingSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingSecurityDescLen gets EncodedUnderlyingSecurityDescLen, Tag 364 +func (m NoUnderlyings) GetEncodedUnderlyingSecurityDescLen() (f field.EncodedUnderlyingSecurityDescLenField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEncodedUnderlyingSecurityDesc gets EncodedUnderlyingSecurityDesc, Tag 365 +func (m NoUnderlyings) GetEncodedUnderlyingSecurityDesc() (f field.EncodedUnderlyingSecurityDescField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCPProgram gets UnderlyingCPProgram, Tag 877 +func (m NoUnderlyings) GetUnderlyingCPProgram() (f field.UnderlyingCPProgramField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCPRegType gets UnderlyingCPRegType, Tag 878 +func (m NoUnderlyings) GetUnderlyingCPRegType() (f field.UnderlyingCPRegTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCurrency gets UnderlyingCurrency, Tag 318 +func (m NoUnderlyings) GetUnderlyingCurrency() (f field.UnderlyingCurrencyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingQty gets UnderlyingQty, Tag 879 +func (m NoUnderlyings) GetUnderlyingQty() (f field.UnderlyingQtyField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingPx gets UnderlyingPx, Tag 810 +func (m NoUnderlyings) GetUnderlyingPx() (f field.UnderlyingPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingDirtyPrice gets UnderlyingDirtyPrice, Tag 882 +func (m NoUnderlyings) GetUnderlyingDirtyPrice() (f field.UnderlyingDirtyPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingEndPrice gets UnderlyingEndPrice, Tag 883 +func (m NoUnderlyings) GetUnderlyingEndPrice() (f field.UnderlyingEndPriceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStartValue gets UnderlyingStartValue, Tag 884 +func (m NoUnderlyings) GetUnderlyingStartValue() (f field.UnderlyingStartValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCurrentValue gets UnderlyingCurrentValue, Tag 885 +func (m NoUnderlyings) GetUnderlyingCurrentValue() (f field.UnderlyingCurrentValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingEndValue gets UnderlyingEndValue, Tag 886 +func (m NoUnderlyings) GetUnderlyingEndValue() (f field.UnderlyingEndValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUnderlyingStips gets NoUnderlyingStips, Tag 887 +func (m NoUnderlyings) GetNoUnderlyingStips() (NoUnderlyingStipsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUnderlyingStipsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetUnderlyingAllocationPercent gets UnderlyingAllocationPercent, Tag 972 +func (m NoUnderlyings) GetUnderlyingAllocationPercent() (f field.UnderlyingAllocationPercentField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSettlementType gets UnderlyingSettlementType, Tag 975 +func (m NoUnderlyings) GetUnderlyingSettlementType() (f field.UnderlyingSettlementTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCashAmount gets UnderlyingCashAmount, Tag 973 +func (m NoUnderlyings) GetUnderlyingCashAmount() (f field.UnderlyingCashAmountField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCashType gets UnderlyingCashType, Tag 974 +func (m NoUnderlyings) GetUnderlyingCashType() (f field.UnderlyingCashTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingUnitOfMeasure gets UnderlyingUnitOfMeasure, Tag 998 +func (m NoUnderlyings) GetUnderlyingUnitOfMeasure() (f field.UnderlyingUnitOfMeasureField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingTimeUnit gets UnderlyingTimeUnit, Tag 1000 +func (m NoUnderlyings) GetUnderlyingTimeUnit() (f field.UnderlyingTimeUnitField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingCapValue gets UnderlyingCapValue, Tag 1038 +func (m NoUnderlyings) GetUnderlyingCapValue() (f field.UnderlyingCapValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUndlyInstrumentParties gets NoUndlyInstrumentParties, Tag 1058 +func (m NoUnderlyings) GetNoUndlyInstrumentParties() (NoUndlyInstrumentPartiesRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUndlyInstrumentPartiesRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//GetUnderlyingSettlMethod gets UnderlyingSettlMethod, Tag 1039 +func (m NoUnderlyings) GetUnderlyingSettlMethod() (f field.UnderlyingSettlMethodField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingAdjustedQuantity gets UnderlyingAdjustedQuantity, Tag 1044 +func (m NoUnderlyings) GetUnderlyingAdjustedQuantity() (f field.UnderlyingAdjustedQuantityField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingFXRate gets UnderlyingFXRate, Tag 1045 +func (m NoUnderlyings) GetUnderlyingFXRate() (f field.UnderlyingFXRateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingFXRateCalc gets UnderlyingFXRateCalc, Tag 1046 +func (m NoUnderlyings) GetUnderlyingFXRateCalc() (f field.UnderlyingFXRateCalcField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingSymbol returns true if UnderlyingSymbol is present, Tag 311 +func (m NoUnderlyings) HasUnderlyingSymbol() bool { + return m.Has(tag.UnderlyingSymbol) +} + +//HasUnderlyingSymbolSfx returns true if UnderlyingSymbolSfx is present, Tag 312 +func (m NoUnderlyings) HasUnderlyingSymbolSfx() bool { + return m.Has(tag.UnderlyingSymbolSfx) +} + +//HasUnderlyingSecurityID returns true if UnderlyingSecurityID is present, Tag 309 +func (m NoUnderlyings) HasUnderlyingSecurityID() bool { + return m.Has(tag.UnderlyingSecurityID) +} + +//HasUnderlyingSecurityIDSource returns true if UnderlyingSecurityIDSource is present, Tag 305 +func (m NoUnderlyings) HasUnderlyingSecurityIDSource() bool { + return m.Has(tag.UnderlyingSecurityIDSource) +} + +//HasNoUnderlyingSecurityAltID returns true if NoUnderlyingSecurityAltID is present, Tag 457 +func (m NoUnderlyings) HasNoUnderlyingSecurityAltID() bool { + return m.Has(tag.NoUnderlyingSecurityAltID) +} + +//HasUnderlyingProduct returns true if UnderlyingProduct is present, Tag 462 +func (m NoUnderlyings) HasUnderlyingProduct() bool { + return m.Has(tag.UnderlyingProduct) +} + +//HasUnderlyingCFICode returns true if UnderlyingCFICode is present, Tag 463 +func (m NoUnderlyings) HasUnderlyingCFICode() bool { + return m.Has(tag.UnderlyingCFICode) +} + +//HasUnderlyingSecurityType returns true if UnderlyingSecurityType is present, Tag 310 +func (m NoUnderlyings) HasUnderlyingSecurityType() bool { + return m.Has(tag.UnderlyingSecurityType) +} + +//HasUnderlyingSecuritySubType returns true if UnderlyingSecuritySubType is present, Tag 763 +func (m NoUnderlyings) HasUnderlyingSecuritySubType() bool { + return m.Has(tag.UnderlyingSecuritySubType) +} + +//HasUnderlyingMaturityMonthYear returns true if UnderlyingMaturityMonthYear is present, Tag 313 +func (m NoUnderlyings) HasUnderlyingMaturityMonthYear() bool { + return m.Has(tag.UnderlyingMaturityMonthYear) +} + +//HasUnderlyingMaturityDate returns true if UnderlyingMaturityDate is present, Tag 542 +func (m NoUnderlyings) HasUnderlyingMaturityDate() bool { + return m.Has(tag.UnderlyingMaturityDate) +} + +//HasUnderlyingCouponPaymentDate returns true if UnderlyingCouponPaymentDate is present, Tag 241 +func (m NoUnderlyings) HasUnderlyingCouponPaymentDate() bool { + return m.Has(tag.UnderlyingCouponPaymentDate) +} + +//HasUnderlyingIssueDate returns true if UnderlyingIssueDate is present, Tag 242 +func (m NoUnderlyings) HasUnderlyingIssueDate() bool { + return m.Has(tag.UnderlyingIssueDate) +} + +//HasUnderlyingRepoCollateralSecurityType returns true if UnderlyingRepoCollateralSecurityType is present, Tag 243 +func (m NoUnderlyings) HasUnderlyingRepoCollateralSecurityType() bool { + return m.Has(tag.UnderlyingRepoCollateralSecurityType) +} + +//HasUnderlyingRepurchaseTerm returns true if UnderlyingRepurchaseTerm is present, Tag 244 +func (m NoUnderlyings) HasUnderlyingRepurchaseTerm() bool { + return m.Has(tag.UnderlyingRepurchaseTerm) +} + +//HasUnderlyingRepurchaseRate returns true if UnderlyingRepurchaseRate is present, Tag 245 +func (m NoUnderlyings) HasUnderlyingRepurchaseRate() bool { + return m.Has(tag.UnderlyingRepurchaseRate) +} + +//HasUnderlyingFactor returns true if UnderlyingFactor is present, Tag 246 +func (m NoUnderlyings) HasUnderlyingFactor() bool { + return m.Has(tag.UnderlyingFactor) +} + +//HasUnderlyingCreditRating returns true if UnderlyingCreditRating is present, Tag 256 +func (m NoUnderlyings) HasUnderlyingCreditRating() bool { + return m.Has(tag.UnderlyingCreditRating) +} + +//HasUnderlyingInstrRegistry returns true if UnderlyingInstrRegistry is present, Tag 595 +func (m NoUnderlyings) HasUnderlyingInstrRegistry() bool { + return m.Has(tag.UnderlyingInstrRegistry) +} + +//HasUnderlyingCountryOfIssue returns true if UnderlyingCountryOfIssue is present, Tag 592 +func (m NoUnderlyings) HasUnderlyingCountryOfIssue() bool { + return m.Has(tag.UnderlyingCountryOfIssue) +} + +//HasUnderlyingStateOrProvinceOfIssue returns true if UnderlyingStateOrProvinceOfIssue is present, Tag 593 +func (m NoUnderlyings) HasUnderlyingStateOrProvinceOfIssue() bool { + return m.Has(tag.UnderlyingStateOrProvinceOfIssue) +} + +//HasUnderlyingLocaleOfIssue returns true if UnderlyingLocaleOfIssue is present, Tag 594 +func (m NoUnderlyings) HasUnderlyingLocaleOfIssue() bool { + return m.Has(tag.UnderlyingLocaleOfIssue) +} + +//HasUnderlyingRedemptionDate returns true if UnderlyingRedemptionDate is present, Tag 247 +func (m NoUnderlyings) HasUnderlyingRedemptionDate() bool { + return m.Has(tag.UnderlyingRedemptionDate) +} + +//HasUnderlyingStrikePrice returns true if UnderlyingStrikePrice is present, Tag 316 +func (m NoUnderlyings) HasUnderlyingStrikePrice() bool { + return m.Has(tag.UnderlyingStrikePrice) +} + +//HasUnderlyingStrikeCurrency returns true if UnderlyingStrikeCurrency is present, Tag 941 +func (m NoUnderlyings) HasUnderlyingStrikeCurrency() bool { + return m.Has(tag.UnderlyingStrikeCurrency) +} + +//HasUnderlyingOptAttribute returns true if UnderlyingOptAttribute is present, Tag 317 +func (m NoUnderlyings) HasUnderlyingOptAttribute() bool { + return m.Has(tag.UnderlyingOptAttribute) +} + +//HasUnderlyingContractMultiplier returns true if UnderlyingContractMultiplier is present, Tag 436 +func (m NoUnderlyings) HasUnderlyingContractMultiplier() bool { + return m.Has(tag.UnderlyingContractMultiplier) +} + +//HasUnderlyingCouponRate returns true if UnderlyingCouponRate is present, Tag 435 +func (m NoUnderlyings) HasUnderlyingCouponRate() bool { + return m.Has(tag.UnderlyingCouponRate) +} + +//HasUnderlyingSecurityExchange returns true if UnderlyingSecurityExchange is present, Tag 308 +func (m NoUnderlyings) HasUnderlyingSecurityExchange() bool { + return m.Has(tag.UnderlyingSecurityExchange) +} + +//HasUnderlyingIssuer returns true if UnderlyingIssuer is present, Tag 306 +func (m NoUnderlyings) HasUnderlyingIssuer() bool { + return m.Has(tag.UnderlyingIssuer) +} + +//HasEncodedUnderlyingIssuerLen returns true if EncodedUnderlyingIssuerLen is present, Tag 362 +func (m NoUnderlyings) HasEncodedUnderlyingIssuerLen() bool { + return m.Has(tag.EncodedUnderlyingIssuerLen) +} + +//HasEncodedUnderlyingIssuer returns true if EncodedUnderlyingIssuer is present, Tag 363 +func (m NoUnderlyings) HasEncodedUnderlyingIssuer() bool { + return m.Has(tag.EncodedUnderlyingIssuer) +} + +//HasUnderlyingSecurityDesc returns true if UnderlyingSecurityDesc is present, Tag 307 +func (m NoUnderlyings) HasUnderlyingSecurityDesc() bool { + return m.Has(tag.UnderlyingSecurityDesc) +} + +//HasEncodedUnderlyingSecurityDescLen returns true if EncodedUnderlyingSecurityDescLen is present, Tag 364 +func (m NoUnderlyings) HasEncodedUnderlyingSecurityDescLen() bool { + return m.Has(tag.EncodedUnderlyingSecurityDescLen) +} + +//HasEncodedUnderlyingSecurityDesc returns true if EncodedUnderlyingSecurityDesc is present, Tag 365 +func (m NoUnderlyings) HasEncodedUnderlyingSecurityDesc() bool { + return m.Has(tag.EncodedUnderlyingSecurityDesc) +} + +//HasUnderlyingCPProgram returns true if UnderlyingCPProgram is present, Tag 877 +func (m NoUnderlyings) HasUnderlyingCPProgram() bool { + return m.Has(tag.UnderlyingCPProgram) +} + +//HasUnderlyingCPRegType returns true if UnderlyingCPRegType is present, Tag 878 +func (m NoUnderlyings) HasUnderlyingCPRegType() bool { + return m.Has(tag.UnderlyingCPRegType) +} + +//HasUnderlyingCurrency returns true if UnderlyingCurrency is present, Tag 318 +func (m NoUnderlyings) HasUnderlyingCurrency() bool { + return m.Has(tag.UnderlyingCurrency) +} + +//HasUnderlyingQty returns true if UnderlyingQty is present, Tag 879 +func (m NoUnderlyings) HasUnderlyingQty() bool { + return m.Has(tag.UnderlyingQty) +} + +//HasUnderlyingPx returns true if UnderlyingPx is present, Tag 810 +func (m NoUnderlyings) HasUnderlyingPx() bool { + return m.Has(tag.UnderlyingPx) +} + +//HasUnderlyingDirtyPrice returns true if UnderlyingDirtyPrice is present, Tag 882 +func (m NoUnderlyings) HasUnderlyingDirtyPrice() bool { + return m.Has(tag.UnderlyingDirtyPrice) +} + +//HasUnderlyingEndPrice returns true if UnderlyingEndPrice is present, Tag 883 +func (m NoUnderlyings) HasUnderlyingEndPrice() bool { + return m.Has(tag.UnderlyingEndPrice) +} + +//HasUnderlyingStartValue returns true if UnderlyingStartValue is present, Tag 884 +func (m NoUnderlyings) HasUnderlyingStartValue() bool { + return m.Has(tag.UnderlyingStartValue) +} + +//HasUnderlyingCurrentValue returns true if UnderlyingCurrentValue is present, Tag 885 +func (m NoUnderlyings) HasUnderlyingCurrentValue() bool { + return m.Has(tag.UnderlyingCurrentValue) +} + +//HasUnderlyingEndValue returns true if UnderlyingEndValue is present, Tag 886 +func (m NoUnderlyings) HasUnderlyingEndValue() bool { + return m.Has(tag.UnderlyingEndValue) +} + +//HasNoUnderlyingStips returns true if NoUnderlyingStips is present, Tag 887 +func (m NoUnderlyings) HasNoUnderlyingStips() bool { + return m.Has(tag.NoUnderlyingStips) +} + +//HasUnderlyingAllocationPercent returns true if UnderlyingAllocationPercent is present, Tag 972 +func (m NoUnderlyings) HasUnderlyingAllocationPercent() bool { + return m.Has(tag.UnderlyingAllocationPercent) +} + +//HasUnderlyingSettlementType returns true if UnderlyingSettlementType is present, Tag 975 +func (m NoUnderlyings) HasUnderlyingSettlementType() bool { + return m.Has(tag.UnderlyingSettlementType) +} + +//HasUnderlyingCashAmount returns true if UnderlyingCashAmount is present, Tag 973 +func (m NoUnderlyings) HasUnderlyingCashAmount() bool { + return m.Has(tag.UnderlyingCashAmount) +} + +//HasUnderlyingCashType returns true if UnderlyingCashType is present, Tag 974 +func (m NoUnderlyings) HasUnderlyingCashType() bool { + return m.Has(tag.UnderlyingCashType) +} + +//HasUnderlyingUnitOfMeasure returns true if UnderlyingUnitOfMeasure is present, Tag 998 +func (m NoUnderlyings) HasUnderlyingUnitOfMeasure() bool { + return m.Has(tag.UnderlyingUnitOfMeasure) +} + +//HasUnderlyingTimeUnit returns true if UnderlyingTimeUnit is present, Tag 1000 +func (m NoUnderlyings) HasUnderlyingTimeUnit() bool { + return m.Has(tag.UnderlyingTimeUnit) +} + +//HasUnderlyingCapValue returns true if UnderlyingCapValue is present, Tag 1038 +func (m NoUnderlyings) HasUnderlyingCapValue() bool { + return m.Has(tag.UnderlyingCapValue) +} + +//HasNoUndlyInstrumentParties returns true if NoUndlyInstrumentParties is present, Tag 1058 +func (m NoUnderlyings) HasNoUndlyInstrumentParties() bool { + return m.Has(tag.NoUndlyInstrumentParties) +} + +//HasUnderlyingSettlMethod returns true if UnderlyingSettlMethod is present, Tag 1039 +func (m NoUnderlyings) HasUnderlyingSettlMethod() bool { + return m.Has(tag.UnderlyingSettlMethod) +} + +//HasUnderlyingAdjustedQuantity returns true if UnderlyingAdjustedQuantity is present, Tag 1044 +func (m NoUnderlyings) HasUnderlyingAdjustedQuantity() bool { + return m.Has(tag.UnderlyingAdjustedQuantity) +} + +//HasUnderlyingFXRate returns true if UnderlyingFXRate is present, Tag 1045 +func (m NoUnderlyings) HasUnderlyingFXRate() bool { + return m.Has(tag.UnderlyingFXRate) +} + +//HasUnderlyingFXRateCalc returns true if UnderlyingFXRateCalc is present, Tag 1046 +func (m NoUnderlyings) HasUnderlyingFXRateCalc() bool { + return m.Has(tag.UnderlyingFXRateCalc) +} + +//NoUnderlyingSecurityAltID is a repeating group element, Tag 457 +type NoUnderlyingSecurityAltID struct { + quickfix.Group +} + +//SetUnderlyingSecurityAltID sets UnderlyingSecurityAltID, Tag 458 +func (m NoUnderlyingSecurityAltID) SetUnderlyingSecurityAltID(v string) { + m.Set(field.NewUnderlyingSecurityAltID(v)) +} + +//SetUnderlyingSecurityAltIDSource sets UnderlyingSecurityAltIDSource, Tag 459 +func (m NoUnderlyingSecurityAltID) SetUnderlyingSecurityAltIDSource(v string) { + m.Set(field.NewUnderlyingSecurityAltIDSource(v)) +} + +//GetUnderlyingSecurityAltID gets UnderlyingSecurityAltID, Tag 458 +func (m NoUnderlyingSecurityAltID) GetUnderlyingSecurityAltID() (f field.UnderlyingSecurityAltIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingSecurityAltIDSource gets UnderlyingSecurityAltIDSource, Tag 459 +func (m NoUnderlyingSecurityAltID) GetUnderlyingSecurityAltIDSource() (f field.UnderlyingSecurityAltIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingSecurityAltID returns true if UnderlyingSecurityAltID is present, Tag 458 +func (m NoUnderlyingSecurityAltID) HasUnderlyingSecurityAltID() bool { + return m.Has(tag.UnderlyingSecurityAltID) +} + +//HasUnderlyingSecurityAltIDSource returns true if UnderlyingSecurityAltIDSource is present, Tag 459 +func (m NoUnderlyingSecurityAltID) HasUnderlyingSecurityAltIDSource() bool { + return m.Has(tag.UnderlyingSecurityAltIDSource) +} + +//NoUnderlyingSecurityAltIDRepeatingGroup is a repeating group, Tag 457 +type NoUnderlyingSecurityAltIDRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingSecurityAltIDRepeatingGroup returns an initialized, NoUnderlyingSecurityAltIDRepeatingGroup +func NewNoUnderlyingSecurityAltIDRepeatingGroup() NoUnderlyingSecurityAltIDRepeatingGroup { + return NoUnderlyingSecurityAltIDRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyingSecurityAltID, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingSecurityAltID), quickfix.GroupElement(tag.UnderlyingSecurityAltIDSource)})} +} + +//Add create and append a new NoUnderlyingSecurityAltID to this group +func (m NoUnderlyingSecurityAltIDRepeatingGroup) Add() NoUnderlyingSecurityAltID { + g := m.RepeatingGroup.Add() + return NoUnderlyingSecurityAltID{g} +} + +//Get returns the ith NoUnderlyingSecurityAltID in the NoUnderlyingSecurityAltIDRepeatinGroup +func (m NoUnderlyingSecurityAltIDRepeatingGroup) Get(i int) NoUnderlyingSecurityAltID { + return NoUnderlyingSecurityAltID{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyingStips is a repeating group element, Tag 887 +type NoUnderlyingStips struct { + quickfix.Group +} + +//SetUnderlyingStipType sets UnderlyingStipType, Tag 888 +func (m NoUnderlyingStips) SetUnderlyingStipType(v string) { + m.Set(field.NewUnderlyingStipType(v)) +} + +//SetUnderlyingStipValue sets UnderlyingStipValue, Tag 889 +func (m NoUnderlyingStips) SetUnderlyingStipValue(v string) { + m.Set(field.NewUnderlyingStipValue(v)) +} + +//GetUnderlyingStipType gets UnderlyingStipType, Tag 888 +func (m NoUnderlyingStips) GetUnderlyingStipType() (f field.UnderlyingStipTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUnderlyingStipValue gets UnderlyingStipValue, Tag 889 +func (m NoUnderlyingStips) GetUnderlyingStipValue() (f field.UnderlyingStipValueField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUnderlyingStipType returns true if UnderlyingStipType is present, Tag 888 +func (m NoUnderlyingStips) HasUnderlyingStipType() bool { + return m.Has(tag.UnderlyingStipType) +} + +//HasUnderlyingStipValue returns true if UnderlyingStipValue is present, Tag 889 +func (m NoUnderlyingStips) HasUnderlyingStipValue() bool { + return m.Has(tag.UnderlyingStipValue) +} + +//NoUnderlyingStipsRepeatingGroup is a repeating group, Tag 887 +type NoUnderlyingStipsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingStipsRepeatingGroup returns an initialized, NoUnderlyingStipsRepeatingGroup +func NewNoUnderlyingStipsRepeatingGroup() NoUnderlyingStipsRepeatingGroup { + return NoUnderlyingStipsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyingStips, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingStipType), quickfix.GroupElement(tag.UnderlyingStipValue)})} +} + +//Add create and append a new NoUnderlyingStips to this group +func (m NoUnderlyingStipsRepeatingGroup) Add() NoUnderlyingStips { + g := m.RepeatingGroup.Add() + return NoUnderlyingStips{g} +} + +//Get returns the ith NoUnderlyingStips in the NoUnderlyingStipsRepeatinGroup +func (m NoUnderlyingStipsRepeatingGroup) Get(i int) NoUnderlyingStips { + return NoUnderlyingStips{m.RepeatingGroup.Get(i)} +} + +//NoUndlyInstrumentParties is a repeating group element, Tag 1058 +type NoUndlyInstrumentParties struct { + quickfix.Group +} + +//SetUndlyInstrumentPartyID sets UndlyInstrumentPartyID, Tag 1059 +func (m NoUndlyInstrumentParties) SetUndlyInstrumentPartyID(v string) { + m.Set(field.NewUndlyInstrumentPartyID(v)) +} + +//SetUndlyInstrumentPartyIDSource sets UndlyInstrumentPartyIDSource, Tag 1060 +func (m NoUndlyInstrumentParties) SetUndlyInstrumentPartyIDSource(v string) { + m.Set(field.NewUndlyInstrumentPartyIDSource(v)) +} + +//SetUndlyInstrumentPartyRole sets UndlyInstrumentPartyRole, Tag 1061 +func (m NoUndlyInstrumentParties) SetUndlyInstrumentPartyRole(v int) { + m.Set(field.NewUndlyInstrumentPartyRole(v)) +} + +//SetNoUndlyInstrumentPartySubIDs sets NoUndlyInstrumentPartySubIDs, Tag 1062 +func (m NoUndlyInstrumentParties) SetNoUndlyInstrumentPartySubIDs(f NoUndlyInstrumentPartySubIDsRepeatingGroup) { + m.SetGroup(f) +} + +//GetUndlyInstrumentPartyID gets UndlyInstrumentPartyID, Tag 1059 +func (m NoUndlyInstrumentParties) GetUndlyInstrumentPartyID() (f field.UndlyInstrumentPartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUndlyInstrumentPartyIDSource gets UndlyInstrumentPartyIDSource, Tag 1060 +func (m NoUndlyInstrumentParties) GetUndlyInstrumentPartyIDSource() (f field.UndlyInstrumentPartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUndlyInstrumentPartyRole gets UndlyInstrumentPartyRole, Tag 1061 +func (m NoUndlyInstrumentParties) GetUndlyInstrumentPartyRole() (f field.UndlyInstrumentPartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoUndlyInstrumentPartySubIDs gets NoUndlyInstrumentPartySubIDs, Tag 1062 +func (m NoUndlyInstrumentParties) GetNoUndlyInstrumentPartySubIDs() (NoUndlyInstrumentPartySubIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoUndlyInstrumentPartySubIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasUndlyInstrumentPartyID returns true if UndlyInstrumentPartyID is present, Tag 1059 +func (m NoUndlyInstrumentParties) HasUndlyInstrumentPartyID() bool { + return m.Has(tag.UndlyInstrumentPartyID) +} + +//HasUndlyInstrumentPartyIDSource returns true if UndlyInstrumentPartyIDSource is present, Tag 1060 +func (m NoUndlyInstrumentParties) HasUndlyInstrumentPartyIDSource() bool { + return m.Has(tag.UndlyInstrumentPartyIDSource) +} + +//HasUndlyInstrumentPartyRole returns true if UndlyInstrumentPartyRole is present, Tag 1061 +func (m NoUndlyInstrumentParties) HasUndlyInstrumentPartyRole() bool { + return m.Has(tag.UndlyInstrumentPartyRole) +} + +//HasNoUndlyInstrumentPartySubIDs returns true if NoUndlyInstrumentPartySubIDs is present, Tag 1062 +func (m NoUndlyInstrumentParties) HasNoUndlyInstrumentPartySubIDs() bool { + return m.Has(tag.NoUndlyInstrumentPartySubIDs) +} + +//NoUndlyInstrumentPartySubIDs is a repeating group element, Tag 1062 +type NoUndlyInstrumentPartySubIDs struct { + quickfix.Group +} + +//SetUndlyInstrumentPartySubID sets UndlyInstrumentPartySubID, Tag 1063 +func (m NoUndlyInstrumentPartySubIDs) SetUndlyInstrumentPartySubID(v string) { + m.Set(field.NewUndlyInstrumentPartySubID(v)) +} + +//SetUndlyInstrumentPartySubIDType sets UndlyInstrumentPartySubIDType, Tag 1064 +func (m NoUndlyInstrumentPartySubIDs) SetUndlyInstrumentPartySubIDType(v int) { + m.Set(field.NewUndlyInstrumentPartySubIDType(v)) +} + +//GetUndlyInstrumentPartySubID gets UndlyInstrumentPartySubID, Tag 1063 +func (m NoUndlyInstrumentPartySubIDs) GetUndlyInstrumentPartySubID() (f field.UndlyInstrumentPartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetUndlyInstrumentPartySubIDType gets UndlyInstrumentPartySubIDType, Tag 1064 +func (m NoUndlyInstrumentPartySubIDs) GetUndlyInstrumentPartySubIDType() (f field.UndlyInstrumentPartySubIDTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasUndlyInstrumentPartySubID returns true if UndlyInstrumentPartySubID is present, Tag 1063 +func (m NoUndlyInstrumentPartySubIDs) HasUndlyInstrumentPartySubID() bool { + return m.Has(tag.UndlyInstrumentPartySubID) +} + +//HasUndlyInstrumentPartySubIDType returns true if UndlyInstrumentPartySubIDType is present, Tag 1064 +func (m NoUndlyInstrumentPartySubIDs) HasUndlyInstrumentPartySubIDType() bool { + return m.Has(tag.UndlyInstrumentPartySubIDType) +} + +//NoUndlyInstrumentPartySubIDsRepeatingGroup is a repeating group, Tag 1062 +type NoUndlyInstrumentPartySubIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUndlyInstrumentPartySubIDsRepeatingGroup returns an initialized, NoUndlyInstrumentPartySubIDsRepeatingGroup +func NewNoUndlyInstrumentPartySubIDsRepeatingGroup() NoUndlyInstrumentPartySubIDsRepeatingGroup { + return NoUndlyInstrumentPartySubIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUndlyInstrumentPartySubIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UndlyInstrumentPartySubID), quickfix.GroupElement(tag.UndlyInstrumentPartySubIDType)})} +} + +//Add create and append a new NoUndlyInstrumentPartySubIDs to this group +func (m NoUndlyInstrumentPartySubIDsRepeatingGroup) Add() NoUndlyInstrumentPartySubIDs { + g := m.RepeatingGroup.Add() + return NoUndlyInstrumentPartySubIDs{g} +} + +//Get returns the ith NoUndlyInstrumentPartySubIDs in the NoUndlyInstrumentPartySubIDsRepeatinGroup +func (m NoUndlyInstrumentPartySubIDsRepeatingGroup) Get(i int) NoUndlyInstrumentPartySubIDs { + return NoUndlyInstrumentPartySubIDs{m.RepeatingGroup.Get(i)} +} + +//NoUndlyInstrumentPartiesRepeatingGroup is a repeating group, Tag 1058 +type NoUndlyInstrumentPartiesRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUndlyInstrumentPartiesRepeatingGroup returns an initialized, NoUndlyInstrumentPartiesRepeatingGroup +func NewNoUndlyInstrumentPartiesRepeatingGroup() NoUndlyInstrumentPartiesRepeatingGroup { + return NoUndlyInstrumentPartiesRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUndlyInstrumentParties, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UndlyInstrumentPartyID), quickfix.GroupElement(tag.UndlyInstrumentPartyIDSource), quickfix.GroupElement(tag.UndlyInstrumentPartyRole), NewNoUndlyInstrumentPartySubIDsRepeatingGroup()})} +} + +//Add create and append a new NoUndlyInstrumentParties to this group +func (m NoUndlyInstrumentPartiesRepeatingGroup) Add() NoUndlyInstrumentParties { + g := m.RepeatingGroup.Add() + return NoUndlyInstrumentParties{g} +} + +//Get returns the ith NoUndlyInstrumentParties in the NoUndlyInstrumentPartiesRepeatinGroup +func (m NoUndlyInstrumentPartiesRepeatingGroup) Get(i int) NoUndlyInstrumentParties { + return NoUndlyInstrumentParties{m.RepeatingGroup.Get(i)} +} + +//NoUnderlyingsRepeatingGroup is a repeating group, Tag 711 +type NoUnderlyingsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoUnderlyingsRepeatingGroup returns an initialized, NoUnderlyingsRepeatingGroup +func NewNoUnderlyingsRepeatingGroup() NoUnderlyingsRepeatingGroup { + return NoUnderlyingsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoUnderlyings, + quickfix.GroupTemplate{quickfix.GroupElement(tag.UnderlyingSymbol), quickfix.GroupElement(tag.UnderlyingSymbolSfx), quickfix.GroupElement(tag.UnderlyingSecurityID), quickfix.GroupElement(tag.UnderlyingSecurityIDSource), NewNoUnderlyingSecurityAltIDRepeatingGroup(), quickfix.GroupElement(tag.UnderlyingProduct), quickfix.GroupElement(tag.UnderlyingCFICode), quickfix.GroupElement(tag.UnderlyingSecurityType), quickfix.GroupElement(tag.UnderlyingSecuritySubType), quickfix.GroupElement(tag.UnderlyingMaturityMonthYear), quickfix.GroupElement(tag.UnderlyingMaturityDate), quickfix.GroupElement(tag.UnderlyingCouponPaymentDate), quickfix.GroupElement(tag.UnderlyingIssueDate), quickfix.GroupElement(tag.UnderlyingRepoCollateralSecurityType), quickfix.GroupElement(tag.UnderlyingRepurchaseTerm), quickfix.GroupElement(tag.UnderlyingRepurchaseRate), quickfix.GroupElement(tag.UnderlyingFactor), quickfix.GroupElement(tag.UnderlyingCreditRating), quickfix.GroupElement(tag.UnderlyingInstrRegistry), quickfix.GroupElement(tag.UnderlyingCountryOfIssue), quickfix.GroupElement(tag.UnderlyingStateOrProvinceOfIssue), quickfix.GroupElement(tag.UnderlyingLocaleOfIssue), quickfix.GroupElement(tag.UnderlyingRedemptionDate), quickfix.GroupElement(tag.UnderlyingStrikePrice), quickfix.GroupElement(tag.UnderlyingStrikeCurrency), quickfix.GroupElement(tag.UnderlyingOptAttribute), quickfix.GroupElement(tag.UnderlyingContractMultiplier), quickfix.GroupElement(tag.UnderlyingCouponRate), quickfix.GroupElement(tag.UnderlyingSecurityExchange), quickfix.GroupElement(tag.UnderlyingIssuer), quickfix.GroupElement(tag.EncodedUnderlyingIssuerLen), quickfix.GroupElement(tag.EncodedUnderlyingIssuer), quickfix.GroupElement(tag.UnderlyingSecurityDesc), quickfix.GroupElement(tag.EncodedUnderlyingSecurityDescLen), quickfix.GroupElement(tag.EncodedUnderlyingSecurityDesc), quickfix.GroupElement(tag.UnderlyingCPProgram), quickfix.GroupElement(tag.UnderlyingCPRegType), quickfix.GroupElement(tag.UnderlyingCurrency), quickfix.GroupElement(tag.UnderlyingQty), quickfix.GroupElement(tag.UnderlyingPx), quickfix.GroupElement(tag.UnderlyingDirtyPrice), quickfix.GroupElement(tag.UnderlyingEndPrice), quickfix.GroupElement(tag.UnderlyingStartValue), quickfix.GroupElement(tag.UnderlyingCurrentValue), quickfix.GroupElement(tag.UnderlyingEndValue), NewNoUnderlyingStipsRepeatingGroup(), quickfix.GroupElement(tag.UnderlyingAllocationPercent), quickfix.GroupElement(tag.UnderlyingSettlementType), quickfix.GroupElement(tag.UnderlyingCashAmount), quickfix.GroupElement(tag.UnderlyingCashType), quickfix.GroupElement(tag.UnderlyingUnitOfMeasure), quickfix.GroupElement(tag.UnderlyingTimeUnit), quickfix.GroupElement(tag.UnderlyingCapValue), NewNoUndlyInstrumentPartiesRepeatingGroup(), quickfix.GroupElement(tag.UnderlyingSettlMethod), quickfix.GroupElement(tag.UnderlyingAdjustedQuantity), quickfix.GroupElement(tag.UnderlyingFXRate), quickfix.GroupElement(tag.UnderlyingFXRateCalc)})} +} + +//Add create and append a new NoUnderlyings to this group +func (m NoUnderlyingsRepeatingGroup) Add() NoUnderlyings { + g := m.RepeatingGroup.Add() + return NoUnderlyings{g} +} + +//Get returns the ith NoUnderlyings in the NoUnderlyingsRepeatinGroup +func (m NoUnderlyingsRepeatingGroup) Get(i int) NoUnderlyings { + return NoUnderlyings{m.RepeatingGroup.Get(i)} +} + +//NoEvents is a repeating group element, Tag 864 +type NoEvents struct { + quickfix.Group +} + +//SetEventType sets EventType, Tag 865 +func (m NoEvents) SetEventType(v int) { + m.Set(field.NewEventType(v)) +} + +//SetEventDate sets EventDate, Tag 866 +func (m NoEvents) SetEventDate(v string) { + m.Set(field.NewEventDate(v)) +} + +//SetEventPx sets EventPx, Tag 867 +func (m NoEvents) SetEventPx(v float64) { + m.Set(field.NewEventPx(v)) +} + +//SetEventText sets EventText, Tag 868 +func (m NoEvents) SetEventText(v string) { + m.Set(field.NewEventText(v)) +} + +//GetEventType gets EventType, Tag 865 +func (m NoEvents) GetEventType() (f field.EventTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventDate gets EventDate, Tag 866 +func (m NoEvents) GetEventDate() (f field.EventDateField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventPx gets EventPx, Tag 867 +func (m NoEvents) GetEventPx() (f field.EventPxField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetEventText gets EventText, Tag 868 +func (m NoEvents) GetEventText() (f field.EventTextField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasEventType returns true if EventType is present, Tag 865 +func (m NoEvents) HasEventType() bool { + return m.Has(tag.EventType) +} + +//HasEventDate returns true if EventDate is present, Tag 866 +func (m NoEvents) HasEventDate() bool { + return m.Has(tag.EventDate) +} + +//HasEventPx returns true if EventPx is present, Tag 867 +func (m NoEvents) HasEventPx() bool { + return m.Has(tag.EventPx) +} + +//HasEventText returns true if EventText is present, Tag 868 +func (m NoEvents) HasEventText() bool { + return m.Has(tag.EventText) +} + +//NoEventsRepeatingGroup is a repeating group, Tag 864 +type NoEventsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoEventsRepeatingGroup returns an initialized, NoEventsRepeatingGroup +func NewNoEventsRepeatingGroup() NoEventsRepeatingGroup { + return NoEventsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoEvents, + quickfix.GroupTemplate{quickfix.GroupElement(tag.EventType), quickfix.GroupElement(tag.EventDate), quickfix.GroupElement(tag.EventPx), quickfix.GroupElement(tag.EventText)})} +} + +//Add create and append a new NoEvents to this group +func (m NoEventsRepeatingGroup) Add() NoEvents { + g := m.RepeatingGroup.Add() + return NoEvents{g} +} + +//Get returns the ith NoEvents in the NoEventsRepeatinGroup +func (m NoEventsRepeatingGroup) Get(i int) NoEvents { + return NoEvents{m.RepeatingGroup.Get(i)} +} + +//NoInstrumentParties is a repeating group element, Tag 1018 +type NoInstrumentParties struct { + quickfix.Group +} + +//SetInstrumentPartyID sets InstrumentPartyID, Tag 1019 +func (m NoInstrumentParties) SetInstrumentPartyID(v string) { + m.Set(field.NewInstrumentPartyID(v)) +} + +//SetInstrumentPartyIDSource sets InstrumentPartyIDSource, Tag 1050 +func (m NoInstrumentParties) SetInstrumentPartyIDSource(v string) { + m.Set(field.NewInstrumentPartyIDSource(v)) +} + +//SetInstrumentPartyRole sets InstrumentPartyRole, Tag 1051 +func (m NoInstrumentParties) SetInstrumentPartyRole(v int) { + m.Set(field.NewInstrumentPartyRole(v)) +} + +//SetNoInstrumentPartySubIDs sets NoInstrumentPartySubIDs, Tag 1052 +func (m NoInstrumentParties) SetNoInstrumentPartySubIDs(f NoInstrumentPartySubIDsRepeatingGroup) { + m.SetGroup(f) +} + +//GetInstrumentPartyID gets InstrumentPartyID, Tag 1019 +func (m NoInstrumentParties) GetInstrumentPartyID() (f field.InstrumentPartyIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrumentPartyIDSource gets InstrumentPartyIDSource, Tag 1050 +func (m NoInstrumentParties) GetInstrumentPartyIDSource() (f field.InstrumentPartyIDSourceField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrumentPartyRole gets InstrumentPartyRole, Tag 1051 +func (m NoInstrumentParties) GetInstrumentPartyRole() (f field.InstrumentPartyRoleField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetNoInstrumentPartySubIDs gets NoInstrumentPartySubIDs, Tag 1052 +func (m NoInstrumentParties) GetNoInstrumentPartySubIDs() (NoInstrumentPartySubIDsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoInstrumentPartySubIDsRepeatingGroup() + err := m.GetGroup(f) + return f, err +} + +//HasInstrumentPartyID returns true if InstrumentPartyID is present, Tag 1019 +func (m NoInstrumentParties) HasInstrumentPartyID() bool { + return m.Has(tag.InstrumentPartyID) +} + +//HasInstrumentPartyIDSource returns true if InstrumentPartyIDSource is present, Tag 1050 +func (m NoInstrumentParties) HasInstrumentPartyIDSource() bool { + return m.Has(tag.InstrumentPartyIDSource) +} + +//HasInstrumentPartyRole returns true if InstrumentPartyRole is present, Tag 1051 +func (m NoInstrumentParties) HasInstrumentPartyRole() bool { + return m.Has(tag.InstrumentPartyRole) +} + +//HasNoInstrumentPartySubIDs returns true if NoInstrumentPartySubIDs is present, Tag 1052 +func (m NoInstrumentParties) HasNoInstrumentPartySubIDs() bool { + return m.Has(tag.NoInstrumentPartySubIDs) +} + +//NoInstrumentPartySubIDs is a repeating group element, Tag 1052 +type NoInstrumentPartySubIDs struct { + quickfix.Group +} + +//SetInstrumentPartySubID sets InstrumentPartySubID, Tag 1053 +func (m NoInstrumentPartySubIDs) SetInstrumentPartySubID(v string) { + m.Set(field.NewInstrumentPartySubID(v)) +} + +//SetInstrumentPartySubIDType sets InstrumentPartySubIDType, Tag 1054 +func (m NoInstrumentPartySubIDs) SetInstrumentPartySubIDType(v int) { + m.Set(field.NewInstrumentPartySubIDType(v)) +} + +//GetInstrumentPartySubID gets InstrumentPartySubID, Tag 1053 +func (m NoInstrumentPartySubIDs) GetInstrumentPartySubID() (f field.InstrumentPartySubIDField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//GetInstrumentPartySubIDType gets InstrumentPartySubIDType, Tag 1054 +func (m NoInstrumentPartySubIDs) GetInstrumentPartySubIDType() (f field.InstrumentPartySubIDTypeField, err quickfix.MessageRejectError) { + err = m.Get(&f) + return +} + +//HasInstrumentPartySubID returns true if InstrumentPartySubID is present, Tag 1053 +func (m NoInstrumentPartySubIDs) HasInstrumentPartySubID() bool { + return m.Has(tag.InstrumentPartySubID) +} + +//HasInstrumentPartySubIDType returns true if InstrumentPartySubIDType is present, Tag 1054 +func (m NoInstrumentPartySubIDs) HasInstrumentPartySubIDType() bool { + return m.Has(tag.InstrumentPartySubIDType) +} + +//NoInstrumentPartySubIDsRepeatingGroup is a repeating group, Tag 1052 +type NoInstrumentPartySubIDsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoInstrumentPartySubIDsRepeatingGroup returns an initialized, NoInstrumentPartySubIDsRepeatingGroup +func NewNoInstrumentPartySubIDsRepeatingGroup() NoInstrumentPartySubIDsRepeatingGroup { + return NoInstrumentPartySubIDsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoInstrumentPartySubIDs, + quickfix.GroupTemplate{quickfix.GroupElement(tag.InstrumentPartySubID), quickfix.GroupElement(tag.InstrumentPartySubIDType)})} +} + +//Add create and append a new NoInstrumentPartySubIDs to this group +func (m NoInstrumentPartySubIDsRepeatingGroup) Add() NoInstrumentPartySubIDs { + g := m.RepeatingGroup.Add() + return NoInstrumentPartySubIDs{g} +} + +//Get returns the ith NoInstrumentPartySubIDs in the NoInstrumentPartySubIDsRepeatinGroup +func (m NoInstrumentPartySubIDsRepeatingGroup) Get(i int) NoInstrumentPartySubIDs { + return NoInstrumentPartySubIDs{m.RepeatingGroup.Get(i)} +} + +//NoInstrumentPartiesRepeatingGroup is a repeating group, Tag 1018 +type NoInstrumentPartiesRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoInstrumentPartiesRepeatingGroup returns an initialized, NoInstrumentPartiesRepeatingGroup +func NewNoInstrumentPartiesRepeatingGroup() NoInstrumentPartiesRepeatingGroup { + return NoInstrumentPartiesRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoInstrumentParties, + quickfix.GroupTemplate{quickfix.GroupElement(tag.InstrumentPartyID), quickfix.GroupElement(tag.InstrumentPartyIDSource), quickfix.GroupElement(tag.InstrumentPartyRole), NewNoInstrumentPartySubIDsRepeatingGroup()})} +} + +//Add create and append a new NoInstrumentParties to this group +func (m NoInstrumentPartiesRepeatingGroup) Add() NoInstrumentParties { + g := m.RepeatingGroup.Add() + return NoInstrumentParties{g} +} + +//Get returns the ith NoInstrumentParties in the NoInstrumentPartiesRepeatinGroup +func (m NoInstrumentPartiesRepeatingGroup) Get(i int) NoInstrumentParties { + return NoInstrumentParties{m.RepeatingGroup.Get(i)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix_boolean.go b/vendor/github.com/quickfixgo/quickfix/fix_boolean.go new file mode 100644 index 0000000..5cf53b5 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix_boolean.go @@ -0,0 +1,32 @@ +package quickfix + +import ( + "errors" +) + +//FIXBoolean is a FIX Boolean value, implements FieldValue. +type FIXBoolean bool + +//Bool converts the FIXBoolean value to bool +func (f FIXBoolean) Bool() bool { return bool(f) } + +func (f *FIXBoolean) Read(bytes []byte) error { + switch string(bytes) { + case "Y": + *f = true + case "N": + *f = false + default: + return errors.New("Invalid Value for bool: " + string(bytes)) + } + + return nil +} + +func (f FIXBoolean) Write() []byte { + if f { + return []byte("Y") + } + + return []byte("N") +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix_float.go b/vendor/github.com/quickfixgo/quickfix/fix_float.go new file mode 100644 index 0000000..1012293 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix_float.go @@ -0,0 +1,38 @@ +package quickfix + +import ( + "fmt" + "strconv" +) + +//FIXFloat is a FIX Float Value, implements FieldValue +type FIXFloat float64 + +//Float64 converts the FIXFloat value to float64 +func (f FIXFloat) Float64() float64 { return float64(f) } + +func (f *FIXFloat) Read(bytes []byte) error { + val, err := strconv.ParseFloat(string(bytes), 64) + if err != nil { + return err + } + + //strconv allows values like "+100.00", which is not allowed for FIX float types + for _, b := range bytes { + if b != '.' && b != '-' && !isDecimal(b) { + return fmt.Errorf("invalid value %v", string(bytes)) + } + } + + *f = FIXFloat(val) + + return err +} + +func (f FIXFloat) Write() []byte { + return []byte(strconv.FormatFloat(float64(f), 'f', -1, 64)) +} + +func isDecimal(b byte) bool { + return '0' <= b && b <= '9' +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix_int.go b/vendor/github.com/quickfixgo/quickfix/fix_int.go new file mode 100644 index 0000000..3185d6d --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix_int.go @@ -0,0 +1,63 @@ +package quickfix + +import ( + "errors" + "strconv" +) + +const ( + //- + asciiMinus = 45 + + //ascii numbers 0-9 + ascii0 = 48 + ascii9 = 57 +) + +//atoi is similar to the function in strconv, but is tuned for ints appearing in FIX field types. +func atoi(d []byte) (int, error) { + if d[0] == asciiMinus { + n, err := parseUInt(d[1:]) + return (-1) * n, err + } + + return parseUInt(d) +} + +//parseUInt is similar to the function in strconv, but is tuned for ints appearing in FIX field types. +func parseUInt(d []byte) (n int, err error) { + if len(d) == 0 { + err = errors.New("empty bytes") + return + } + + for _, dec := range d { + if dec < ascii0 || dec > ascii9 { + err = errors.New("invalid format") + return + } + + n = n*10 + (int(dec) - ascii0) + } + + return +} + +//FIXInt is a FIX Int Value, implements FieldValue +type FIXInt int + +//Int converts the FIXInt value to int +func (f FIXInt) Int() int { return int(f) } + +func (f *FIXInt) Read(bytes []byte) error { + i, err := atoi(bytes) + if err != nil { + return err + } + *f = FIXInt(i) + return nil +} + +func (f FIXInt) Write() []byte { + return []byte(strconv.Itoa(int(f))) +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix_string.go b/vendor/github.com/quickfixgo/quickfix/fix_string.go new file mode 100644 index 0000000..bfa54ae --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix_string.go @@ -0,0 +1,17 @@ +package quickfix + +//FIXString is a FIX String Value, implements FieldValue +type FIXString string + +func (f FIXString) String() string { + return string(f) +} + +func (f *FIXString) Read(bytes []byte) (err error) { + *f = FIXString(bytes) + return +} + +func (f FIXString) Write() []byte { + return []byte(f) +} diff --git a/vendor/github.com/quickfixgo/quickfix/fix_utc_timestamp.go b/vendor/github.com/quickfixgo/quickfix/fix_utc_timestamp.go new file mode 100644 index 0000000..83b6559 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fix_utc_timestamp.go @@ -0,0 +1,40 @@ +package quickfix + +import ( + "time" +) + +//FIXUTCTimestamp is a FIX UTC Timestamp value, implements FieldValue +type FIXUTCTimestamp struct { + time.Time + NoMillis bool +} + +const ( + utcTimestampFormat = "20060102-15:04:05.000" + utcTimestampNoMillisFormat = "20060102-15:04:05" +) + +func (f *FIXUTCTimestamp) Read(bytes []byte) error { + var err error + //with millisecs + if f.Time, err = time.Parse(utcTimestampFormat, string(bytes)); err == nil { + return nil + } + + //w/o millisecs + if f.Time, err = time.Parse(utcTimestampNoMillisFormat, string(bytes)); err != nil { + return err + } + + f.NoMillis = true + return nil +} + +func (f FIXUTCTimestamp) Write() []byte { + if f.NoMillis { + return []byte(f.UTC().Format(utcTimestampNoMillisFormat)) + } + + return []byte(f.UTC().Format(utcTimestampFormat)) +} diff --git a/vendor/github.com/quickfixgo/quickfix/fixt11/header.generated.go b/vendor/github.com/quickfixgo/quickfix/fixt11/header.generated.go new file mode 100644 index 0000000..8b9eb67 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fixt11/header.generated.go @@ -0,0 +1,562 @@ +package fixt11 + +import ( + "time" + + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/tag" +) + +//Header is the fixt11 Header type +type Header struct { + quickfix.Header +} + +//NewHeader returns a new, initialized Header instance +func NewHeader() (h Header) { + h.Init() + h.SetBeginString("FIXT.1.1") + return +} + +//SetBeginString sets BeginString, Tag 8 +func (h Header) SetBeginString(v string) { + h.Set(field.NewBeginString(v)) +} + +//SetBodyLength sets BodyLength, Tag 9 +func (h Header) SetBodyLength(v int) { + h.Set(field.NewBodyLength(v)) +} + +//SetMsgSeqNum sets MsgSeqNum, Tag 34 +func (h Header) SetMsgSeqNum(v int) { + h.Set(field.NewMsgSeqNum(v)) +} + +//SetMsgType sets MsgType, Tag 35 +func (h Header) SetMsgType(v string) { + h.Set(field.NewMsgType(v)) +} + +//SetPossDupFlag sets PossDupFlag, Tag 43 +func (h Header) SetPossDupFlag(v bool) { + h.Set(field.NewPossDupFlag(v)) +} + +//SetSenderCompID sets SenderCompID, Tag 49 +func (h Header) SetSenderCompID(v string) { + h.Set(field.NewSenderCompID(v)) +} + +//SetSenderSubID sets SenderSubID, Tag 50 +func (h Header) SetSenderSubID(v string) { + h.Set(field.NewSenderSubID(v)) +} + +//SetSendingTime sets SendingTime, Tag 52 +func (h Header) SetSendingTime(v time.Time) { + h.Set(field.NewSendingTime(v)) +} + +//SetTargetCompID sets TargetCompID, Tag 56 +func (h Header) SetTargetCompID(v string) { + h.Set(field.NewTargetCompID(v)) +} + +//SetTargetSubID sets TargetSubID, Tag 57 +func (h Header) SetTargetSubID(v string) { + h.Set(field.NewTargetSubID(v)) +} + +//SetSecureDataLen sets SecureDataLen, Tag 90 +func (h Header) SetSecureDataLen(v int) { + h.Set(field.NewSecureDataLen(v)) +} + +//SetSecureData sets SecureData, Tag 91 +func (h Header) SetSecureData(v string) { + h.Set(field.NewSecureData(v)) +} + +//SetPossResend sets PossResend, Tag 97 +func (h Header) SetPossResend(v bool) { + h.Set(field.NewPossResend(v)) +} + +//SetOnBehalfOfCompID sets OnBehalfOfCompID, Tag 115 +func (h Header) SetOnBehalfOfCompID(v string) { + h.Set(field.NewOnBehalfOfCompID(v)) +} + +//SetOnBehalfOfSubID sets OnBehalfOfSubID, Tag 116 +func (h Header) SetOnBehalfOfSubID(v string) { + h.Set(field.NewOnBehalfOfSubID(v)) +} + +//SetOrigSendingTime sets OrigSendingTime, Tag 122 +func (h Header) SetOrigSendingTime(v time.Time) { + h.Set(field.NewOrigSendingTime(v)) +} + +//SetDeliverToCompID sets DeliverToCompID, Tag 128 +func (h Header) SetDeliverToCompID(v string) { + h.Set(field.NewDeliverToCompID(v)) +} + +//SetDeliverToSubID sets DeliverToSubID, Tag 129 +func (h Header) SetDeliverToSubID(v string) { + h.Set(field.NewDeliverToSubID(v)) +} + +//SetSenderLocationID sets SenderLocationID, Tag 142 +func (h Header) SetSenderLocationID(v string) { + h.Set(field.NewSenderLocationID(v)) +} + +//SetTargetLocationID sets TargetLocationID, Tag 143 +func (h Header) SetTargetLocationID(v string) { + h.Set(field.NewTargetLocationID(v)) +} + +//SetOnBehalfOfLocationID sets OnBehalfOfLocationID, Tag 144 +func (h Header) SetOnBehalfOfLocationID(v string) { + h.Set(field.NewOnBehalfOfLocationID(v)) +} + +//SetDeliverToLocationID sets DeliverToLocationID, Tag 145 +func (h Header) SetDeliverToLocationID(v string) { + h.Set(field.NewDeliverToLocationID(v)) +} + +//SetXmlDataLen sets XmlDataLen, Tag 212 +func (h Header) SetXmlDataLen(v int) { + h.Set(field.NewXmlDataLen(v)) +} + +//SetXmlData sets XmlData, Tag 213 +func (h Header) SetXmlData(v string) { + h.Set(field.NewXmlData(v)) +} + +//SetMessageEncoding sets MessageEncoding, Tag 347 +func (h Header) SetMessageEncoding(v string) { + h.Set(field.NewMessageEncoding(v)) +} + +//SetLastMsgSeqNumProcessed sets LastMsgSeqNumProcessed, Tag 369 +func (h Header) SetLastMsgSeqNumProcessed(v int) { + h.Set(field.NewLastMsgSeqNumProcessed(v)) +} + +//SetNoHops sets NoHops, Tag 627 +func (h Header) SetNoHops(f NoHopsRepeatingGroup) { + h.SetGroup(f) +} + +//SetApplVerID sets ApplVerID, Tag 1128 +func (h Header) SetApplVerID(v string) { + h.Set(field.NewApplVerID(v)) +} + +//SetCstmApplVerID sets CstmApplVerID, Tag 1129 +func (h Header) SetCstmApplVerID(v string) { + h.Set(field.NewCstmApplVerID(v)) +} + +//GetBeginString gets BeginString, Tag 8 +func (h Header) GetBeginString() (f field.BeginStringField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetBodyLength gets BodyLength, Tag 9 +func (h Header) GetBodyLength() (f field.BodyLengthField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetMsgSeqNum gets MsgSeqNum, Tag 34 +func (h Header) GetMsgSeqNum() (f field.MsgSeqNumField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetMsgType gets MsgType, Tag 35 +func (h Header) GetMsgType() (f field.MsgTypeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetPossDupFlag gets PossDupFlag, Tag 43 +func (h Header) GetPossDupFlag() (f field.PossDupFlagField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSenderCompID gets SenderCompID, Tag 49 +func (h Header) GetSenderCompID() (f field.SenderCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSenderSubID gets SenderSubID, Tag 50 +func (h Header) GetSenderSubID() (f field.SenderSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSendingTime gets SendingTime, Tag 52 +func (h Header) GetSendingTime() (f field.SendingTimeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetTargetCompID gets TargetCompID, Tag 56 +func (h Header) GetTargetCompID() (f field.TargetCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetTargetSubID gets TargetSubID, Tag 57 +func (h Header) GetTargetSubID() (f field.TargetSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSecureDataLen gets SecureDataLen, Tag 90 +func (h Header) GetSecureDataLen() (f field.SecureDataLenField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSecureData gets SecureData, Tag 91 +func (h Header) GetSecureData() (f field.SecureDataField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetPossResend gets PossResend, Tag 97 +func (h Header) GetPossResend() (f field.PossResendField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOnBehalfOfCompID gets OnBehalfOfCompID, Tag 115 +func (h Header) GetOnBehalfOfCompID() (f field.OnBehalfOfCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOnBehalfOfSubID gets OnBehalfOfSubID, Tag 116 +func (h Header) GetOnBehalfOfSubID() (f field.OnBehalfOfSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOrigSendingTime gets OrigSendingTime, Tag 122 +func (h Header) GetOrigSendingTime() (f field.OrigSendingTimeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetDeliverToCompID gets DeliverToCompID, Tag 128 +func (h Header) GetDeliverToCompID() (f field.DeliverToCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetDeliverToSubID gets DeliverToSubID, Tag 129 +func (h Header) GetDeliverToSubID() (f field.DeliverToSubIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetSenderLocationID gets SenderLocationID, Tag 142 +func (h Header) GetSenderLocationID() (f field.SenderLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetTargetLocationID gets TargetLocationID, Tag 143 +func (h Header) GetTargetLocationID() (f field.TargetLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetOnBehalfOfLocationID gets OnBehalfOfLocationID, Tag 144 +func (h Header) GetOnBehalfOfLocationID() (f field.OnBehalfOfLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetDeliverToLocationID gets DeliverToLocationID, Tag 145 +func (h Header) GetDeliverToLocationID() (f field.DeliverToLocationIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetXmlDataLen gets XmlDataLen, Tag 212 +func (h Header) GetXmlDataLen() (f field.XmlDataLenField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetXmlData gets XmlData, Tag 213 +func (h Header) GetXmlData() (f field.XmlDataField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetMessageEncoding gets MessageEncoding, Tag 347 +func (h Header) GetMessageEncoding() (f field.MessageEncodingField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetLastMsgSeqNumProcessed gets LastMsgSeqNumProcessed, Tag 369 +func (h Header) GetLastMsgSeqNumProcessed() (f field.LastMsgSeqNumProcessedField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetNoHops gets NoHops, Tag 627 +func (h Header) GetNoHops() (NoHopsRepeatingGroup, quickfix.MessageRejectError) { + f := NewNoHopsRepeatingGroup() + err := h.GetGroup(f) + return f, err +} + +//GetApplVerID gets ApplVerID, Tag 1128 +func (h Header) GetApplVerID() (f field.ApplVerIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetCstmApplVerID gets CstmApplVerID, Tag 1129 +func (h Header) GetCstmApplVerID() (f field.CstmApplVerIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//HasBeginString returns true if BeginString is present, Tag 8 +func (h Header) HasBeginString() bool { + return h.Has(tag.BeginString) +} + +//HasBodyLength returns true if BodyLength is present, Tag 9 +func (h Header) HasBodyLength() bool { + return h.Has(tag.BodyLength) +} + +//HasMsgSeqNum returns true if MsgSeqNum is present, Tag 34 +func (h Header) HasMsgSeqNum() bool { + return h.Has(tag.MsgSeqNum) +} + +//HasMsgType returns true if MsgType is present, Tag 35 +func (h Header) HasMsgType() bool { + return h.Has(tag.MsgType) +} + +//HasPossDupFlag returns true if PossDupFlag is present, Tag 43 +func (h Header) HasPossDupFlag() bool { + return h.Has(tag.PossDupFlag) +} + +//HasSenderCompID returns true if SenderCompID is present, Tag 49 +func (h Header) HasSenderCompID() bool { + return h.Has(tag.SenderCompID) +} + +//HasSenderSubID returns true if SenderSubID is present, Tag 50 +func (h Header) HasSenderSubID() bool { + return h.Has(tag.SenderSubID) +} + +//HasSendingTime returns true if SendingTime is present, Tag 52 +func (h Header) HasSendingTime() bool { + return h.Has(tag.SendingTime) +} + +//HasTargetCompID returns true if TargetCompID is present, Tag 56 +func (h Header) HasTargetCompID() bool { + return h.Has(tag.TargetCompID) +} + +//HasTargetSubID returns true if TargetSubID is present, Tag 57 +func (h Header) HasTargetSubID() bool { + return h.Has(tag.TargetSubID) +} + +//HasSecureDataLen returns true if SecureDataLen is present, Tag 90 +func (h Header) HasSecureDataLen() bool { + return h.Has(tag.SecureDataLen) +} + +//HasSecureData returns true if SecureData is present, Tag 91 +func (h Header) HasSecureData() bool { + return h.Has(tag.SecureData) +} + +//HasPossResend returns true if PossResend is present, Tag 97 +func (h Header) HasPossResend() bool { + return h.Has(tag.PossResend) +} + +//HasOnBehalfOfCompID returns true if OnBehalfOfCompID is present, Tag 115 +func (h Header) HasOnBehalfOfCompID() bool { + return h.Has(tag.OnBehalfOfCompID) +} + +//HasOnBehalfOfSubID returns true if OnBehalfOfSubID is present, Tag 116 +func (h Header) HasOnBehalfOfSubID() bool { + return h.Has(tag.OnBehalfOfSubID) +} + +//HasOrigSendingTime returns true if OrigSendingTime is present, Tag 122 +func (h Header) HasOrigSendingTime() bool { + return h.Has(tag.OrigSendingTime) +} + +//HasDeliverToCompID returns true if DeliverToCompID is present, Tag 128 +func (h Header) HasDeliverToCompID() bool { + return h.Has(tag.DeliverToCompID) +} + +//HasDeliverToSubID returns true if DeliverToSubID is present, Tag 129 +func (h Header) HasDeliverToSubID() bool { + return h.Has(tag.DeliverToSubID) +} + +//HasSenderLocationID returns true if SenderLocationID is present, Tag 142 +func (h Header) HasSenderLocationID() bool { + return h.Has(tag.SenderLocationID) +} + +//HasTargetLocationID returns true if TargetLocationID is present, Tag 143 +func (h Header) HasTargetLocationID() bool { + return h.Has(tag.TargetLocationID) +} + +//HasOnBehalfOfLocationID returns true if OnBehalfOfLocationID is present, Tag 144 +func (h Header) HasOnBehalfOfLocationID() bool { + return h.Has(tag.OnBehalfOfLocationID) +} + +//HasDeliverToLocationID returns true if DeliverToLocationID is present, Tag 145 +func (h Header) HasDeliverToLocationID() bool { + return h.Has(tag.DeliverToLocationID) +} + +//HasXmlDataLen returns true if XmlDataLen is present, Tag 212 +func (h Header) HasXmlDataLen() bool { + return h.Has(tag.XmlDataLen) +} + +//HasXmlData returns true if XmlData is present, Tag 213 +func (h Header) HasXmlData() bool { + return h.Has(tag.XmlData) +} + +//HasMessageEncoding returns true if MessageEncoding is present, Tag 347 +func (h Header) HasMessageEncoding() bool { + return h.Has(tag.MessageEncoding) +} + +//HasLastMsgSeqNumProcessed returns true if LastMsgSeqNumProcessed is present, Tag 369 +func (h Header) HasLastMsgSeqNumProcessed() bool { + return h.Has(tag.LastMsgSeqNumProcessed) +} + +//HasNoHops returns true if NoHops is present, Tag 627 +func (h Header) HasNoHops() bool { + return h.Has(tag.NoHops) +} + +//HasApplVerID returns true if ApplVerID is present, Tag 1128 +func (h Header) HasApplVerID() bool { + return h.Has(tag.ApplVerID) +} + +//HasCstmApplVerID returns true if CstmApplVerID is present, Tag 1129 +func (h Header) HasCstmApplVerID() bool { + return h.Has(tag.CstmApplVerID) +} + +//NoHops is a repeating group element, Tag 627 +type NoHops struct { + quickfix.Group +} + +//SetHopCompID sets HopCompID, Tag 628 +func (h NoHops) SetHopCompID(v string) { + h.Set(field.NewHopCompID(v)) +} + +//SetHopSendingTime sets HopSendingTime, Tag 629 +func (h NoHops) SetHopSendingTime(v time.Time) { + h.Set(field.NewHopSendingTime(v)) +} + +//SetHopRefID sets HopRefID, Tag 630 +func (h NoHops) SetHopRefID(v int) { + h.Set(field.NewHopRefID(v)) +} + +//GetHopCompID gets HopCompID, Tag 628 +func (h NoHops) GetHopCompID() (f field.HopCompIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetHopSendingTime gets HopSendingTime, Tag 629 +func (h NoHops) GetHopSendingTime() (f field.HopSendingTimeField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//GetHopRefID gets HopRefID, Tag 630 +func (h NoHops) GetHopRefID() (f field.HopRefIDField, err quickfix.MessageRejectError) { + err = h.Get(&f) + return +} + +//HasHopCompID returns true if HopCompID is present, Tag 628 +func (h NoHops) HasHopCompID() bool { + return h.Has(tag.HopCompID) +} + +//HasHopSendingTime returns true if HopSendingTime is present, Tag 629 +func (h NoHops) HasHopSendingTime() bool { + return h.Has(tag.HopSendingTime) +} + +//HasHopRefID returns true if HopRefID is present, Tag 630 +func (h NoHops) HasHopRefID() bool { + return h.Has(tag.HopRefID) +} + +//NoHopsRepeatingGroup is a repeating group, Tag 627 +type NoHopsRepeatingGroup struct { + *quickfix.RepeatingGroup +} + +//NewNoHopsRepeatingGroup returns an initialized, NoHopsRepeatingGroup +func NewNoHopsRepeatingGroup() NoHopsRepeatingGroup { + return NoHopsRepeatingGroup{ + quickfix.NewRepeatingGroup(tag.NoHops, + quickfix.GroupTemplate{quickfix.GroupElement(tag.HopCompID), quickfix.GroupElement(tag.HopSendingTime), quickfix.GroupElement(tag.HopRefID)})} +} + +//Add create and append a new NoHops to this group +func (h NoHopsRepeatingGroup) Add() NoHops { + g := h.RepeatingGroup.Add() + return NoHops{g} +} + +//Get returns the ith NoHops in the NoHopsRepeatinGroup +func (h NoHopsRepeatingGroup) Get(i int) NoHops { + return NoHops{h.RepeatingGroup.Get(i)} +} diff --git a/vendor/github.com/quickfixgo/quickfix/fixt11/trailer.generated.go b/vendor/github.com/quickfixgo/quickfix/fixt11/trailer.generated.go new file mode 100644 index 0000000..cbff27d --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/fixt11/trailer.generated.go @@ -0,0 +1,60 @@ +package fixt11 + +import ( + "github.com/quickfixgo/quickfix" + "github.com/quickfixgo/quickfix/field" + "github.com/quickfixgo/quickfix/tag" +) + +//Trailer is the fixt11 Trailer type +type Trailer struct { + quickfix.Trailer +} + +//SetCheckSum sets CheckSum, Tag 10 +func (t Trailer) SetCheckSum(v string) { + t.Set(field.NewCheckSum(v)) +} + +//SetSignature sets Signature, Tag 89 +func (t Trailer) SetSignature(v string) { + t.Set(field.NewSignature(v)) +} + +//SetSignatureLength sets SignatureLength, Tag 93 +func (t Trailer) SetSignatureLength(v int) { + t.Set(field.NewSignatureLength(v)) +} + +//GetCheckSum gets CheckSum, Tag 10 +func (t Trailer) GetCheckSum() (f field.CheckSumField, err quickfix.MessageRejectError) { + err = t.Get(&f) + return +} + +//GetSignature gets Signature, Tag 89 +func (t Trailer) GetSignature() (f field.SignatureField, err quickfix.MessageRejectError) { + err = t.Get(&f) + return +} + +//GetSignatureLength gets SignatureLength, Tag 93 +func (t Trailer) GetSignatureLength() (f field.SignatureLengthField, err quickfix.MessageRejectError) { + err = t.Get(&f) + return +} + +//HasCheckSum returns true if CheckSum is present, Tag 10 +func (t Trailer) HasCheckSum() bool { + return t.Has(tag.CheckSum) +} + +//HasSignature returns true if Signature is present, Tag 89 +func (t Trailer) HasSignature() bool { + return t.Has(tag.Signature) +} + +//HasSignatureLength returns true if SignatureLength is present, Tag 93 +func (t Trailer) HasSignatureLength() bool { + return t.Has(tag.SignatureLength) +} diff --git a/vendor/github.com/quickfixgo/quickfix/in_session.go b/vendor/github.com/quickfixgo/quickfix/in_session.go new file mode 100644 index 0000000..68d5721 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/in_session.go @@ -0,0 +1,358 @@ +package quickfix + +import ( + "time" + + "github.com/quickfixgo/quickfix/enum" + "github.com/quickfixgo/quickfix/internal" +) + +type inSession struct{ loggedOn } + +func (state inSession) String() string { return "In Session" } + +func (state inSession) FixMsgIn(session *session, msg Message) sessionState { + var msgType FIXString + if err := msg.Header.GetField(tagMsgType, &msgType); err != nil { + return handleStateError(session, err) + } + + switch string(msgType) { + case enum.MsgType_LOGON: + if err := session.handleLogon(msg); err != nil { + if err := session.initiateLogout(""); err != nil { + return handleStateError(session, err) + } + return logoutState{} + } + + return state + case enum.MsgType_LOGOUT: + return state.handleLogout(session, msg) + case enum.MsgType_RESEND_REQUEST: + return state.handleResendRequest(session, msg) + case enum.MsgType_SEQUENCE_RESET: + return state.handleSequenceReset(session, msg) + case enum.MsgType_TEST_REQUEST: + return state.handleTestRequest(session, msg) + default: + if err := session.verify(msg); err != nil { + return state.processReject(session, msg, err) + } + } + + if err := session.store.IncrNextTargetMsgSeqNum(); err != nil { + return handleStateError(session, err) + } + + return state +} + +func (state inSession) Timeout(session *session, event internal.Event) (nextState sessionState) { + switch event { + case internal.NeedHeartbeat: + heartBt := NewMessage() + heartBt.Header.SetField(tagMsgType, FIXString("0")) + if err := session.send(heartBt); err != nil { + return handleStateError(session, err) + } + case internal.PeerTimeout: + testReq := NewMessage() + testReq.Header.SetField(tagMsgType, FIXString("1")) + testReq.Body.SetField(tagTestReqID, FIXString("TEST")) + if err := session.send(testReq); err != nil { + return handleStateError(session, err) + } + session.log.OnEvent("Sent test request TEST") + session.peerTimer.Reset(time.Duration(float64(1.2) * float64(session.HeartBtInt))) + return pendingTimeout{state} + } + + return state +} + +func (state inSession) handleLogout(session *session, msg Message) (nextState sessionState) { + if err := session.verifySelect(msg, false, false); err != nil { + return state.processReject(session, msg, err) + } + + if session.IsLoggedOn() { + session.log.OnEvent("Received logout request") + session.log.OnEvent("Sending logout response") + + if err := session.sendLogout(""); err != nil { + session.logError(err) + } + } else { + session.log.OnEvent("Received logout response") + } + + if err := session.store.IncrNextTargetMsgSeqNum(); err != nil { + session.logError(err) + } + + if session.ResetOnLogout { + if err := session.dropAndReset(); err != nil { + session.logError(err) + } + } + + return latentState{} +} + +func (state inSession) handleTestRequest(session *session, msg Message) (nextState sessionState) { + if err := session.verify(msg); err != nil { + return state.processReject(session, msg, err) + } + var testReq FIXString + if err := msg.Body.GetField(tagTestReqID, &testReq); err != nil { + session.log.OnEvent("Test Request with no testRequestID") + } else { + heartBt := NewMessage() + heartBt.Header.SetField(tagMsgType, FIXString("0")) + heartBt.Body.SetField(tagTestReqID, testReq) + if err := session.send(heartBt); err != nil { + return handleStateError(session, err) + } + } + + if err := session.store.IncrNextTargetMsgSeqNum(); err != nil { + return handleStateError(session, err) + } + return state +} + +func (state inSession) handleSequenceReset(session *session, msg Message) (nextState sessionState) { + var gapFillFlag FIXBoolean + if msg.Body.Has(tagGapFillFlag) { + if err := msg.Body.GetField(tagGapFillFlag, &gapFillFlag); err != nil { + return state.processReject(session, msg, err) + } + } + + if err := session.verifySelect(msg, bool(gapFillFlag), bool(gapFillFlag)); err != nil { + return state.processReject(session, msg, err) + } + + var newSeqNo FIXInt + if err := msg.Body.GetField(tagNewSeqNo, &newSeqNo); err == nil { + expectedSeqNum := FIXInt(session.store.NextTargetMsgSeqNum()) + session.log.OnEventf("Received SequenceReset FROM: %v TO: %v", expectedSeqNum, newSeqNo) + + switch { + case newSeqNo > expectedSeqNum: + if err := session.store.SetNextTargetMsgSeqNum(int(newSeqNo)); err != nil { + return handleStateError(session, err) + } + case newSeqNo < expectedSeqNum: + //FIXME: to be compliant with legacy tests, do not include tag in reftagid? (11c_NewSeqNoLess) + if err := session.doReject(msg, valueIsIncorrectNoTag()); err != nil { + return handleStateError(session, err) + } + } + } + return state +} + +func (state inSession) handleResendRequest(session *session, msg Message) (nextState sessionState) { + if err := session.verifyIgnoreSeqNumTooHighOrLow(msg); err != nil { + return state.processReject(session, msg, err) + } + + var err error + var beginSeqNoField FIXInt + if err = msg.Body.GetField(tagBeginSeqNo, &beginSeqNoField); err != nil { + return state.processReject(session, msg, RequiredTagMissing(tagBeginSeqNo)) + } + + beginSeqNo := beginSeqNoField + + var endSeqNoField FIXInt + if err = msg.Body.GetField(tagEndSeqNo, &endSeqNoField); err != nil { + return state.processReject(session, msg, RequiredTagMissing(tagEndSeqNo)) + } + + endSeqNo := int(endSeqNoField) + + session.log.OnEventf("Received ResendRequest FROM: %d TO: %d", beginSeqNo, endSeqNo) + expectedSeqNum := session.store.NextSenderMsgSeqNum() + + if (session.sessionID.BeginString >= enum.BeginStringFIX42 && endSeqNo == 0) || + (session.sessionID.BeginString <= enum.BeginStringFIX42 && endSeqNo == 999999) || + (endSeqNo >= expectedSeqNum) { + endSeqNo = expectedSeqNum - 1 + } + + if err := state.resendMessages(session, int(beginSeqNo), endSeqNo); err != nil { + return handleStateError(session, err) + } + + if err := session.checkTargetTooLow(msg); err != nil { + return state + } + + if err := session.checkTargetTooHigh(msg); err != nil { + return state + } + + if err := session.store.IncrNextTargetMsgSeqNum(); err != nil { + return handleStateError(session, err) + } + return state +} + +func (state inSession) resendMessages(session *session, beginSeqNo, endSeqNo int) (err error) { + msgs, err := session.store.GetMessages(beginSeqNo, endSeqNo) + if err != nil { + session.log.OnEventf("error retrieving messages from store: %s", err.Error()) + return + } + + seqNum := beginSeqNo + nextSeqNum := seqNum + for _, msgBytes := range msgs { + msg, _ := ParseMessage(msgBytes) + msgType, _ := msg.Header.GetString(tagMsgType) + sentMessageSeqNum, _ := msg.Header.GetInt(tagMsgSeqNum) + + if isAdminMessageType(msgType) { + nextSeqNum = sentMessageSeqNum + 1 + continue + } + + if seqNum != sentMessageSeqNum { + state.generateSequenceReset(session, seqNum, sentMessageSeqNum) + } + + session.log.OnEventf("Resending Message: %v", sentMessageSeqNum) + if err = session.resend(msg); err != nil { + return + } + + seqNum = sentMessageSeqNum + 1 + nextSeqNum = seqNum + } + + if seqNum != nextSeqNum { // gapfill for catch-up + state.generateSequenceReset(session, seqNum, nextSeqNum) + } + + return +} + +func (state inSession) processReject(session *session, msg Message, rej MessageRejectError) (nextState sessionState) { + switch TypedError := rej.(type) { + case targetTooHigh: + + switch session.State.(type) { + default: + if err := session.doTargetTooHigh(TypedError); err != nil { + return handleStateError(session, err) + } + case resendState: + //assumes target too high reject already sent + } + + session.messageStash[TypedError.ReceivedTarget] = msg + return resendState{} + + case targetTooLow: + return state.doTargetTooLow(session, msg, TypedError) + case incorrectBeginString: + if err := session.initiateLogout(rej.Error()); err != nil { + return handleStateError(session, err) + } + return logoutState{} + } + + switch rej.RejectReason() { + case rejectReasonCompIDProblem, rejectReasonSendingTimeAccuracyProblem: + if err := session.doReject(msg, rej); err != nil { + return handleStateError(session, err) + } + + if err := session.initiateLogout(""); err != nil { + return handleStateError(session, err) + } + return logoutState{} + default: + if err := session.doReject(msg, rej); err != nil { + return handleStateError(session, err) + } + + if err := session.store.IncrNextTargetMsgSeqNum(); err != nil { + return handleStateError(session, err) + } + return state + } +} + +func (state inSession) doTargetTooLow(session *session, msg Message, rej targetTooLow) (nextState sessionState) { + var posDupFlag FIXBoolean + if err := msg.Header.GetField(tagPossDupFlag, &posDupFlag); err == nil && posDupFlag { + + origSendingTime := new(FIXUTCTimestamp) + if err = msg.Header.GetField(tagOrigSendingTime, origSendingTime); err != nil { + if rejErr := session.doReject(msg, RequiredTagMissing(tagOrigSendingTime)); rejErr != nil { + return handleStateError(session, rejErr) + } + return state + } + + sendingTime := new(FIXUTCTimestamp) + if err = msg.Header.GetField(tagSendingTime, sendingTime); err != nil { + return state.processReject(session, msg, err) + } + + if sendingTime.Before(origSendingTime.Time) { + if err := session.doReject(msg, sendingTimeAccuracyProblem()); err != nil { + return handleStateError(session, err) + } + + if err := session.initiateLogout(""); err != nil { + return handleStateError(session, err) + } + return logoutState{} + } + + if appReject := session.fromCallback(msg); appReject != nil { + if err := session.doReject(msg, appReject); err != nil { + return handleStateError(session, err) + } + + if err := session.initiateLogout(""); err != nil { + return handleStateError(session, err) + } + return logoutState{} + } + } else { + if err := session.initiateLogout(rej.Error()); err != nil { + return handleStateError(session, err) + } + return logoutState{} + } + + return state +} + +func (state *inSession) generateSequenceReset(session *session, beginSeqNo int, endSeqNo int) { + sequenceReset := NewMessage() + session.fillDefaultHeader(sequenceReset) + + sequenceReset.Header.SetField(tagMsgType, FIXString("4")) + sequenceReset.Header.SetField(tagMsgSeqNum, FIXInt(beginSeqNo)) + sequenceReset.Header.SetField(tagPossDupFlag, FIXBoolean(true)) + sequenceReset.Body.SetField(tagNewSeqNo, FIXInt(endSeqNo)) + sequenceReset.Body.SetField(tagGapFillFlag, FIXBoolean(true)) + + var origSendingTime FIXString + if err := sequenceReset.Header.GetField(tagSendingTime, &origSendingTime); err == nil { + sequenceReset.Header.SetField(tagOrigSendingTime, origSendingTime) + } + + //FIXME error check? + msgBytes, _ := sequenceReset.Build() + session.sendBytes(msgBytes) + + session.log.OnEventf("Sent SequenceReset TO: %v", endSeqNo) +} diff --git a/vendor/github.com/quickfixgo/quickfix/initiator.go b/vendor/github.com/quickfixgo/quickfix/initiator.go new file mode 100644 index 0000000..21317d7 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/initiator.go @@ -0,0 +1,190 @@ +package quickfix + +import ( + "bufio" + "crypto/tls" + "net" + "sync" + "time" +) + +//Initiator initiates connections and processes messages for all sessions. +type Initiator struct { + app Application + settings *Settings + sessionSettings map[SessionID]*SessionSettings + storeFactory MessageStoreFactory + logFactory LogFactory + globalLog Log + stopChan chan interface{} + wg sync.WaitGroup + sessions map[SessionID]*session + sessionFactory +} + +//Start Initiator. +func (i *Initiator) Start() (err error) { + i.stopChan = make(chan interface{}) + + for sessionID, settings := range i.sessionSettings { + //TODO: move into session factory + var tlsConfig *tls.Config + if tlsConfig, err = loadTLSConfig(settings); err != nil { + return + } + + i.wg.Add(1) + go func(sessID SessionID) { + i.handleConnection(i.sessions[sessID], tlsConfig) + i.wg.Done() + }(sessionID) + } + + return +} + +//Stop Initiator. +func (i *Initiator) Stop() { + close(i.stopChan) + i.wg.Wait() +} + +//NewInitiator creates and initializes a new Initiator. +func NewInitiator(app Application, storeFactory MessageStoreFactory, appSettings *Settings, logFactory LogFactory) (*Initiator, error) { + i := &Initiator{ + app: app, + storeFactory: storeFactory, + settings: appSettings, + sessionSettings: appSettings.SessionSettings(), + logFactory: logFactory, + sessions: make(map[SessionID]*session), + sessionFactory: sessionFactory{true}, + } + + var err error + i.globalLog, err = logFactory.Create() + if err != nil { + return i, err + } + + for sessionID, s := range i.sessionSettings { + session, err := i.createSession(sessionID, storeFactory, s, logFactory, app) + if err != nil { + return nil, err + } + + i.sessions[sessionID] = session + } + + return i, nil +} + +//waitForInSessionTime returns true if the session is in session, false if the handler should stop +func (i *Initiator) waitForInSessionTime(session *session) bool { + inSessionTime := make(chan interface{}) + go func() { + session.waitForInSessionTime() + close(inSessionTime) + }() + + select { + case <-inSessionTime: + case <-i.stopChan: + return false + } + + return true +} + +//watiForReconnectInterval returns true if a reconnect should be re-attempted, false if handler should stop +func (i *Initiator) waitForReconnectInterval(reconnectInterval time.Duration) bool { + select { + case <-time.After(reconnectInterval): + case <-i.stopChan: + return false + } + + return true +} + +func (i *Initiator) handleConnection(session *session, tlsConfig *tls.Config) { + var wg sync.WaitGroup + wg.Add(1) + go func() { + session.run() + wg.Done() + }() + + defer func() { + session.stop() + wg.Wait() + }() + + connectionAttempt := 0 + + for { + if !i.waitForInSessionTime(session) { + return + } + + var disconnected chan interface{} + var msgIn chan fixIn + var msgOut chan []byte + + address := session.SocketConnectAddress[connectionAttempt%len(session.SocketConnectAddress)] + session.log.OnEventf("Connecting to: %v", address) + + var netConn net.Conn + if tlsConfig != nil { + tlsConn, err := tls.Dial("tcp", address, tlsConfig) + if err != nil { + session.log.OnEventf("Failed to connect: %v", err) + goto reconnect + } + + err = tlsConn.Handshake() + if err != nil { + session.log.OnEventf("Failed handshake:%v", err) + goto reconnect + } + netConn = tlsConn + } else { + var err error + netConn, err = net.Dial("tcp", address) + if err != nil { + session.log.OnEventf("Failed to connect: %v", err) + goto reconnect + } + } + + msgIn = make(chan fixIn) + msgOut = make(chan []byte) + if err := session.connect(msgIn, msgOut); err != nil { + session.log.OnEventf("Failed to initiate: %v", err) + goto reconnect + } + + go readLoop(newParser(bufio.NewReader(netConn)), msgIn) + disconnected = make(chan interface{}) + go func() { + writeLoop(netConn, msgOut, session.log) + if err := netConn.Close(); err != nil { + session.log.OnEvent(err.Error()) + } + close(disconnected) + }() + + select { + case <-disconnected: + case <-i.stopChan: + return + } + + reconnect: + connectionAttempt++ + session.log.OnEventf("Reconnecting in %v", session.ReconnectInterval) + if !i.waitForReconnectInterval(session.ReconnectInterval) { + return + } + } +} diff --git a/vendor/github.com/quickfixgo/quickfix/internal/event.go b/vendor/github.com/quickfixgo/quickfix/internal/event.go new file mode 100644 index 0000000..5c6af8d --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/internal/event.go @@ -0,0 +1,15 @@ +package internal + +//Event is an abstraction for session events +type Event int + +const ( + //PeerTimeout indicates the session peer has become unresponsive + PeerTimeout Event = iota + //NeedHeartbeat indicates the session should send a heartbeat + NeedHeartbeat + //LogonTimeout indicates the peer has not sent a logon request + LogonTimeout + //LogoutTimeout indicates the peer has not sent a logout request + LogoutTimeout +) diff --git a/vendor/github.com/quickfixgo/quickfix/internal/event_timer.go b/vendor/github.com/quickfixgo/quickfix/internal/event_timer.go new file mode 100644 index 0000000..adb76a9 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/internal/event_timer.go @@ -0,0 +1,25 @@ +package internal + +import ( + "time" +) + +type EventTimer struct { + Task func() + timer *time.Timer +} + +func (t *EventTimer) Stop() (ok bool) { + if t.timer != nil { + ok = t.timer.Stop() + } + return +} + +func (t *EventTimer) Reset(timeout time.Duration) (ok bool) { + ok = t.Stop() + if t.Task != nil && timeout > 0 { + t.timer = time.AfterFunc(timeout, t.Task) + } + return +} diff --git a/vendor/github.com/quickfixgo/quickfix/internal/session_settings.go b/vendor/github.com/quickfixgo/quickfix/internal/session_settings.go new file mode 100644 index 0000000..7b9a376 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/internal/session_settings.go @@ -0,0 +1,20 @@ +package internal + +import "time" + +//SessionSettings stores all of the configuration for a given session +type SessionSettings struct { + ResetOnLogon bool + RefreshOnLogon bool + ResetOnLogout bool + HeartBtInt time.Duration + SessionTime *TimeRange + InitiateLogon bool + + //required on logon for FIX.T.1 messages + DefaultApplVerID string + + //specific to initiators + ReconnectInterval time.Duration + SocketConnectAddress []string +} diff --git a/vendor/github.com/quickfixgo/quickfix/internal/time_range.go b/vendor/github.com/quickfixgo/quickfix/internal/time_range.go new file mode 100644 index 0000000..7b5b5bd --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/internal/time_range.go @@ -0,0 +1,174 @@ +package internal + +import ( + "errors" + "time" +) + +//TimeOfDay represents the time of day +type TimeOfDay struct { + hour, minute, second int + d time.Duration +} + +const shortForm = "15:04:05" + +var errParseTime = errors.New("Time must be in the format HH:MM:SS") + +//NewTimeOfDay returns a newly initialized TimeOfDay +func NewTimeOfDay(hour, minute, second int) TimeOfDay { + d := time.Duration(second)*time.Second + + time.Duration(minute)*time.Minute + + time.Duration(hour)*time.Hour + + return TimeOfDay{hour: hour, minute: minute, second: second, d: d} +} + +//ParseTimeOfDay parses a TimeOfDay from a string in the format HH:MM:SS +func ParseTimeOfDay(str string) (TimeOfDay, error) { + t, err := time.Parse(shortForm, str) + if err != nil { + return TimeOfDay{}, errParseTime + } + + return NewTimeOfDay(t.Clock()), nil +} + +//TimeRange represents a time band in a given time zone +type TimeRange struct { + startTime, endTime TimeOfDay + startDay, endDay *time.Weekday + loc *time.Location +} + +//NewUTCTimeRange returns a time range in UTC +func NewUTCTimeRange(start, end TimeOfDay) *TimeRange { + return NewTimeRangeInLocation(start, end, time.UTC) +} + +//NewTimeRangeInLocation returns a time range in a given location +func NewTimeRangeInLocation(start, end TimeOfDay, loc *time.Location) *TimeRange { + if loc == nil { + panic("time: missing Location in call to NewTimeRangeInLocation") + } + + return &TimeRange{startTime: start, endTime: end, loc: loc} +} + +//NewUTCWeekRange returns a weekly TimeRange +func NewUTCWeekRange(startTime, endTime TimeOfDay, startDay, endDay time.Weekday) *TimeRange { + return NewWeekRangeInLocation(startTime, endTime, startDay, endDay, time.UTC) +} + +//NewWeekRangeInLocation returns a time range in a given location +func NewWeekRangeInLocation(startTime, endTime TimeOfDay, startDay, endDay time.Weekday, loc *time.Location) *TimeRange { + r := NewTimeRangeInLocation(startTime, endTime, loc) + r.startDay = &startDay + r.endDay = &endDay + + return r +} + +func (r *TimeRange) isInTimeRange(t time.Time) bool { + t = t.In(r.loc) + ts := NewTimeOfDay(t.Clock()).d + + if r.startTime.d < r.endTime.d { + return r.startTime.d <= ts && ts <= r.endTime.d + } + + return !(r.endTime.d < ts && ts < r.startTime.d) +} + +func (r *TimeRange) isInWeekRange(t time.Time) bool { + t = t.In(r.loc) + day := t.Weekday() + + if *r.startDay == *r.endDay { + if day == *r.startDay { + return r.isInTimeRange(t) + } + + return true + } + + switch { + case *r.startDay < *r.endDay: + if day < *r.startDay || *r.endDay < day { + return false + } + + default: + if *r.endDay < day && day < *r.startDay { + return false + } + } + + timeOfDay := NewTimeOfDay(t.Clock()) + + if day == *r.startDay { + return timeOfDay.d >= r.startTime.d + } + + if day == *r.endDay { + return timeOfDay.d <= r.endTime.d + } + + return true +} + +//IsInRange returns true if time t is within in the time range +func (r *TimeRange) IsInRange(t time.Time) bool { + if r == nil { + return true + } + + if r.startDay != nil { + return r.isInWeekRange(t) + } + + return r.isInTimeRange(t) +} + +//IsInSameRange determines if two points in time are in the same time range +func (r *TimeRange) IsInSameRange(t1, t2 time.Time) bool { + if r == nil { + return true + } + + if !(r.IsInRange(t1) && r.IsInRange(t2)) { + return false + } + + if t2.Before(t1) { + t1, t2 = t2, t1 + } + + t1 = t1.In(r.loc) + t1Time := NewTimeOfDay(t1.Clock()) + dayOffset := 0 + + if r.endDay == nil { + if r.startTime.d >= r.endTime.d && t1Time.d >= r.startTime.d { + dayOffset = 1 + } + } else { + switch { + case *r.endDay < t1.Weekday(): + dayOffset = 7 + int(*(r.endDay)-t1.Weekday()) + + case t1.Weekday() == *r.endDay: + if r.endTime.d <= t1Time.d { + dayOffset = 7 + } + + default: + dayOffset = int(*(r.endDay) - t1.Weekday()) + } + } + + sessionEnd := time.Date(t1.Year(), t1.Month(), t1.Day(), r.endTime.hour, r.endTime.minute, r.endTime.second, 0, r.loc) + sessionEnd = sessionEnd.AddDate(0, 0, dayOffset) + + return t2.Before(sessionEnd) +} diff --git a/vendor/github.com/quickfixgo/quickfix/latent_state.go b/vendor/github.com/quickfixgo/quickfix/latent_state.go new file mode 100644 index 0000000..3140ecd --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/latent_state.go @@ -0,0 +1,23 @@ +package quickfix + +import "github.com/quickfixgo/quickfix/internal" + +type latentState struct{ inSessionTime } + +func (state latentState) String() string { return "Latent State" } +func (state latentState) IsLoggedOn() bool { return false } +func (state latentState) IsConnected() bool { return false } + +func (state latentState) FixMsgIn(session *session, msg Message) (nextState sessionState) { + session.log.OnEventf("Invalid Session State: Unexpected Msg %v while in Latent state", msg) + return state +} + +func (state latentState) Timeout(*session, internal.Event) (nextState sessionState) { + return state +} + +func (state latentState) ShutdownNow(*session) {} +func (state latentState) Stop(*session) (nextState sessionState) { + return state +} diff --git a/vendor/github.com/quickfixgo/quickfix/log.go b/vendor/github.com/quickfixgo/quickfix/log.go new file mode 100644 index 0000000..78f3e7d --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/log.go @@ -0,0 +1,25 @@ +package quickfix + +//Log is a generic interface for logging FIX messages and events. +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{}) +} + +//The LogFactory interface creates global and session specific Log instances +type LogFactory interface { + //global log + Create() (Log, error) + + //session specific log + CreateSessionLog(sessionID SessionID) (Log, error) +} diff --git a/vendor/github.com/quickfixgo/quickfix/logon_state.go b/vendor/github.com/quickfixgo/quickfix/logon_state.go new file mode 100644 index 0000000..b70e4f5 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/logon_state.go @@ -0,0 +1,40 @@ +package quickfix + +import ( + "github.com/quickfixgo/quickfix/enum" + "github.com/quickfixgo/quickfix/internal" +) + +type logonState struct{ connectedNotLoggedOn } + +func (s logonState) String() string { return "Logon State" } + +func (s logonState) FixMsgIn(session *session, msg Message) (nextState sessionState) { + var msgType FIXString + if err := msg.Header.GetField(tagMsgType, &msgType); err != nil { + return handleStateError(session, err) + } + + if string(msgType) != enum.MsgType_LOGON { + session.log.OnEventf("Invalid Session State: Received Msg %s while waiting for Logon", msg) + return latentState{} + } + + if err := session.handleLogon(msg); err != nil { + return handleStateError(session, err) + } + return inSession{} +} + +func (s logonState) Timeout(session *session, e internal.Event) (nextState sessionState) { + switch e { + case internal.LogonTimeout: + session.log.OnEvent("Timed out waiting for logon response") + return latentState{} + } + return s +} + +func (s logonState) Stop(session *session) (nextState sessionState) { + return latentState{} +} diff --git a/vendor/github.com/quickfixgo/quickfix/logout_state.go b/vendor/github.com/quickfixgo/quickfix/logout_state.go new file mode 100644 index 0000000..3619546 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/logout_state.go @@ -0,0 +1,30 @@ +package quickfix + +import "github.com/quickfixgo/quickfix/internal" + +type logoutState struct{ connectedNotLoggedOn } + +func (state logoutState) String() string { return "Logout State" } + +func (state logoutState) FixMsgIn(session *session, msg Message) (nextState sessionState) { + nextState = inSession{}.FixMsgIn(session, msg) + if nextState, ok := nextState.(latentState); ok { + return nextState + } + + return state +} + +func (state logoutState) Timeout(session *session, event internal.Event) (nextState sessionState) { + switch event { + case internal.LogoutTimeout: + session.log.OnEvent("Timed out waiting for logout response") + return latentState{} + } + + return state +} + +func (state logoutState) Stop(session *session) (nextstate sessionState) { + return state +} diff --git a/vendor/github.com/quickfixgo/quickfix/message.go b/vendor/github.com/quickfixgo/quickfix/message.go new file mode 100644 index 0000000..756ce29 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/message.go @@ -0,0 +1,296 @@ +package quickfix + +import ( + "bytes" + "fmt" + "math" + "time" + + "github.com/quickfixgo/quickfix/enum" +) + +//Header is first section of a FIX Message +type Header struct{ FieldMap } + +//Init initializes the Header instance +func (h *Header) Init() { + //in the message header, the first 3 tags in the message header must be 8,9,35 + h.initWithOrdering(func(i, j Tag) bool { + var ordering = func(t Tag) uint32 { + switch t { + case tagBeginString: + return 1 + case tagBodyLength: + return 2 + case tagMsgType: + return 3 + } + + return math.MaxUint32 + } + + orderi := ordering(i) + orderj := ordering(j) + + switch { + case orderi < orderj: + return true + case orderi > orderj: + return false + } + + return i < j + }) +} + +//Body is the primary application section of a FIX message +type Body struct{ FieldMap } + +//Init initializes the FIX message +func (b *Body) Init() { + b.init() +} + +//Trailer is the last section of a FIX message +type Trailer struct{ FieldMap } + +//Init initializes the FIX message +func (t *Trailer) Init() { + // In the trailer, CheckSum (tag 10) must be last + t.initWithOrdering(func(i, j Tag) bool { + switch { + case i == tagCheckSum: + return false + case j == tagCheckSum: + return true + } + + return i < j + }) +} + +//Message is a FIX Message abstraction. +type Message struct { + Header Header + Trailer Trailer + Body Body + + //ReceiveTime is the time that this message was read from the socket connection + ReceiveTime time.Time + + rawMessage []byte + + //slice of Bytes corresponding to the message body + bodyBytes []byte + + //field bytes as they appear in the raw message + fields TagValues +} + +//ToMessage returns the message itself +func (m Message) ToMessage() Message { return m } + +//parseError is returned when bytes cannot be parsed as a FIX message. +type parseError struct { + OrigError string +} + +func (e parseError) Error() string { return fmt.Sprintf("error parsing message: %s", e.OrigError) } + +//NewMessage returns a newly initialized Message instance +func NewMessage() (m Message) { + m.Header.Init() + m.Body.Init() + m.Trailer.Init() + + return +} + +//ParseMessage constructs a Message from a byte slice wrapping a FIX message. +func ParseMessage(rawMessage []byte) (Message, error) { + msg := NewMessage() + msg.rawMessage = rawMessage + + //allocate fields in one chunk + fieldCount := 0 + for _, b := range rawMessage { + if b == '\001' { + fieldCount++ + } + } + msg.fields = make(TagValues, fieldCount) + + fieldIndex := 0 + var err error + + //message must start with begin string, body length, msg type + if rawMessage, err = extractSpecificField(&msg.fields[fieldIndex], tagBeginString, rawMessage); err != nil { + return msg, err + } + + msg.Header.tagLookup[msg.fields[fieldIndex].tag] = msg.fields[fieldIndex : fieldIndex+1] + fieldIndex++ + + parsedFieldBytes := &msg.fields[fieldIndex] + if rawMessage, err = extractSpecificField(parsedFieldBytes, tagBodyLength, rawMessage); err != nil { + return msg, err + } + + msg.Header.tagLookup[parsedFieldBytes.tag] = msg.fields[fieldIndex : fieldIndex+1] + fieldIndex++ + + parsedFieldBytes = &msg.fields[fieldIndex] + if rawMessage, err = extractSpecificField(parsedFieldBytes, tagMsgType, rawMessage); err != nil { + return msg, err + } + + msg.Header.tagLookup[parsedFieldBytes.tag] = msg.fields[fieldIndex : fieldIndex+1] + fieldIndex++ + + trailerBytes := []byte{} + foundBody := false + for { + parsedFieldBytes = &msg.fields[fieldIndex] + rawMessage, err = extractField(parsedFieldBytes, rawMessage) + if err != nil { + return msg, err + } + + switch { + case parsedFieldBytes.tag.IsHeader(): + msg.Header.tagLookup[parsedFieldBytes.tag] = msg.fields[fieldIndex : fieldIndex+1] + case parsedFieldBytes.tag.IsTrailer(): + msg.Trailer.tagLookup[parsedFieldBytes.tag] = msg.fields[fieldIndex : fieldIndex+1] + default: + foundBody = true + trailerBytes = rawMessage + msg.Body.tagLookup[parsedFieldBytes.tag] = msg.fields[fieldIndex : fieldIndex+1] + } + if parsedFieldBytes.tag == tagCheckSum { + break + } + + if !foundBody { + msg.bodyBytes = rawMessage + } + + fieldIndex++ + } + + //body length would only be larger than trailer if fields out of order + if len(msg.bodyBytes) > len(trailerBytes) { + msg.bodyBytes = msg.bodyBytes[:len(msg.bodyBytes)-len(trailerBytes)] + } + + length := 0 + for _, field := range msg.fields { + switch field.tag { + case tagBeginString, tagBodyLength, tagCheckSum: //tags do not contribute to length + default: + length += field.length() + } + } + + var bodyLength FIXInt + if err := msg.Header.GetField(tagBodyLength, &bodyLength); err != nil { + return msg, parseError{OrigError: err.Error()} + } + + if length != int(bodyLength) { + return msg, parseError{OrigError: fmt.Sprintf("Incorrect Message Length, expected %d, got %d", bodyLength, length)} + } + + return msg, nil +} + +//reverseRoute returns a message builder with routing header fields initialized as the reverse of this message. +func (m Message) reverseRoute() Message { + reverseMsg := NewMessage() + + copy := func(src Tag, dest Tag) { + var field FIXString + if m.Header.GetField(src, &field) == nil { + if len(field) != 0 { + reverseMsg.Header.SetField(dest, field) + } + } + } + + copy(tagSenderCompID, tagTargetCompID) + copy(tagSenderSubID, tagTargetSubID) + copy(tagSenderLocationID, tagTargetLocationID) + + copy(tagTargetCompID, tagSenderCompID) + copy(tagTargetSubID, tagSenderSubID) + copy(tagTargetLocationID, tagSenderLocationID) + + copy(tagOnBehalfOfCompID, tagDeliverToCompID) + copy(tagOnBehalfOfSubID, tagDeliverToSubID) + copy(tagDeliverToCompID, tagOnBehalfOfCompID) + copy(tagDeliverToSubID, tagOnBehalfOfSubID) + + //tags added in 4.1 + var beginString FIXString + if m.Header.GetField(tagBeginString, &beginString) == nil { + if string(beginString) != enum.BeginStringFIX40 { + copy(tagOnBehalfOfLocationID, tagDeliverToLocationID) + copy(tagDeliverToLocationID, tagOnBehalfOfLocationID) + } + } + + return reverseMsg +} + +func extractSpecificField(field *TagValue, expectedTag Tag, buffer []byte) (remBuffer []byte, err error) { + remBuffer, err = extractField(field, buffer) + switch { + case err != nil: + return + case field.tag != expectedTag: + err = parseError{OrigError: fmt.Sprintf("extractSpecificField: Fields out of order, expected %d, got %d", expectedTag, field.tag)} + return + } + + return +} + +func extractField(parsedFieldBytes *TagValue, buffer []byte) (remBytes []byte, err error) { + endIndex := bytes.IndexByte(buffer, '\001') + if endIndex == -1 { + err = parseError{OrigError: "extractField: No Trailing Delim in " + string(buffer)} + remBytes = buffer + return + } + + err = parsedFieldBytes.parse(buffer[:endIndex+1]) + return buffer[(endIndex + 1):], err +} + +func (m *Message) String() string { + return string(m.rawMessage) +} + +func newCheckSum(value int) FIXString { + return FIXString(fmt.Sprintf("%03d", value)) +} + +//Build constructs a []byte from a Message instance +func (m *Message) Build() ([]byte, error) { + m.cook() + + var b bytes.Buffer + m.Header.write(&b) + m.Body.write(&b) + m.Trailer.write(&b) + + m.rawMessage = b.Bytes() + + return m.rawMessage, nil +} + +func (m Message) cook() { + bodyLength := m.Header.length() + m.Body.length() + m.Trailer.length() + m.Header.SetField(tagBodyLength, FIXInt(bodyLength)) + checkSum := (m.Header.total() + m.Body.total() + m.Trailer.total()) % 256 + m.Trailer.SetField(tagCheckSum, newCheckSum(checkSum)) +} diff --git a/vendor/github.com/quickfixgo/quickfix/message_router.go b/vendor/github.com/quickfixgo/quickfix/message_router.go new file mode 100644 index 0000000..3eba69d --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/message_router.go @@ -0,0 +1,77 @@ +package quickfix + +import ( + "github.com/quickfixgo/quickfix/enum" +) + +type routeKey struct { + FIXVersion string + MsgType string +} + +//A MessageRoute is a function that can process a fromApp/fromAdmin callback +type MessageRoute func(msg Message, sessionID SessionID) MessageRejectError + +//A MessageRouter is a mutex for MessageRoutes +type MessageRouter struct { + routes map[routeKey]MessageRoute +} + +//NewMessageRouter returns an initialized MessageRouter instance +func NewMessageRouter() *MessageRouter { + return &MessageRouter{routes: make(map[routeKey]MessageRoute)} +} + +//AddRoute adds a route to the MessageRouter instance keyed to begin string and msgType. +func (c MessageRouter) AddRoute(beginString string, msgType string, router MessageRoute) { + c.routes[routeKey{beginString, msgType}] = router +} + +//Route may be called from the fromApp/fromAdmin callbacks. Messages that cannot be routed will be rejected with UnsupportedMessageType. +func (c MessageRouter) Route(msg Message, sessionID SessionID) MessageRejectError { + var beginString FIXString + if err := msg.Header.GetField(tagBeginString, &beginString); err != nil { + return nil + } + + var msgType FIXString + if err := msg.Header.GetField(tagMsgType, &msgType); err != nil { + return err + } + + return c.tryRoute(string(beginString), string(msgType), msg, sessionID) +} + +func (c MessageRouter) tryRoute(beginString string, msgType string, msg Message, sessionID SessionID) MessageRejectError { + fixVersion := beginString + if beginString == enum.BeginStringFIXT11 && !isAdminMessageType(msgType) { + var applVerID FIXString + if err := msg.Header.GetField(tagApplVerID, &applVerID); err != nil { + session, _ := lookupSession(sessionID) + applVerID = FIXString(session.TargetDefaultApplicationVersionID()) + } + + switch string(applVerID) { + case enum.ApplVerID_FIX40: + fixVersion = enum.BeginStringFIX40 + case enum.ApplVerID_FIX41: + fixVersion = enum.BeginStringFIX41 + case enum.ApplVerID_FIX42: + fixVersion = enum.BeginStringFIX42 + case enum.ApplVerID_FIX43: + fixVersion = enum.BeginStringFIX43 + case enum.ApplVerID_FIX44: + fixVersion = enum.BeginStringFIX44 + default: + fixVersion = string(applVerID) + } + } + + route, ok := c.routes[routeKey{fixVersion, msgType}] + + if !ok { + return UnsupportedMessageType() + } + + return route(msg, sessionID) +} diff --git a/vendor/github.com/quickfixgo/quickfix/msg_type.go b/vendor/github.com/quickfixgo/quickfix/msg_type.go new file mode 100644 index 0000000..e1d8aad --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/msg_type.go @@ -0,0 +1,11 @@ +package quickfix + +//IsAdminMessageType returns true if the message type is a sesion level message. +func isAdminMessageType(m string) bool { + switch m { + case "0", "A", "1", "2", "3", "4", "5": + return true + } + + return false +} diff --git a/vendor/github.com/quickfixgo/quickfix/not_session_time.go b/vendor/github.com/quickfixgo/quickfix/not_session_time.go new file mode 100644 index 0000000..e9b589d --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/not_session_time.go @@ -0,0 +1,21 @@ +package quickfix + +import "github.com/quickfixgo/quickfix/internal" + +type notSessionTime struct{ latentState } + +func (notSessionTime) String() string { return "Not session time" } +func (notSessionTime) IsSessionTime() bool { return false } + +func (state notSessionTime) FixMsgIn(session *session, msg Message) (nextState sessionState) { + session.log.OnEventf("Invalid Session State: Unexpected Msg %v while in Latent state", msg) + return state +} + +func (state notSessionTime) Timeout(*session, internal.Event) (nextState sessionState) { + return state +} + +func (state notSessionTime) Stop(*session) (nextState sessionState) { + return state +} diff --git a/vendor/github.com/quickfixgo/quickfix/null_log.go b/vendor/github.com/quickfixgo/quickfix/null_log.go new file mode 100644 index 0000000..10ff2c2 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/null_log.go @@ -0,0 +1,22 @@ +package quickfix + +type nullLog struct{} + +func (l nullLog) OnIncoming(s string) {} +func (l nullLog) OnOutgoing(s string) {} +func (l nullLog) OnEvent(s string) {} +func (l nullLog) OnEventf(format string, a ...interface{}) {} + +type nullLogFactory struct{} + +func (nullLogFactory) Create() (Log, error) { + return nullLog{}, nil +} +func (nullLogFactory) CreateSessionLog(sessionID SessionID) (Log, error) { + return nullLog{}, nil +} + +//NewNullLogFactory creates an instance of LogFactory that returns no-op loggers. +func NewNullLogFactory() LogFactory { + return nullLogFactory{} +} diff --git a/vendor/github.com/quickfixgo/quickfix/parser.go b/vendor/github.com/quickfixgo/quickfix/parser.go new file mode 100644 index 0000000..33fa419 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/parser.go @@ -0,0 +1,121 @@ +package quickfix + +import ( + "bytes" + "io" + "time" +) + +const ( + defaultBufSize = 4096 +) + +type parser struct { + buffer []byte + reader io.Reader + lastRead time.Time +} + +func newParser(reader io.Reader) *parser { + return &parser{reader: reader} +} + +func (p *parser) readMore() (int, error) { + if len(p.buffer) == cap(p.buffer) { + newBuffer := make([]byte, len(p.buffer), len(p.buffer)+defaultBufSize) + copy(newBuffer, p.buffer) + p.buffer = newBuffer + } + + n, e := p.reader.Read(p.buffer[len(p.buffer):cap(p.buffer)]) + p.lastRead = time.Now() + p.buffer = p.buffer[:len(p.buffer)+n] + return n, e +} + +func (p *parser) findIndex(delim []byte) (int, error) { + return p.findIndexAfterOffset(0, delim) +} + +func (p *parser) findIndexAfterOffset(offset int, delim []byte) (int, error) { + for { + if offset > len(p.buffer) { + if n, err := p.readMore(); n == 0 && err != nil { + return -1, err + } + + continue + } + + if index := bytes.Index(p.buffer[offset:], delim); index != -1 { + return index + offset, nil + } + + n, err := p.readMore() + + if n == 0 && err != nil { + return -1, err + } + } +} + +func (p *parser) findStart() (int, error) { + return p.findIndex([]byte("8=")) +} + +func (p *parser) findEndAfterOffset(offset int) (int, error) { + index, err := p.findIndexAfterOffset(offset, []byte("\00110=")) + if err != nil { + return index, err + } + + index, err = p.findIndexAfterOffset(index+1, []byte("\001")) + if err != nil { + return index, err + } + + return index + 1, nil +} + +func (p *parser) jumpLength() (int, error) { + lengthIndex, err := p.findIndex([]byte("9=")) + if err != nil { + return 0, err + } + + lengthIndex += 3 + + offset, err := p.findIndexAfterOffset(lengthIndex, []byte("\001")) + if err != nil { + return 0, err + } + + length, err := atoi(p.buffer[lengthIndex:offset]) + if err != nil { + return length, err + } + return offset + length, nil +} + +func (p *parser) ReadMessage() ([]byte, error) { + start, err := p.findStart() + if err != nil { + return []byte{}, err + } + p.buffer = p.buffer[start:] + + index, err := p.jumpLength() + if err != nil { + return []byte{}, err + } + + index, err = p.findEndAfterOffset(index) + if err != nil { + return []byte{}, err + } + + msgBytes := p.buffer[:index:index] + p.buffer = p.buffer[index:] + + return msgBytes, nil +} diff --git a/vendor/github.com/quickfixgo/quickfix/pending_timeout.go b/vendor/github.com/quickfixgo/quickfix/pending_timeout.go new file mode 100644 index 0000000..87154dd --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/pending_timeout.go @@ -0,0 +1,17 @@ +package quickfix + +import "github.com/quickfixgo/quickfix/internal" + +type pendingTimeout struct { + sessionState +} + +func (s pendingTimeout) Timeout(session *session, event internal.Event) (nextState sessionState) { + switch event { + case internal.PeerTimeout: + session.log.OnEvent("Session Timeout") + return latentState{} + } + + return s +} diff --git a/vendor/github.com/quickfixgo/quickfix/registry.go b/vendor/github.com/quickfixgo/quickfix/registry.go new file mode 100644 index 0000000..87d55d4 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/registry.go @@ -0,0 +1,71 @@ +package quickfix + +import ( + "errors" + "sync" +) + +var sessionsLock sync.RWMutex +var sessions = make(map[SessionID]*session) +var errDuplicateSessionID = errors.New("Duplicate SessionID") +var errUnknownSession = errors.New("Unknown session") + +//Messagable is a Message or something that can be converted to a Message +type Messagable interface { + ToMessage() Message +} + +//Send determines the session to send Messagable using header fields BeginString, TargetCompID, SenderCompID +func Send(m Messagable) (err error) { + msg := m.ToMessage() + var beginString FIXString + if err := msg.Header.GetField(tagBeginString, &beginString); err != nil { + return err + } + + var targetCompID FIXString + if err := msg.Header.GetField(tagTargetCompID, &targetCompID); err != nil { + return err + } + + var senderCompID FIXString + if err := msg.Header.GetField(tagSenderCompID, &senderCompID); err != nil { + + return nil + } + + sessionID := SessionID{BeginString: string(beginString), TargetCompID: string(targetCompID), SenderCompID: string(senderCompID)} + + return SendToTarget(msg, sessionID) +} + +//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 Messagable, sessionID SessionID) error { + msg := m.ToMessage() + session, ok := lookupSession(sessionID) + if !ok { + return errUnknownSession + } + + return session.queueForSend(msg) +} + +func registerSession(s *session) error { + sessionsLock.Lock() + defer sessionsLock.Unlock() + + if _, ok := sessions[s.sessionID]; ok { + return errDuplicateSessionID + } + + sessions[s.sessionID] = s + return nil +} + +func lookupSession(sessionID SessionID) (s *session, ok bool) { + sessionsLock.RLock() + defer sessionsLock.RUnlock() + + s, ok = sessions[sessionID] + return +} diff --git a/vendor/github.com/quickfixgo/quickfix/repeating_group.go b/vendor/github.com/quickfixgo/quickfix/repeating_group.go new file mode 100644 index 0000000..262794c --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/repeating_group.go @@ -0,0 +1,210 @@ +package quickfix + +import ( + "fmt" + "math" + "strconv" +) + +//GroupItem interface is used to construct repeating group templates +type GroupItem interface { + //Tag returns the tag identifying this GroupItem + Tag() Tag + + //Parameter to Read is tagValues. For most fields, only the first tagValue will be required. + //The length of the slice extends from the tagValue mapped to the field to be read through the + //following fields. This can be useful for GroupItems made up of repeating groups. + // + //The Read function returns the remaining tagValues not processed by the GroupItem. If there was a + //problem reading the field, an error may be returned + Read(TagValues) (TagValues, error) + + //Clone makes a copy of this GroupItem + Clone() GroupItem +} + +type protoGroupElement struct { + tag Tag +} + +func (t protoGroupElement) Tag() Tag { return t.tag } +func (t protoGroupElement) Read(tv TagValues) (TagValues, error) { + if tv[0].tag == t.tag { + return tv[1:], nil + } + + return tv, nil +} + +func (t protoGroupElement) Clone() GroupItem { return t } + +//GroupElement returns a GroupItem made up of a single field +func GroupElement(tag Tag) GroupItem { + return protoGroupElement{tag: tag} +} + +//GroupTemplate specifies the group item order for a RepeatingGroup +type GroupTemplate []GroupItem + +//Clone makes a copy of this GroupTemplate +func (gt GroupTemplate) Clone() GroupTemplate { + clone := make(GroupTemplate, len(gt)) + for i := range gt { + clone[i] = gt[i].Clone() + } + + return clone +} + +//Group is a group of fields occuring in a repeating group +type Group struct{ FieldMap } + +//RepeatingGroup is a FIX Repeating Group type +type RepeatingGroup struct { + tag Tag + template GroupTemplate + groups []Group +} + +//NewRepeatingGroup returns an initilized RepeatingGroup instance +func NewRepeatingGroup(tag Tag, template GroupTemplate) *RepeatingGroup { + return &RepeatingGroup{ + tag: tag, + template: template, + } +} + +//Tag returns the Tag for this repeating Group +func (f RepeatingGroup) Tag() Tag { + return f.tag +} + +//Clone makes a copy of this RepeatingGroup (tag, template) +func (f RepeatingGroup) Clone() GroupItem { + return &RepeatingGroup{ + tag: f.tag, + template: f.template.Clone(), + } +} + +//Len returns the number of Groups in this RepeatingGroup +func (f RepeatingGroup) Len() int { + return len(f.groups) +} + +//Get returns the ith group in this RepeatingGroup +func (f RepeatingGroup) Get(i int) Group { + return f.groups[i] +} + +//Add appends a new group to the RepeatingGroup and returns the new Group +func (f *RepeatingGroup) Add() Group { + var g Group + g.initWithOrdering(f.groupTagOrder()) + + f.groups = append(f.groups, g) + return g +} + +//Write returns tagValues for all Items in the repeating group ordered by +//Group sequence and Group template order +func (f RepeatingGroup) Write() TagValues { + tvs := make(TagValues, 1, 1) + tvs[0].init(f.tag, []byte(strconv.Itoa(len(f.groups)))) + + for _, group := range f.groups { + tags := group.sortedTags() + + for _, tag := range tags { + if fields, ok := group.tagLookup[tag]; ok { + tvs = append(tvs, fields...) + } + } + } + + return tvs +} + +func (f RepeatingGroup) findItemInGroupTemplate(t Tag) (item GroupItem, ok bool) { + for _, templateField := range f.template { + if t == templateField.Tag() { + ok = true + item = templateField.Clone() + break + } + } + + return +} + +func (f RepeatingGroup) groupTagOrder() tagOrder { + tagMap := make(map[Tag]int) + for i, f := range f.template { + tagMap[f.Tag()] = i + } + + return func(i, j Tag) bool { + orderi := math.MaxInt64 + orderj := math.MaxInt64 + + if iIndex, ok := tagMap[i]; ok { + orderi = iIndex + } + + if jIndex, ok := tagMap[j]; ok { + orderj = jIndex + } + + return orderi < orderj + } +} + +func (f RepeatingGroup) delimiter() Tag { + return f.template[0].Tag() +} + +func (f RepeatingGroup) isDelimiter(t Tag) bool { + return t == f.delimiter() +} + +func (f *RepeatingGroup) Read(tv TagValues) (TagValues, error) { + expectedGroupSize, err := atoi(tv[0].value) + if err != nil { + return tv, err + } + + if expectedGroupSize == 0 { + return tv[1:], nil + } + + tv = tv[1:cap(tv)] + tagOrdering := f.groupTagOrder() + var group Group + group.initWithOrdering(tagOrdering) + for len(tv) > 0 { + field, ok := f.findItemInGroupTemplate(tv[0].tag) + if !ok { + break + } + + tvRange := tv + if tv, err = field.Read(tv); err != nil { + return tv, err + } + + if f.isDelimiter(field.Tag()) { + group = Group{} + group.initWithOrdering(tagOrdering) + + f.groups = append(f.groups, group) + } + + group.tagLookup[tvRange[0].tag] = tvRange + } + + if len(f.groups) != expectedGroupSize { + return tv, repeatingGroupFieldsOutOfOrder(f.tag, fmt.Sprintf("group %v: template is wrong or delimiter %v not found: expected %v groups, but found %v", f.tag, f.delimiter(), expectedGroupSize, len(f.groups))) + } + + return tv, err +} diff --git a/vendor/github.com/quickfixgo/quickfix/resend_state.go b/vendor/github.com/quickfixgo/quickfix/resend_state.go new file mode 100644 index 0000000..15254d8 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/resend_state.go @@ -0,0 +1,37 @@ +package quickfix + +import "github.com/quickfixgo/quickfix/internal" + +type resendState struct{ loggedOn } + +func (s resendState) String() string { return "Resend" } + +func (s resendState) Timeout(session *session, event internal.Event) (nextState sessionState) { + nextState = inSession{}.Timeout(session, event) + switch nextState.(type) { + case inSession: + nextState = s + case pendingTimeout: + //wrap pendingTimeout in resend. prevents us falling back to inSession if recovering + //from pendingTimeout + nextState = pendingTimeout{s} + } + + return +} + +func (s resendState) FixMsgIn(session *session, msg Message) (nextState sessionState) { + nextState = inSession{}.FixMsgIn(session, msg) + + if !nextState.IsLoggedOn() || len(session.messageStash) == 0 { + return + } + + targetSeqNum := session.store.NextTargetMsgSeqNum() + if msg, ok := session.messageStash[targetSeqNum]; ok { + delete(session.messageStash, targetSeqNum) + nextState = nextState.FixMsgIn(session, msg) + } + + return +} diff --git a/vendor/github.com/quickfixgo/quickfix/screen_log.go b/vendor/github.com/quickfixgo/quickfix/screen_log.go new file mode 100644 index 0000000..a26e687 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/screen_log.go @@ -0,0 +1,46 @@ +package quickfix + +import ( + "fmt" + "time" +) + +type screenLog struct { + prefix string +} + +func (l screenLog) OnIncoming(s string) { + logTime := time.Now().UTC() + fmt.Printf("<%v, %s, incoming>\n (%s)\n", logTime, l.prefix, s) +} + +func (l screenLog) OnOutgoing(s string) { + logTime := time.Now().UTC() + fmt.Printf("<%v, %s, outgoing>\n (%s)\n", logTime, l.prefix, s) +} + +func (l screenLog) OnEvent(s string) { + logTime := time.Now().UTC() + fmt.Printf("<%v, %s, event>\n (%s)\n", logTime, l.prefix, s) +} + +func (l screenLog) OnEventf(format string, a ...interface{}) { + l.OnEvent(fmt.Sprintf(format, a...)) +} + +type screenLogFactory struct{} + +func (screenLogFactory) Create() (Log, error) { + log := screenLog{"GLOBAL"} + return log, nil +} + +func (screenLogFactory) CreateSessionLog(sessionID SessionID) (Log, error) { + log := screenLog{sessionID.String()} + return log, nil +} + +//NewScreenLogFactory creates an instance of LogFactory that writes messages and events to stdout. +func NewScreenLogFactory() LogFactory { + return screenLogFactory{} +} diff --git a/vendor/github.com/quickfixgo/quickfix/session.go b/vendor/github.com/quickfixgo/quickfix/session.go new file mode 100644 index 0000000..d161a6a --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/session.go @@ -0,0 +1,646 @@ +package quickfix + +import ( + "errors" + "fmt" + "sync" + "time" + + "github.com/quickfixgo/quickfix/enum" + "github.com/quickfixgo/quickfix/internal" +) + +//The Session is the primary FIX abstraction for message communication +type session struct { + store MessageStore + + log Log + sessionID SessionID + + messageOut chan<- []byte + messageIn <-chan fixIn + + //application messages are queued up for send here + toSend []Message + + //mutex for access to toSend + sendMutex sync.Mutex + + sessionEvent chan internal.Event + messageEvent chan bool + application Application + validator + stateMachine + stateTimer internal.EventTimer + peerTimer internal.EventTimer + messageStash map[int]Message + + targetDefaultApplVerID string + + admin chan interface{} + internal.SessionSettings +} + +func (s *session) logError(err error) { + s.log.OnEvent(err.Error()) +} + +//TargetDefaultApplicationVersionID returns the default application version ID for messages received by this version. +//Applicable for For FIX.T.1 sessions. +func (s *session) TargetDefaultApplicationVersionID() string { + return s.targetDefaultApplVerID +} + +type connect struct { + messageOut chan<- []byte + messageIn <-chan fixIn + err chan<- error +} + +func (s *session) connect(msgIn <-chan fixIn, msgOut chan<- []byte) error { + rep := make(chan error) + s.admin <- connect{ + messageOut: msgOut, + messageIn: msgIn, + err: rep, + } + + return <-rep +} + +type stopReq struct{} + +func (s *session) stop() { + s.admin <- stopReq{} +} + +type waitChan <-chan interface{} + +type waitForInSessionReq struct{ rep chan<- waitChan } + +func (s *session) waitForInSessionTime() { + rep := make(chan waitChan) + s.admin <- waitForInSessionReq{rep} + if wait, ok := <-rep; ok { + <-wait + } +} + +func (s *session) insertSendingTime(header Header) { + sendingTime := time.Now().UTC() + + if s.sessionID.BeginString >= enum.BeginStringFIX42 { + header.SetField(tagSendingTime, FIXUTCTimestamp{Time: sendingTime}) + } else { + header.SetField(tagSendingTime, FIXUTCTimestamp{Time: sendingTime, NoMillis: true}) + } +} + +func (s *session) fillDefaultHeader(msg Message) { + msg.Header.SetField(tagBeginString, FIXString(s.sessionID.BeginString)) + msg.Header.SetField(tagSenderCompID, FIXString(s.sessionID.SenderCompID)) + msg.Header.SetField(tagTargetCompID, FIXString(s.sessionID.TargetCompID)) + + s.insertSendingTime(msg.Header) +} + +func (s *session) sendLogon(resetStore, setResetSeqNum bool) error { + logon := NewMessage() + logon.Header.SetField(tagMsgType, FIXString("A")) + logon.Header.SetField(tagBeginString, FIXString(s.sessionID.BeginString)) + logon.Header.SetField(tagTargetCompID, FIXString(s.sessionID.TargetCompID)) + logon.Header.SetField(tagSenderCompID, FIXString(s.sessionID.SenderCompID)) + logon.Body.SetField(tagEncryptMethod, FIXString("0")) + logon.Body.SetField(tagHeartBtInt, FIXInt(s.HeartBtInt.Seconds())) + + if setResetSeqNum { + logon.Body.SetField(tagResetSeqNumFlag, FIXBoolean(true)) + } + + if len(s.DefaultApplVerID) > 0 { + logon.Body.SetField(tagDefaultApplVerID, FIXString(s.DefaultApplVerID)) + } + + if err := s.dropAndSend(logon, resetStore); err != nil { + return err + } + + return nil +} + +func (s *session) sendLogout(reason string) error { + logout := NewMessage() + logout.Header.SetField(tagMsgType, FIXString("5")) + logout.Header.SetField(tagBeginString, FIXString(s.sessionID.BeginString)) + logout.Header.SetField(tagTargetCompID, FIXString(s.sessionID.TargetCompID)) + logout.Header.SetField(tagSenderCompID, FIXString(s.sessionID.SenderCompID)) + if reason != "" { + logout.Body.SetField(tagText, FIXString(reason)) + } + return s.send(logout) +} + +func (s *session) resend(msg Message) error { + msg.Header.SetField(tagPossDupFlag, FIXBoolean(true)) + + var origSendingTime FIXString + if err := msg.Header.GetField(tagSendingTime, &origSendingTime); err == nil { + msg.Header.SetField(tagOrigSendingTime, origSendingTime) + } + + s.insertSendingTime(msg.Header) + + if _, err := msg.Build(); err != nil { + return err + } + s.sendBytes(msg.rawMessage) + + return nil +} + +//queueForSend will validate, persist, and queue the message for send +func (s *session) queueForSend(msg Message) error { + s.sendMutex.Lock() + defer s.sendMutex.Unlock() + + if err := s.prepMessageForSend(&msg); err != nil { + return err + } + + s.toSend = append(s.toSend, msg) + + select { + case s.messageEvent <- true: + default: + } + + return nil +} + +//send will validate, persist, queue the message. If the session is logged on, send all messages in the queue +func (s *session) send(msg Message) error { + if !s.IsLoggedOn() { + return s.queueForSend(msg) + } + + s.sendMutex.Lock() + defer s.sendMutex.Unlock() + + if err := s.prepMessageForSend(&msg); err != nil { + return err + } + + s.toSend = append(s.toSend, msg) + s.sendQueued() + + return nil +} + +//dropAndReset will drop the send queue and reset the message store +func (s *session) dropAndReset() error { + s.sendMutex.Lock() + defer s.sendMutex.Unlock() + + s.dropQueued() + return s.store.Reset() +} + +//dropAndSend will optionally reset the store, validate and persist the message, then drops the send queue and sends the message. +func (s *session) dropAndSend(msg Message, resetStore bool) error { + + s.sendMutex.Lock() + defer s.sendMutex.Unlock() + + if resetStore { + if err := s.store.Reset(); err != nil { + return err + } + } + + if err := s.prepMessageForSend(&msg); err != nil { + return err + } + + s.dropQueued() + s.toSend = append(s.toSend, msg) + s.sendQueued() + + return nil +} + +func (s *session) prepMessageForSend(msg *Message) error { + s.fillDefaultHeader(*msg) + seqNum := s.store.NextSenderMsgSeqNum() + msg.Header.SetField(tagMsgSeqNum, FIXInt(seqNum)) + + var msgType FIXString + if err := msg.Header.GetField(tagMsgType, &msgType); err != nil { + return err + } + + if isAdminMessageType(string(msgType)) { + s.application.ToAdmin(*msg, s.sessionID) + } else { + if err := s.application.ToApp(*msg, s.sessionID); err != nil { + return err + } + } + + msgBytes, err := msg.Build() + if err == nil { + err = s.persist(seqNum, msgBytes) + } + + return err +} + +func (s *session) persist(seqNum int, msgBytes []byte) error { + if err := s.store.SaveMessage(seqNum, msgBytes); err != nil { + return err + } + + return s.store.IncrNextSenderMsgSeqNum() +} + +func (s *session) sendQueued() { + for _, msg := range s.toSend { + s.sendBytes(msg.rawMessage) + } + + s.dropQueued() +} + +func (s *session) dropQueued() { + s.toSend = s.toSend[:0] +} + +func (s *session) sendBytes(msg []byte) { + s.log.OnOutgoing(string(msg)) + s.messageOut <- msg + s.stateTimer.Reset(s.HeartBtInt) +} + +func (s *session) doTargetTooHigh(reject targetTooHigh) error { + s.log.OnEventf("MsgSeqNum too high, expecting %v but received %v", reject.ExpectedTarget, reject.ReceivedTarget) + + resend := NewMessage() + resend.Header.SetField(tagMsgType, FIXString("2")) + resend.Body.SetField(tagBeginSeqNo, FIXInt(reject.ExpectedTarget)) + + var endSeqNum = 0 + if s.sessionID.BeginString < enum.BeginStringFIX42 { + endSeqNum = 999999 + } + resend.Body.SetField(tagEndSeqNo, FIXInt(endSeqNum)) + + if err := s.send(resend); err != nil { + return err + } + + s.log.OnEventf("Sent ResendRequest FROM: %v TO: %v", reject.ExpectedTarget, endSeqNum) + + return nil +} + +func (s *session) handleLogon(msg Message) error { + //Grab default app ver id from fixt.1.1 logon + if s.sessionID.BeginString == enum.BeginStringFIXT11 { + var targetApplVerID FIXString + + if err := msg.Body.GetField(tagDefaultApplVerID, &targetApplVerID); err != nil { + return err + } + + s.targetDefaultApplVerID = string(targetApplVerID) + } + + resetStore := false + if s.InitiateLogon { + s.log.OnEvent("Received logon response") + } else { + s.log.OnEvent("Received logon request") + resetStore = s.ResetOnLogon + + if s.RefreshOnLogon { + if err := s.store.Refresh(); err != nil { + return err + } + } + } + + var resetSeqNumFlag FIXBoolean + if err := msg.Body.GetField(tagResetSeqNumFlag, &resetSeqNumFlag); err == nil { + if resetSeqNumFlag { + s.log.OnEvent("Logon contains ResetSeqNumFlag=Y, resetting sequence numbers to 1") + resetStore = true + } + } + + if resetStore { + if err := s.store.Reset(); err != nil { + return err + } + } + + if err := s.verifyIgnoreSeqNumTooHigh(msg); err != nil { + return err + } + + if !s.InitiateLogon { + var heartBtInt FIXInt + if err := msg.Body.GetField(tagHeartBtInt, &heartBtInt); err == nil { + s.HeartBtInt = time.Duration(heartBtInt) * time.Second + } + + s.log.OnEvent("Responding to logon request") + if err := s.sendLogon(resetStore, resetSeqNumFlag.Bool()); err != nil { + return err + } + } + + s.peerTimer.Reset(time.Duration(float64(1.2) * float64(s.HeartBtInt))) + s.application.OnLogon(s.sessionID) + + if err := s.checkTargetTooHigh(msg); err != nil { + switch TypedError := err.(type) { + case targetTooHigh: + return s.doTargetTooHigh(TypedError) + } + } + + return s.store.IncrNextTargetMsgSeqNum() +} + +func (s *session) initiateLogout(reason string) (err error) { + if err = s.sendLogout(reason); err != nil { + s.logError(err) + return + } + s.log.OnEvent("Inititated logout request") + time.AfterFunc(time.Duration(2)*time.Second, func() { s.sessionEvent <- internal.LogoutTimeout }) + + return +} + +func (s *session) verify(msg Message) MessageRejectError { + return s.verifySelect(msg, true, true) +} + +func (s *session) verifyIgnoreSeqNumTooHigh(msg Message) MessageRejectError { + return s.verifySelect(msg, false, true) +} + +func (s *session) verifyIgnoreSeqNumTooHighOrLow(msg Message) MessageRejectError { + return s.verifySelect(msg, false, false) +} + +func (s *session) verifySelect(msg Message, checkTooHigh bool, checkTooLow bool) MessageRejectError { + if reject := s.checkBeginString(msg); reject != nil { + return reject + } + + if reject := s.checkCompID(msg); reject != nil { + return reject + } + + if reject := s.checkSendingTime(msg); reject != nil { + return reject + } + + if checkTooLow { + if reject := s.checkTargetTooLow(msg); reject != nil { + return reject + } + } + + if checkTooHigh { + if reject := s.checkTargetTooHigh(msg); reject != nil { + return reject + } + } + + if s.validator != nil { + if reject := s.validator.Validate(msg); reject != nil { + return reject + } + } + + return s.fromCallback(msg) +} + +func (s *session) fromCallback(msg Message) MessageRejectError { + var msgType FIXString + if err := msg.Header.GetField(tagMsgType, &msgType); err != nil { + return err + } + + if isAdminMessageType(string(msgType)) { + return s.application.FromAdmin(msg, s.sessionID) + } + + return s.application.FromApp(msg, s.sessionID) +} + +func (s *session) checkTargetTooLow(msg Message) MessageRejectError { + var seqNum FIXInt + switch err := msg.Header.GetField(tagMsgSeqNum, &seqNum); { + case err != nil: + return RequiredTagMissing(tagMsgSeqNum) + case int(seqNum) < s.store.NextTargetMsgSeqNum(): + return targetTooLow{ReceivedTarget: int(seqNum), ExpectedTarget: s.store.NextTargetMsgSeqNum()} + } + + return nil +} + +func (s *session) checkTargetTooHigh(msg Message) MessageRejectError { + var seqNum FIXInt + switch err := msg.Header.GetField(tagMsgSeqNum, &seqNum); { + case err != nil: + return RequiredTagMissing(tagMsgSeqNum) + case int(seqNum) > s.store.NextTargetMsgSeqNum(): + return targetTooHigh{ReceivedTarget: int(seqNum), ExpectedTarget: s.store.NextTargetMsgSeqNum()} + } + + return nil +} + +func (s *session) checkCompID(msg Message) MessageRejectError { + var senderCompID FIXString + var targetCompID FIXString + + haveSender := msg.Header.GetField(tagSenderCompID, &senderCompID) + haveTarget := msg.Header.GetField(tagTargetCompID, &targetCompID) + + switch { + case haveSender != nil: + return RequiredTagMissing(tagSenderCompID) + case haveTarget != nil: + return RequiredTagMissing(tagTargetCompID) + case len(targetCompID) == 0: + return TagSpecifiedWithoutAValue(tagTargetCompID) + case len(senderCompID) == 0: + return TagSpecifiedWithoutAValue(tagSenderCompID) + case s.sessionID.SenderCompID != string(targetCompID) || s.sessionID.TargetCompID != string(senderCompID): + return compIDProblem() + } + + return nil +} + +func (s *session) checkSendingTime(msg Message) MessageRejectError { + if ok := msg.Header.Has(tagSendingTime); !ok { + return RequiredTagMissing(tagSendingTime) + } + + sendingTime := new(FIXUTCTimestamp) + if err := msg.Header.GetField(tagSendingTime, sendingTime); err != nil { + return err + } + + if delta := time.Since(sendingTime.Time); delta <= -1*time.Duration(120)*time.Second || delta >= time.Duration(120)*time.Second { + return sendingTimeAccuracyProblem() + } + + return nil +} + +func (s *session) checkBeginString(msg Message) MessageRejectError { + var beginString FIXString + switch err := msg.Header.GetField(tagBeginString, &beginString); { + case err != nil: + return RequiredTagMissing(tagBeginString) + case s.sessionID.BeginString != string(beginString): + return incorrectBeginString{} + } + + return nil +} + +func (s *session) doReject(msg Message, rej MessageRejectError) error { + reply := msg.reverseRoute() + + if s.sessionID.BeginString >= enum.BeginStringFIX42 { + + if rej.IsBusinessReject() { + reply.Header.SetField(tagMsgType, FIXString("j")) + reply.Body.SetField(tagBusinessRejectReason, FIXInt(rej.RejectReason())) + } else { + reply.Header.SetField(tagMsgType, FIXString("3")) + switch { + default: + reply.Body.SetField(tagSessionRejectReason, FIXInt(rej.RejectReason())) + case rej.RejectReason() > rejectReasonInvalidMsgType && s.sessionID.BeginString == enum.BeginStringFIX42: + //fix42 knows up to invalid msg type + } + + if refTagID := rej.RefTagID(); refTagID != nil { + reply.Body.SetField(tagRefTagID, FIXInt(*refTagID)) + } + } + reply.Body.SetField(tagText, FIXString(rej.Error())) + + var msgType FIXString + if err := msg.Header.GetField(tagMsgType, &msgType); err == nil { + reply.Body.SetField(tagRefMsgType, msgType) + } + } else { + reply.Header.SetField(tagMsgType, FIXString("3")) + + if refTagID := rej.RefTagID(); refTagID != nil { + reply.Body.SetField(tagText, FIXString(fmt.Sprintf("%s (%d)", rej.Error(), *refTagID))) + } else { + reply.Body.SetField(tagText, FIXString(rej.Error())) + } + } + + seqNum := new(FIXInt) + if err := msg.Header.GetField(tagMsgSeqNum, seqNum); err == nil { + reply.Body.SetField(tagRefSeqNum, seqNum) + } + + s.log.OnEventf("Message Rejected: %v", rej.Error()) + return s.send(reply) +} + +type fixIn struct { + bytes []byte + receiveTime time.Time +} + +func (s *session) onDisconnect() { + s.log.OnEvent("Disconnected") + if s.messageOut != nil { + close(s.messageOut) + s.messageOut = nil + } + + s.messageIn = nil +} + +func (s *session) onAdmin(msg interface{}) { + switch msg := msg.(type) { + + case connect: + + if s.IsConnected() { + if msg.err != nil { + msg.err <- errors.New("Already connected") + close(msg.err) + } + return + } + + if msg.err != nil { + close(msg.err) + } + + s.messageIn = msg.messageIn + s.messageOut = msg.messageOut + s.messageStash = make(map[int]Message) + + s.Connect(s) + + case stopReq: + s.Stop(s) + + case waitForInSessionReq: + if !s.IsSessionTime() { + msg.rep <- s.stateMachine.notifyOnInSessionTime + } + close(msg.rep) + } +} + +func (s *session) run() { + s.Start(s) + + defer func() { + s.stateTimer.Stop() + s.peerTimer.Stop() + }() + + for !s.Stopped() { + select { + + case msg := <-s.admin: + s.onAdmin(msg) + + case <-s.messageEvent: + s.SendAppMessages(s) + + case fixIn, ok := <-s.messageIn: + if !ok { + s.Disconnected(s) + } else { + s.Incoming(s, fixIn) + } + + case evt := <-s.sessionEvent: + s.Timeout(s, evt) + + case now := <-time.After(time.Second): + s.CheckSessionTime(s, now) + } + } +} diff --git a/vendor/github.com/quickfixgo/quickfix/session_factory.go b/vendor/github.com/quickfixgo/quickfix/session_factory.go new file mode 100644 index 0000000..4027cdb --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/session_factory.go @@ -0,0 +1,291 @@ +package quickfix + +import ( + "errors" + "net" + "strconv" + "time" + + "github.com/quickfixgo/quickfix/config" + "github.com/quickfixgo/quickfix/datadictionary" + "github.com/quickfixgo/quickfix/enum" + "github.com/quickfixgo/quickfix/internal" +) + +var dayLookup = map[string]time.Weekday{ + "Sunday": time.Sunday, + "Monday": time.Monday, + "Tuesday": time.Tuesday, + "Wednesday": time.Wednesday, + "Thursday": time.Thursday, + "Friday": time.Friday, + "Saturday": time.Saturday, + + "Sun": time.Sunday, + "Mon": time.Monday, + "Tue": time.Tuesday, + "Wed": time.Wednesday, + "Thu": time.Thursday, + "Fri": time.Friday, + "Sat": time.Saturday, +} + +var applVerIDLookup = map[string]string{ + enum.BeginStringFIX40: "2", + enum.BeginStringFIX41: "3", + enum.BeginStringFIX42: "4", + enum.BeginStringFIX43: "5", + enum.BeginStringFIX44: "6", + "FIX.5.0": "7", + "FIX.5.0SP1": "8", + "FIX.5.0SP2": "9", +} + +type sessionFactory struct { + //True if building sessions that initiate logon + BuildInitiators bool +} + +//Creates Session, associates with internal session registry +func (f sessionFactory) createSession( + sessionID SessionID, storeFactory MessageStoreFactory, settings *SessionSettings, + logFactory LogFactory, application Application, +) (session *session, err error) { + + if session, err = f.newSession(sessionID, storeFactory, settings, logFactory, application); err != nil { + return + } + + if err = registerSession(session); err != nil { + return + } + application.OnCreate(session.sessionID) + session.log.OnEvent("Created session") + + return +} + +func (f sessionFactory) newSession( + sessionID SessionID, storeFactory MessageStoreFactory, settings *SessionSettings, logFactory LogFactory, + application Application) (s *session, err error) { + s = &session{sessionID: sessionID} + + var validatorSettings = defaultValidatorSettings + if settings.HasSetting(config.ValidateFieldsOutOfOrder) { + if validatorSettings.CheckFieldsOutOfOrder, err = settings.BoolSetting(config.ValidateFieldsOutOfOrder); err != nil { + return + } + } + + if sessionID.IsFIXT() { + if s.DefaultApplVerID, err = settings.Setting(config.DefaultApplVerID); err != nil { + return + } + + if applVerID, ok := applVerIDLookup[s.DefaultApplVerID]; ok { + s.DefaultApplVerID = applVerID + } + + //If the transport or app data dictionary setting is set, the other also needs to be set. + if settings.HasSetting(config.TransportDataDictionary) || settings.HasSetting(config.AppDataDictionary) { + var transportDataDictionaryPath, appDataDictionaryPath string + if transportDataDictionaryPath, err = settings.Setting(config.TransportDataDictionary); err != nil { + return + } + + if appDataDictionaryPath, err = settings.Setting(config.AppDataDictionary); err != nil { + return + } + + var transportDataDictionary, appDataDictionary *datadictionary.DataDictionary + if transportDataDictionary, err = datadictionary.Parse(transportDataDictionaryPath); err != nil { + return + } + + if appDataDictionary, err = datadictionary.Parse(appDataDictionaryPath); err != nil { + return + } + + s.validator = &fixtValidator{transportDataDictionary, appDataDictionary, validatorSettings} + } + } else if settings.HasSetting(config.DataDictionary) { + var dataDictionaryPath string + if dataDictionaryPath, err = settings.Setting(config.DataDictionary); err != nil { + return + } + + var dataDictionary *datadictionary.DataDictionary + if dataDictionary, err = datadictionary.Parse(dataDictionaryPath); err != nil { + return + } + + s.validator = &fixValidator{dataDictionary, validatorSettings} + } + + if settings.HasSetting(config.ResetOnLogon) { + if s.ResetOnLogon, err = settings.BoolSetting(config.ResetOnLogon); err != nil { + return + } + } + + if settings.HasSetting(config.RefreshOnLogon) { + if s.RefreshOnLogon, err = settings.BoolSetting(config.RefreshOnLogon); err != nil { + return + } + } + + if settings.HasSetting(config.ResetOnLogout) { + if s.ResetOnLogout, err = settings.BoolSetting(config.ResetOnLogout); err != nil { + return + } + } + + if settings.HasSetting(config.StartTime) || settings.HasSetting(config.EndTime) { + var startTimeStr, endTimeStr string + if startTimeStr, err = settings.Setting(config.StartTime); err != nil { + return + } + + if endTimeStr, err = settings.Setting(config.EndTime); err != nil { + return + } + + var start, end internal.TimeOfDay + if start, err = internal.ParseTimeOfDay(startTimeStr); err != nil { + return + } + + if end, err = internal.ParseTimeOfDay(endTimeStr); err != nil { + return + } + + loc := time.UTC + if settings.HasSetting(config.TimeZone) { + var locStr string + if locStr, err = settings.Setting(config.TimeZone); err != nil { + return + } + + loc, err = time.LoadLocation(locStr) + if err != nil { + return + } + } + + if !settings.HasSetting(config.StartDay) && !settings.HasSetting(config.EndDay) { + s.SessionTime = internal.NewTimeRangeInLocation(start, end, loc) + } else { + var startDayStr, endDayStr string + if startDayStr, err = settings.Setting(config.StartDay); err != nil { + return + } + + if endDayStr, err = settings.Setting(config.EndDay); err != nil { + return + } + + parseDay := func(setting, dayStr string) (day time.Weekday, err error) { + day, ok := dayLookup[dayStr] + if !ok { + return day, IncorrectFormatForSetting{Setting: setting, Value: dayStr} + } + return + } + + var startDay, endDay time.Weekday + if startDay, err = parseDay(config.StartDay, startDayStr); err != nil { + return + } + + if endDay, err = parseDay(config.EndDay, endDayStr); err != nil { + return + } + + s.SessionTime = internal.NewWeekRangeInLocation(start, end, startDay, endDay, loc) + } + } + + if f.BuildInitiators { + if err = f.buildInitiatorSettings(s, settings); err != nil { + return + } + } + + if s.log, err = logFactory.CreateSessionLog(s.sessionID); err != nil { + return + } + + if s.store, err = storeFactory.Create(s.sessionID); err != nil { + return + } + + s.sessionEvent = make(chan internal.Event) + s.messageEvent = make(chan bool, 1) + s.admin = make(chan interface{}) + s.application = application + s.stateTimer = internal.EventTimer{Task: func() { s.sessionEvent <- internal.NeedHeartbeat }} + s.peerTimer = internal.EventTimer{Task: func() { s.sessionEvent <- internal.PeerTimeout }} + return +} + +func (f sessionFactory) buildInitiatorSettings(session *session, settings *SessionSettings) error { + session.InitiateLogon = true + + heartBtInt, err := settings.IntSetting(config.HeartBtInt) + if err != nil { + return err + } + + if heartBtInt <= 0 { + return errors.New("Heartbeat must be greater than zero") + } + session.HeartBtInt = time.Duration(heartBtInt) * time.Second + + session.ReconnectInterval = 30 * time.Second + if settings.HasSetting(config.ReconnectInterval) { + + interval, err := settings.IntSetting(config.ReconnectInterval) + if err != nil { + return err + } + + if interval <= 0 { + return errors.New("ReconnectInterval must be greater than zero") + } + + session.ReconnectInterval = time.Duration(interval) * time.Second + } + + return f.configureSocketConnectAddress(session, settings) +} + +func (f sessionFactory) configureSocketConnectAddress(session *session, settings *SessionSettings) (err error) { + session.SocketConnectAddress = []string{} + + var socketConnectHost, socketConnectPort string + for i := 0; ; { + + hostConfig := config.SocketConnectHost + portConfig := config.SocketConnectPort + + if i > 0 { + hostConfig = hostConfig + strconv.Itoa(i) + portConfig = portConfig + strconv.Itoa(i) + + if !(settings.HasSetting(hostConfig) || settings.HasSetting(portConfig)) { + return + } + } + + if socketConnectHost, err = settings.Setting(hostConfig); err != nil { + return + } + + if socketConnectPort, err = settings.Setting(portConfig); err != nil { + return + } + + session.SocketConnectAddress = append(session.SocketConnectAddress, net.JoinHostPort(socketConnectHost, socketConnectPort)) + i++ + } +} diff --git a/vendor/github.com/quickfixgo/quickfix/session_id.go b/vendor/github.com/quickfixgo/quickfix/session_id.go new file mode 100644 index 0000000..7dfc6d8 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/session_id.go @@ -0,0 +1,24 @@ +package quickfix + +import ( + "fmt" + "github.com/quickfixgo/quickfix/enum" +) + +// SessionID is a unique identifer of a Session +type SessionID struct { + BeginString, TargetCompID, TargetSubID, TargetLocationID, SenderCompID, SenderSubID, SenderLocationID, Qualifier string +} + +//IsFIXT returns true if the SessionID has a FIXT BeginString +func (s SessionID) IsFIXT() bool { + return s.BeginString == enum.BeginStringFIXT11 +} + +func (s SessionID) String() string { + if len(s.Qualifier) > 0 { + return fmt.Sprintf("%s:%s->%s:%s", s.BeginString, s.SenderCompID, s.TargetCompID, s.Qualifier) + } + + return fmt.Sprintf("%s:%s->%s", s.BeginString, s.SenderCompID, s.TargetCompID) +} diff --git a/vendor/github.com/quickfixgo/quickfix/session_rejects.go b/vendor/github.com/quickfixgo/quickfix/session_rejects.go new file mode 100644 index 0000000..ba9e6ec --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/session_rejects.go @@ -0,0 +1,32 @@ +package quickfix + +import ( + "fmt" +) + +//IncorrectBeginString is a message reject specific to incorrect begin strings. +type incorrectBeginString struct{ messageRejectError } + +func (e incorrectBeginString) Error() string { return "Incorrect BeginString" } + +//targetTooHigh is a MessageReject where the sequence number is larger than expected. +type targetTooHigh struct { + messageRejectError + ReceivedTarget int + ExpectedTarget int +} + +func (e targetTooHigh) Error() string { + return fmt.Sprintf("MsgSeqNum too high, expecting %d but received %d", e.ExpectedTarget, e.ReceivedTarget) +} + +//targetTooLow is a MessageReject where the sequence number is less than expected. +type targetTooLow struct { + messageRejectError + ReceivedTarget int + ExpectedTarget int +} + +func (e targetTooLow) Error() string { + return fmt.Sprintf("MsgSeqNum too low, expecting %d but received %d", e.ExpectedTarget, e.ReceivedTarget) +} diff --git a/vendor/github.com/quickfixgo/quickfix/session_settings.go b/vendor/github.com/quickfixgo/quickfix/session_settings.go new file mode 100644 index 0000000..130bf96 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/session_settings.go @@ -0,0 +1,135 @@ +package quickfix + +import ( + "fmt" + "strconv" + "time" +) + +//SessionSettings maps session settings to values with typed accessors. +type SessionSettings struct { + settings map[string]string +} + +//ConditionallyRequiredSetting indicates a missing setting +type ConditionallyRequiredSetting struct { + Setting string +} + +func (e ConditionallyRequiredSetting) Error() string { + return fmt.Sprintf("Conditionally Required Setting: %v", e.Setting) +} + +//IncorrectFormatForSetting indicates a setting that is incorrectly formatted +type IncorrectFormatForSetting struct { + Setting, Value string + Err error +} + +func (e IncorrectFormatForSetting) Error() string { + return fmt.Sprintf("%q is invalid for %s", e.Value, e.Setting) +} + +//Init initializes or resets SessionSettings +func (s *SessionSettings) Init() { + s.settings = make(map[string]string) +} + +//NewSessionSettings returns a newly initialized SessionSettings instance +func NewSessionSettings() *SessionSettings { + s := &SessionSettings{} + s.Init() + + return s +} + +//Set assigns a value to a setting on SessionSettings. +func (s *SessionSettings) Set(setting string, val string) { + //lazy init + if s.settings == nil { + s.Init() + } + + s.settings[setting] = val +} + +//HasSetting returns true if a setting is set, false if not +func (s *SessionSettings) HasSetting(setting string) bool { + _, ok := s.settings[setting] + return ok +} + +//Setting is a settings string accessor. Returns an error if the setting is missing. +func (s *SessionSettings) Setting(setting string) (string, error) { + val, ok := s.settings[setting] + if !ok { + return val, ConditionallyRequiredSetting{setting} + } + + return val, nil +} + +//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 (s *SessionSettings) IntSetting(setting string) (val int, err error) { + stringVal, err := s.Setting(setting) + + if err != nil { + return + } + + if val, err = strconv.Atoi(stringVal); err != nil { + return val, IncorrectFormatForSetting{Setting: setting, Value: stringVal, Err: err} + } + + return +} + +//DurationSetting returns the requested setting parsed as a time.Duration. +//Returns an error if the setting is not set or cannot be parsed as a time.Duration. +func (s *SessionSettings) DurationSetting(setting string) (val time.Duration, err error) { + stringVal, err := s.Setting(setting) + + if err != nil { + return + } + + if val, err = time.ParseDuration(stringVal); err != nil { + return val, IncorrectFormatForSetting{Setting: setting, Value: stringVal, Err: err} + } + + return +} + +//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 (s SessionSettings) BoolSetting(setting string) (bool, error) { + stringVal, err := s.Setting(setting) + + if err != nil { + return false, err + } + + switch stringVal { + case "Y", "y": + return true, nil + case "N", "n": + return false, nil + } + + return false, IncorrectFormatForSetting{Setting: setting, Value: stringVal} +} + +func (s *SessionSettings) overlay(overlay *SessionSettings) { + for key, val := range overlay.settings { + s.settings[key] = val + } +} + +func (s *SessionSettings) clone() *SessionSettings { + sClone := NewSessionSettings() + + for k, v := range s.settings { + sClone.settings[k] = v + } + + return sClone +} diff --git a/vendor/github.com/quickfixgo/quickfix/session_state.go b/vendor/github.com/quickfixgo/quickfix/session_state.go new file mode 100644 index 0000000..7645919 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/session_state.go @@ -0,0 +1,249 @@ +package quickfix + +import ( + "fmt" + "time" + + "github.com/quickfixgo/quickfix/internal" +) + +type stateMachine struct { + State sessionState + pendingStop, stopped bool + notifyOnInSessionTime chan interface{} +} + +func (sm *stateMachine) Start(s *session) { + sm.pendingStop = false + sm.stopped = false + + sm.State = latentState{} + sm.CheckSessionTime(s, time.Now()) +} + +func (sm *stateMachine) Connect(session *session) { + if !sm.IsSessionTime() { + session.log.OnEvent("Connection outside of session time") + sm.handleDisconnectState(session) + return + } + + if session.InitiateLogon { + if session.RefreshOnLogon { + if err := session.store.Refresh(); err != nil { + session.logError(err) + return + } + } + + session.log.OnEvent("Sending logon request") + if err := session.sendLogon(false, false); err != nil { + session.logError(err) + return + } + } + + sm.setState(session, logonState{}) +} + +func (sm *stateMachine) Stop(session *session) { + sm.pendingStop = true + sm.setState(session, sm.State.Stop(session)) +} + +func (sm *stateMachine) Stopped() bool { + return sm.stopped +} + +func (sm *stateMachine) Disconnected(session *session) { + if sm.IsConnected() { + sm.setState(session, latentState{}) + } +} + +func (sm *stateMachine) Incoming(session *session, m fixIn) { + sm.CheckSessionTime(session, time.Now()) + if !sm.IsConnected() { + return + } + + session.log.OnIncoming(string(m.bytes)) + if msg, err := ParseMessage(m.bytes); err != nil { + session.log.OnEventf("Msg Parse Error: %v, %q", err.Error(), m.bytes) + } else { + msg.ReceiveTime = m.receiveTime + sm.fixMsgIn(session, msg) + } + session.peerTimer.Reset(time.Duration(float64(1.2) * float64(session.HeartBtInt))) +} + +func (sm *stateMachine) fixMsgIn(session *session, m Message) { + sm.setState(session, sm.State.FixMsgIn(session, m)) +} + +func (sm *stateMachine) SendAppMessages(session *session) { + sm.CheckSessionTime(session, time.Now()) + + session.sendMutex.Lock() + defer session.sendMutex.Unlock() + + if session.IsLoggedOn() { + session.sendQueued() + } else { + session.dropQueued() + } +} + +func (sm *stateMachine) Timeout(session *session, e internal.Event) { + sm.CheckSessionTime(session, time.Now()) + sm.setState(session, sm.State.Timeout(session, e)) +} + +func (sm *stateMachine) CheckSessionTime(session *session, now time.Time) { + if !session.SessionTime.IsInRange(now) { + if sm.IsSessionTime() { + session.log.OnEvent("Not in session") + } + + sm.State.ShutdownNow(session) + sm.setState(session, notSessionTime{}) + + if sm.notifyOnInSessionTime == nil { + sm.notifyOnInSessionTime = make(chan interface{}) + } + return + } + + if !sm.IsSessionTime() { + session.log.OnEvent("In session") + sm.notifyInSessionTime() + sm.setState(session, latentState{}) + } + + if !session.SessionTime.IsInSameRange(session.store.CreationTime(), now) { + session.log.OnEvent("Session reset") + sm.State.ShutdownNow(session) + if err := session.dropAndReset(); err != nil { + session.logError(err) + } + sm.setState(session, latentState{}) + } +} + +func (sm *stateMachine) setState(session *session, nextState sessionState) { + if !nextState.IsConnected() { + if sm.IsConnected() { + sm.handleDisconnectState(session) + } + + if sm.pendingStop { + sm.stopped = true + sm.notifyInSessionTime() + } + } + + sm.State = nextState +} + +func (sm *stateMachine) notifyInSessionTime() { + if sm.notifyOnInSessionTime != nil { + close(sm.notifyOnInSessionTime) + } + sm.notifyOnInSessionTime = nil +} + +func (sm *stateMachine) handleDisconnectState(s *session) { + doOnLogout := s.IsLoggedOn() + + switch s.State.(type) { + case logoutState: + doOnLogout = true + case logonState: + if s.InitiateLogon { + doOnLogout = true + } + } + + if doOnLogout { + s.application.OnLogout(s.sessionID) + } + + s.onDisconnect() +} + +func (sm *stateMachine) IsLoggedOn() bool { + return sm.State.IsLoggedOn() +} + +func (sm *stateMachine) IsConnected() bool { + return sm.State.IsConnected() +} + +func (sm *stateMachine) IsSessionTime() bool { + return sm.State.IsSessionTime() +} + +func handleStateError(s *session, err error) sessionState { + s.logError(err) + return latentState{} +} + +//sessionState is the current state of the session state machine. The session state determines how the session responds to +//incoming messages, timeouts, and requests to send application messages. +type sessionState interface { + //FixMsgIn is called by the session on incoming messages from the counter party. The return type is the next session state + //following message processing + FixMsgIn(*session, Message) (nextState sessionState) + + //Timeout is called by the session on a timeout event. + Timeout(*session, internal.Event) (nextState sessionState) + + //IsLoggedOn returns true if state is logged on an in session, false otherwise + IsLoggedOn() bool + + //IsConnected returns true if the state is connected + IsConnected() bool + + //IsSessionTime returns true if the state is in session time + IsSessionTime() bool + + //ShutdownNow terminates the session state immediately + ShutdownNow(*session) + + //Stop triggers a clean stop + Stop(*session) (nextState sessionState) + + //debugging convenience + fmt.Stringer +} + +type inSessionTime struct{} + +func (inSessionTime) IsSessionTime() bool { return true } + +type connected struct{} + +func (connected) IsConnected() bool { return true } +func (connected) IsSessionTime() bool { return true } + +type connectedNotLoggedOn struct{ connected } + +func (connectedNotLoggedOn) IsLoggedOn() bool { return false } +func (connectedNotLoggedOn) ShutdownNow(*session) {} + +type loggedOn struct{ connected } + +func (loggedOn) IsLoggedOn() bool { return true } +func (loggedOn) ShutdownNow(s *session) { + if err := s.sendLogout(""); err != nil { + s.logError(err) + } +} + +func (loggedOn) Stop(s *session) (nextState sessionState) { + if err := s.initiateLogout(""); err != nil { + return handleStateError(s, err) + } + + return logoutState{} +} diff --git a/vendor/github.com/quickfixgo/quickfix/settings.go b/vendor/github.com/quickfixgo/quickfix/settings.go new file mode 100644 index 0000000..97c9353 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/settings.go @@ -0,0 +1,147 @@ +package quickfix + +import ( + "bufio" + "fmt" + "io" + "regexp" + + "github.com/quickfixgo/quickfix/config" +) + +//The Settings type represents a collection of global and session settings. +type Settings struct { + globalSettings *SessionSettings + sessionSettings map[SessionID]*SessionSettings +} + +//Init initializes or resets a Settings instance +func (s *Settings) Init() { + s.globalSettings = NewSessionSettings() + s.sessionSettings = make(map[SessionID]*SessionSettings) +} + +func (s *Settings) lazyInit() { + if s.globalSettings == nil { + s.Init() + } +} + +//NewSettings creates a Settings instance +func NewSettings() *Settings { + s := &Settings{} + s.Init() + return s +} + +func sessionIDFromSessionSettings(globalSettings *SessionSettings, sessionSettings *SessionSettings) SessionID { + sessionID := SessionID{} + + for _, settings := range []*SessionSettings{globalSettings, sessionSettings} { + if settings.HasSetting(config.BeginString) { + sessionID.BeginString, _ = settings.Setting(config.BeginString) + } + + if settings.HasSetting(config.TargetCompID) { + sessionID.TargetCompID, _ = settings.Setting(config.TargetCompID) + } + + if settings.HasSetting(config.SenderCompID) { + sessionID.SenderCompID, _ = settings.Setting(config.SenderCompID) + } + + if settings.HasSetting(config.SessionQualifier) { + sessionID.Qualifier, _ = settings.Setting(config.SessionQualifier) + } + } + + return sessionID +} + +//ParseSettings creates and initializes a Settings instance with config parsed from a Reader. +//Returns error if the config is has parse errors +func ParseSettings(reader io.Reader) (*Settings, error) { + s := NewSettings() + + scanner := bufio.NewScanner(reader) + blankRegEx := regexp.MustCompile(`^\s*$`) + commentRegEx := regexp.MustCompile(`^#.*`) + defaultRegEx := regexp.MustCompile(`^\[(?i)DEFAULT\]\s*$`) + sessionRegEx := regexp.MustCompile(`^\[(?i)SESSION\]\s*$`) + settingRegEx := regexp.MustCompile(`^([^=]*)=(.*)$`) + + var settings *SessionSettings + + lineNumber := 0 + for scanner.Scan() { + lineNumber++ + line := scanner.Text() + + switch { + case commentRegEx.MatchString(line) || blankRegEx.MatchString(line): + continue + + case defaultRegEx.MatchString(line): + settings = s.GlobalSettings() + + case sessionRegEx.MatchString(line): + if settings != nil && settings != s.GlobalSettings() { + if _, err := s.AddSession(settings); err != nil { + return nil, err + } + } + settings = NewSessionSettings() + + case settingRegEx.MatchString(line): + parts := settingRegEx.FindStringSubmatch(line) + settings.Set(parts[1], parts[2]) + + default: + return s, fmt.Errorf("error parsing line %v", lineNumber) + } + } + + if err := scanner.Err(); err != nil { + return s, err + } + + if settings == nil || settings == s.GlobalSettings() { + return s, fmt.Errorf("no sessions declared") + } + _, err := s.AddSession(settings) + + return s, err +} + +//GlobalSettings are default setting inherited by all session settings. +func (s *Settings) GlobalSettings() *SessionSettings { + s.lazyInit() + return s.globalSettings +} + +//SessionSettings return all session settings overlaying globalsettings. +func (s *Settings) SessionSettings() map[SessionID]*SessionSettings { + allSessionSettings := make(map[SessionID]*SessionSettings) + + for sessionID, settings := range s.sessionSettings { + cloneSettings := s.globalSettings.clone() + cloneSettings.overlay(settings) + allSessionSettings[sessionID] = cloneSettings + } + + return allSessionSettings +} + +//AddSession adds Session Settings to Settings instance. Returns an error if session settings with duplicate sessionID has already been added +func (s *Settings) AddSession(sessionSettings *SessionSettings) (SessionID, error) { + s.lazyInit() + + sessionID := sessionIDFromSessionSettings(s.GlobalSettings(), sessionSettings) + if _, dup := s.sessionSettings[sessionID]; dup { + return sessionID, fmt.Errorf("duplicate session configured for %v", sessionID) + } + + s.sessionSettings[sessionID] = sessionSettings + + return sessionID, nil +} diff --git a/vendor/github.com/quickfixgo/quickfix/sqlstore.go b/vendor/github.com/quickfixgo/quickfix/sqlstore.go new file mode 100644 index 0000000..745ec82 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/sqlstore.go @@ -0,0 +1,278 @@ +package quickfix + +import ( + "database/sql" + "fmt" + "time" + + "github.com/quickfixgo/quickfix/config" +) + +type sqlStoreFactory struct { + settings *Settings +} + +type sqlStore struct { + sessionID SessionID + cache *memoryStore + sqlDriver string + sqlDataSourceName string + sqlConnMaxLifetime time.Duration + db *sql.DB +} + +// NewSQLStoreFactory returns a sql-based implementation of MessageStoreFactory +func NewSQLStoreFactory(settings *Settings) MessageStoreFactory { + return sqlStoreFactory{settings: settings} +} + +// Create creates a new SQLStore implementation of the MessageStore interface +func (f sqlStoreFactory) Create(sessionID SessionID) (msgStore MessageStore, err error) { + sessionSettings, ok := f.settings.SessionSettings()[sessionID] + if !ok { + return nil, fmt.Errorf("unknown session: %v", sessionID) + } + sqlDriver, err := sessionSettings.Setting(config.SQLDriver) + if err != nil { + return nil, err + } + sqlDataSourceName, err := sessionSettings.Setting(config.SQLDataSourceName) + if err != nil { + return nil, err + } + sqlConnMaxLifetime := 0 * time.Second + if sessionSettings.HasSetting(config.SQLConnMaxLifetime) { + sqlConnMaxLifetime, err = sessionSettings.DurationSetting(config.SQLConnMaxLifetime) + if err != nil { + return nil, err + } + } + return newSQLStore(sessionID, sqlDriver, sqlDataSourceName, sqlConnMaxLifetime) +} + +func newSQLStore(sessionID SessionID, driver string, dataSourceName string, connMaxLifetime time.Duration) (store *sqlStore, err error) { + store = &sqlStore{ + sessionID: sessionID, + cache: &memoryStore{}, + sqlDriver: driver, + sqlDataSourceName: dataSourceName, + sqlConnMaxLifetime: connMaxLifetime, + } + store.cache.Reset() + + if store.db, err = sql.Open(store.sqlDriver, store.sqlDataSourceName); err != nil { + return nil, err + } + store.db.SetConnMaxLifetime(store.sqlConnMaxLifetime) + + if err = store.db.Ping(); err != nil { // ensure immediate connection + return nil, err + } + if err = store.populateCache(); err != nil { + return nil, err + } + + return store, nil +} + +// Reset deletes the store records and sets the seqnums back to 1 +func (store *sqlStore) Reset() error { + s := store.sessionID + _, err := store.db.Exec(`DELETE FROM messages + WHERE beginstring=? AND session_qualifier=? + AND sendercompid=? AND sendersubid=? AND senderlocid=? + AND targetcompid=? AND targetsubid=? AND targetlocid=?`, + s.BeginString, s.Qualifier, + s.SenderCompID, s.SenderSubID, s.SenderLocationID, + s.TargetCompID, s.TargetSubID, s.TargetLocationID) + if err != nil { + return err + } + + if err = store.cache.Reset(); err != nil { + return err + } + + _, err = store.db.Exec(`UPDATE sessions + SET creation_time=?, incoming_seqnum=?, outgoing_seqnum=? + WHERE beginstring=? AND session_qualifier=? + AND sendercompid=? AND sendersubid=? AND senderlocid=? + AND targetcompid=? AND targetsubid=? AND targetlocid=?`, + store.cache.CreationTime(), store.cache.NextTargetMsgSeqNum(), store.cache.NextSenderMsgSeqNum(), + s.BeginString, s.Qualifier, + s.SenderCompID, s.SenderSubID, s.SenderLocationID, + s.TargetCompID, s.TargetSubID, s.TargetLocationID) + + return err +} + +// Refresh reloads the store from the database +func (store *sqlStore) Refresh() error { + if err := store.cache.Reset(); err != nil { + return err + } + return store.populateCache() +} + +func (store *sqlStore) populateCache() (err error) { + s := store.sessionID + var creationTime time.Time + var incomingSeqNum, outgoingSeqNum int + row := store.db.QueryRow(`SELECT creation_time, incoming_seqnum, outgoing_seqnum + FROM sessions + WHERE beginstring=? AND session_qualifier=? + AND sendercompid=? AND sendersubid=? AND senderlocid=? + AND targetcompid=? AND targetsubid=? AND targetlocid=?`, + s.BeginString, s.Qualifier, + s.SenderCompID, s.SenderSubID, s.SenderLocationID, + s.TargetCompID, s.TargetSubID, s.TargetLocationID) + + err = row.Scan(&creationTime, &incomingSeqNum, &outgoingSeqNum) + + // session record found, load it + if err == nil { + store.cache.creationTime = creationTime + store.cache.SetNextTargetMsgSeqNum(incomingSeqNum) + store.cache.SetNextSenderMsgSeqNum(outgoingSeqNum) + return nil + } + + // fatal error, give up + if err != sql.ErrNoRows { + return err + } + + // session record not found, create it + _, err = store.db.Exec(`INSERT INTO sessions ( + creation_time, incoming_seqnum, outgoing_seqnum, + beginstring, session_qualifier, + sendercompid, sendersubid, senderlocid, + targetcompid, targetsubid, targetlocid) + VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, + store.cache.creationTime, + store.cache.NextTargetMsgSeqNum(), + store.cache.NextSenderMsgSeqNum(), + s.BeginString, s.Qualifier, + s.SenderCompID, s.SenderSubID, s.SenderLocationID, + s.TargetCompID, s.TargetSubID, s.TargetLocationID) + + return err +} + +// NextSenderMsgSeqNum returns the next MsgSeqNum that will be sent +func (store *sqlStore) NextSenderMsgSeqNum() int { + return store.cache.NextSenderMsgSeqNum() +} + +// NextTargetMsgSeqNum returns the next MsgSeqNum that should be received +func (store *sqlStore) NextTargetMsgSeqNum() int { + return store.cache.NextTargetMsgSeqNum() +} + +// SetNextSenderMsgSeqNum sets the next MsgSeqNum that will be sent +func (store *sqlStore) SetNextSenderMsgSeqNum(next int) error { + s := store.sessionID + _, err := store.db.Exec(`UPDATE sessions SET outgoing_seqnum = ? + WHERE beginstring=? AND session_qualifier=? + AND sendercompid=? AND sendersubid=? AND senderlocid=? + AND targetcompid=? AND targetsubid=? AND targetlocid=?`, + next, s.BeginString, s.Qualifier, + s.SenderCompID, s.SenderSubID, s.SenderLocationID, + s.TargetCompID, s.TargetSubID, s.TargetLocationID) + if err != nil { + return err + } + return store.cache.SetNextSenderMsgSeqNum(next) +} + +// SetNextTargetMsgSeqNum sets the next MsgSeqNum that should be received +func (store *sqlStore) SetNextTargetMsgSeqNum(next int) error { + s := store.sessionID + _, err := store.db.Exec(`UPDATE sessions SET incoming_seqnum = ? + WHERE beginstring=? AND session_qualifier=? + AND sendercompid=? AND sendersubid=? AND senderlocid=? + AND targetcompid=? AND targetsubid=? AND targetlocid=?`, + next, s.BeginString, s.Qualifier, + s.SenderCompID, s.SenderSubID, s.SenderLocationID, + s.TargetCompID, s.TargetSubID, s.TargetLocationID) + if err != nil { + return err + } + return store.cache.SetNextTargetMsgSeqNum(next) +} + +// IncrNextSenderMsgSeqNum increments the next MsgSeqNum that will be sent +func (store *sqlStore) IncrNextSenderMsgSeqNum() error { + store.cache.IncrNextSenderMsgSeqNum() + return store.SetNextSenderMsgSeqNum(store.cache.NextSenderMsgSeqNum()) +} + +// IncrNextTargetMsgSeqNum increments the next MsgSeqNum that should be received +func (store *sqlStore) IncrNextTargetMsgSeqNum() error { + store.cache.IncrNextTargetMsgSeqNum() + return store.SetNextTargetMsgSeqNum(store.cache.NextTargetMsgSeqNum()) +} + +// CreationTime returns the creation time of the store +func (store *sqlStore) CreationTime() time.Time { + return store.cache.CreationTime() +} + +func (store *sqlStore) SaveMessage(seqNum int, msg []byte) error { + s := store.sessionID + + _, err := store.db.Exec(`INSERT INTO messages ( + msgseqnum, message, + beginstring, session_qualifier, + sendercompid, sendersubid, senderlocid, + targetcompid, targetsubid, targetlocid) + VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, + seqNum, string(msg), + s.BeginString, s.Qualifier, + s.SenderCompID, s.SenderSubID, s.SenderLocationID, + s.TargetCompID, s.TargetSubID, s.TargetLocationID) + + return err +} + +func (store *sqlStore) GetMessages(beginSeqNum, endSeqNum int) ([][]byte, error) { + s := store.sessionID + var msgs [][]byte + rows, err := store.db.Query(`SELECT message FROM messages + WHERE beginstring=? AND session_qualifier=? + AND sendercompid=? AND sendersubid=? AND senderlocid=? + AND targetcompid=? AND targetsubid=? AND targetlocid=? + AND msgseqnum>=? AND msgseqnum<=? + ORDER BY msgseqnum`, + s.BeginString, s.Qualifier, + s.SenderCompID, s.SenderSubID, s.SenderLocationID, + s.TargetCompID, s.TargetSubID, s.TargetLocationID, + beginSeqNum, endSeqNum) + if err != nil { + return nil, err + } + defer rows.Close() + + for rows.Next() { + var message string + if err := rows.Scan(&message); err != nil { + return nil, err + } + msgs = append(msgs, []byte(message)) + } + + if err := rows.Err(); err != nil { + return nil, err + } + + return msgs, nil +} + +// Close closes the store's database connection +func (store *sqlStore) Close() error { + if store.db != nil { + store.db.Close() + store.db = nil + } + return nil +} diff --git a/vendor/github.com/quickfixgo/quickfix/store.go b/vendor/github.com/quickfixgo/quickfix/store.go new file mode 100644 index 0000000..7765a47 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/store.go @@ -0,0 +1,115 @@ +package quickfix + +import "time" + +//The MessageStore interface provides methods to record and retrieve messages for resend purposes +type MessageStore interface { + NextSenderMsgSeqNum() int + NextTargetMsgSeqNum() int + + IncrNextSenderMsgSeqNum() error + IncrNextTargetMsgSeqNum() error + + SetNextSenderMsgSeqNum(next int) error + SetNextTargetMsgSeqNum(next int) error + + CreationTime() time.Time + + SaveMessage(seqNum int, msg []byte) error + GetMessages(beginSeqNum, endSeqNum int) ([][]byte, error) + + Refresh() error + Reset() error + + Close() error +} + +//The MessageStoreFactory interface is used by session to create a session specific message store +type MessageStoreFactory interface { + Create(sessionID SessionID) (MessageStore, error) +} + +type memoryStore struct { + senderMsgSeqNum, targetMsgSeqNum int + creationTime time.Time + messageMap map[int][]byte +} + +func (store memoryStore) NextSenderMsgSeqNum() int { + return store.senderMsgSeqNum + 1 +} + +func (store memoryStore) NextTargetMsgSeqNum() int { + return store.targetMsgSeqNum + 1 +} + +func (store *memoryStore) IncrNextSenderMsgSeqNum() error { + store.senderMsgSeqNum++ + return nil +} + +func (store *memoryStore) IncrNextTargetMsgSeqNum() error { + store.targetMsgSeqNum++ + return nil +} + +func (store *memoryStore) SetNextSenderMsgSeqNum(nextSeqNum int) error { + store.senderMsgSeqNum = nextSeqNum - 1 + return nil +} +func (store *memoryStore) SetNextTargetMsgSeqNum(nextSeqNum int) error { + store.targetMsgSeqNum = nextSeqNum - 1 + return nil +} + +func (store memoryStore) CreationTime() time.Time { + return store.creationTime +} + +func (store *memoryStore) Reset() error { + store.senderMsgSeqNum = 0 + store.targetMsgSeqNum = 0 + store.creationTime = time.Now() + store.messageMap = nil + return nil +} + +func (store *memoryStore) Refresh() error { + //nop, nothing to refresh + return nil +} + +func (store *memoryStore) Close() error { + //nop, nothing to close + return nil +} + +func (store *memoryStore) SaveMessage(seqNum int, msg []byte) error { + if store.messageMap == nil { + store.messageMap = make(map[int][]byte) + } + + store.messageMap[seqNum] = msg + return nil +} + +func (store memoryStore) GetMessages(beginSeqNum, endSeqNum int) ([][]byte, error) { + var msgs [][]byte + for seqNum := beginSeqNum; seqNum <= endSeqNum; seqNum++ { + if m, ok := store.messageMap[seqNum]; ok { + msgs = append(msgs, m) + } + } + return msgs, nil +} + +type memoryStoreFactory struct{} + +func (f memoryStoreFactory) Create(sessionID SessionID) (MessageStore, error) { + var m memoryStore + m.Reset() + return &m, nil +} + +//NewMemoryStoreFactory returns a MessageStoreFactory instance that created in-memory MessageStores +func NewMemoryStoreFactory() MessageStoreFactory { return memoryStoreFactory{} } diff --git a/vendor/github.com/quickfixgo/quickfix/tag.go b/vendor/github.com/quickfixgo/quickfix/tag.go new file mode 100644 index 0000000..800375e --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/tag.go @@ -0,0 +1,114 @@ +package quickfix + +//Tag is a typed int representing a FIX tag +type Tag int + +const ( + tagBeginString Tag = 8 + tagBodyLength Tag = 9 + tagMsgType Tag = 35 + tagSenderCompID Tag = 49 + tagTargetCompID Tag = 56 + tagOnBehalfOfCompID Tag = 115 + tagDeliverToCompID Tag = 128 + tagSecureDataLen Tag = 90 + tagMsgSeqNum Tag = 34 + tagSenderSubID Tag = 50 + tagSenderLocationID Tag = 142 + tagTargetSubID Tag = 57 + tagTargetLocationID Tag = 143 + tagOnBehalfOfSubID Tag = 116 + tagOnBehalfOfLocationID Tag = 144 + tagDeliverToSubID Tag = 129 + tagDeliverToLocationID Tag = 145 + tagPossDupFlag Tag = 43 + tagPossResend Tag = 97 + tagSendingTime Tag = 52 + tagOrigSendingTime Tag = 122 + tagXMLDataLen Tag = 212 + tagXMLData Tag = 213 + tagMessageEncoding Tag = 347 + tagLastMsgSeqNumProcessed Tag = 369 + tagOnBehalfOfSendingTime Tag = 370 + tagApplVerID Tag = 1128 + tagCstmApplVerID Tag = 1129 + tagNoHops Tag = 627 + tagApplExtID Tag = 1156 + tagSecureData Tag = 91 + tagHopCompID Tag = 628 + tagHopSendingTime Tag = 629 + tagHopRefID Tag = 630 + + tagHeartBtInt Tag = 108 + tagBusinessRejectReason Tag = 380 + tagSessionRejectReason Tag = 373 + tagRefMsgType Tag = 372 + tagRefTagID Tag = 371 + tagRefSeqNum Tag = 45 + tagEncryptMethod Tag = 98 + tagResetSeqNumFlag Tag = 141 + tagDefaultApplVerID Tag = 1137 + tagText Tag = 58 + tagTestReqID Tag = 112 + tagGapFillFlag Tag = 123 + tagNewSeqNo Tag = 36 + tagBeginSeqNo Tag = 7 + tagEndSeqNo Tag = 16 + + tagSignatureLength Tag = 93 + tagSignature Tag = 89 + tagCheckSum Tag = 10 +) + +//IsTrailer returns true if tag belongs in the message trailer +func (t Tag) IsTrailer() bool { + switch t { + case tagSignatureLength, tagSignature, tagCheckSum: + return true + } + return false +} + +//IsHeader returns true if tag belongs in the message header +func (t Tag) IsHeader() bool { + switch t { + case tagBeginString, + tagBodyLength, + tagMsgType, + tagSenderCompID, + tagTargetCompID, + tagOnBehalfOfCompID, + tagDeliverToCompID, + tagSecureDataLen, + tagMsgSeqNum, + tagSenderSubID, + tagSenderLocationID, + tagTargetSubID, + tagTargetLocationID, + tagOnBehalfOfSubID, + tagOnBehalfOfLocationID, + tagDeliverToSubID, + tagDeliverToLocationID, + tagPossDupFlag, + tagPossResend, + tagSendingTime, + tagOrigSendingTime, + tagXMLDataLen, + tagXMLData, + tagMessageEncoding, + tagLastMsgSeqNumProcessed, + tagOnBehalfOfSendingTime, + tagApplVerID, + tagCstmApplVerID, + tagNoHops, + tagApplExtID, + tagSecureData, + tagHopCompID, + tagHopSendingTime, + tagHopRefID: + + return true + } + + return false +} diff --git a/vendor/github.com/quickfixgo/quickfix/tag/tag_numbers.generated.go b/vendor/github.com/quickfixgo/quickfix/tag/tag_numbers.generated.go new file mode 100644 index 0000000..e7419a0 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/tag/tag_numbers.generated.go @@ -0,0 +1,1656 @@ +package tag + +import ( + "github.com/quickfixgo/quickfix" +) + +const ( + Account quickfix.Tag = 1 + AccountType quickfix.Tag = 581 + AccruedInterestAmt quickfix.Tag = 159 + AccruedInterestRate quickfix.Tag = 158 + AcctIDSource quickfix.Tag = 660 + Adjustment quickfix.Tag = 334 + AdjustmentType quickfix.Tag = 718 + AdvId quickfix.Tag = 2 + AdvRefID quickfix.Tag = 3 + AdvSide quickfix.Tag = 4 + AdvTransType quickfix.Tag = 5 + AffectedOrderID quickfix.Tag = 535 + AffectedSecondaryOrderID quickfix.Tag = 536 + AffirmStatus quickfix.Tag = 940 + AggregatedBook quickfix.Tag = 266 + AggressorIndicator quickfix.Tag = 1057 + AgreementCurrency quickfix.Tag = 918 + AgreementDate quickfix.Tag = 915 + AgreementDesc quickfix.Tag = 913 + AgreementID quickfix.Tag = 914 + AllocAccount quickfix.Tag = 79 + AllocAccountType quickfix.Tag = 798 + AllocAccruedInterestAmt quickfix.Tag = 742 + AllocAcctIDSource quickfix.Tag = 661 + AllocAvgPx quickfix.Tag = 153 + AllocCancReplaceReason quickfix.Tag = 796 + AllocClearingFeeIndicator quickfix.Tag = 1136 + AllocCustomerCapacity quickfix.Tag = 993 + AllocHandlInst quickfix.Tag = 209 + AllocID quickfix.Tag = 70 + AllocInterestAtMaturity quickfix.Tag = 741 + AllocIntermedReqType quickfix.Tag = 808 + AllocLinkID quickfix.Tag = 196 + AllocLinkType quickfix.Tag = 197 + AllocMethod quickfix.Tag = 1002 + AllocNetMoney quickfix.Tag = 154 + AllocNoOrdersType quickfix.Tag = 857 + AllocPositionEffect quickfix.Tag = 1047 + AllocPrice quickfix.Tag = 366 + AllocQty quickfix.Tag = 80 + AllocRejCode quickfix.Tag = 88 + AllocReportID quickfix.Tag = 755 + AllocReportRefID quickfix.Tag = 795 + AllocReportType quickfix.Tag = 794 + AllocSettlCurrAmt quickfix.Tag = 737 + AllocSettlCurrency quickfix.Tag = 736 + AllocSettlInstType quickfix.Tag = 780 + AllocShares quickfix.Tag = 80 + AllocStatus quickfix.Tag = 87 + AllocText quickfix.Tag = 161 + AllocTransType quickfix.Tag = 71 + AllocType quickfix.Tag = 626 + AllowableOneSidednessCurr quickfix.Tag = 767 + AllowableOneSidednessPct quickfix.Tag = 765 + AllowableOneSidednessValue quickfix.Tag = 766 + AltMDSourceID quickfix.Tag = 817 + ApplBegSeqNum quickfix.Tag = 1182 + ApplEndSeqNum quickfix.Tag = 1183 + ApplExtID quickfix.Tag = 1156 + ApplID quickfix.Tag = 1180 + ApplLastSeqNum quickfix.Tag = 1350 + ApplNewSeqNum quickfix.Tag = 1399 + ApplQueueAction quickfix.Tag = 815 + ApplQueueDepth quickfix.Tag = 813 + ApplQueueMax quickfix.Tag = 812 + ApplQueueResolution quickfix.Tag = 814 + ApplReportID quickfix.Tag = 1356 + ApplReportType quickfix.Tag = 1426 + ApplReqID quickfix.Tag = 1346 + ApplReqType quickfix.Tag = 1347 + ApplResendFlag quickfix.Tag = 1352 + ApplResponseError quickfix.Tag = 1354 + ApplResponseID quickfix.Tag = 1353 + ApplResponseType quickfix.Tag = 1348 + ApplSeqNum quickfix.Tag = 1181 + ApplTotalMessageCount quickfix.Tag = 1349 + ApplVerID quickfix.Tag = 1128 + AsOfIndicator quickfix.Tag = 1015 + AsgnReqID quickfix.Tag = 831 + AsgnRptID quickfix.Tag = 833 + AssignmentMethod quickfix.Tag = 744 + AssignmentUnit quickfix.Tag = 745 + AttachmentPoint quickfix.Tag = 1457 + AutoAcceptIndicator quickfix.Tag = 754 + AvgParPx quickfix.Tag = 860 + AvgPrxPrecision quickfix.Tag = 74 + AvgPx quickfix.Tag = 6 + AvgPxIndicator quickfix.Tag = 819 + AvgPxPrecision quickfix.Tag = 74 + BasisFeatureDate quickfix.Tag = 259 + BasisFeaturePrice quickfix.Tag = 260 + BasisPxType quickfix.Tag = 419 + BeginSeqNo quickfix.Tag = 7 + BeginString quickfix.Tag = 8 + Benchmark quickfix.Tag = 219 + BenchmarkCurveCurrency quickfix.Tag = 220 + BenchmarkCurveName quickfix.Tag = 221 + BenchmarkCurvePoint quickfix.Tag = 222 + BenchmarkPrice quickfix.Tag = 662 + BenchmarkPriceType quickfix.Tag = 663 + BenchmarkSecurityID quickfix.Tag = 699 + BenchmarkSecurityIDSource quickfix.Tag = 761 + BidDescriptor quickfix.Tag = 400 + BidDescriptorType quickfix.Tag = 399 + BidForwardPoints quickfix.Tag = 189 + BidForwardPoints2 quickfix.Tag = 642 + BidID quickfix.Tag = 390 + BidPx quickfix.Tag = 132 + BidRequestTransType quickfix.Tag = 374 + BidSize quickfix.Tag = 134 + BidSpotRate quickfix.Tag = 188 + BidSwapPoints quickfix.Tag = 1065 + BidTradeType quickfix.Tag = 418 + BidType quickfix.Tag = 394 + BidYield quickfix.Tag = 632 + BodyLength quickfix.Tag = 9 + BookingRefID quickfix.Tag = 466 + BookingType quickfix.Tag = 775 + BookingUnit quickfix.Tag = 590 + BrokerOfCredit quickfix.Tag = 92 + BusinessRejectReason quickfix.Tag = 380 + BusinessRejectRefID quickfix.Tag = 379 + BuyVolume quickfix.Tag = 330 + CFICode quickfix.Tag = 461 + CPProgram quickfix.Tag = 875 + CPRegType quickfix.Tag = 876 + CalculatedCcyLastQty quickfix.Tag = 1056 + CancellationRights quickfix.Tag = 480 + CapPrice quickfix.Tag = 1199 + CardExpDate quickfix.Tag = 490 + CardHolderName quickfix.Tag = 488 + CardIssNo quickfix.Tag = 491 + CardIssNum quickfix.Tag = 491 + CardNumber quickfix.Tag = 489 + CardStartDate quickfix.Tag = 503 + CashDistribAgentAcctName quickfix.Tag = 502 + CashDistribAgentAcctNumber quickfix.Tag = 500 + CashDistribAgentCode quickfix.Tag = 499 + CashDistribAgentName quickfix.Tag = 498 + CashDistribCurr quickfix.Tag = 478 + CashDistribPayRef quickfix.Tag = 501 + CashMargin quickfix.Tag = 544 + CashOrderQty quickfix.Tag = 152 + CashOutstanding quickfix.Tag = 901 + CashSettlAgentAcctName quickfix.Tag = 185 + CashSettlAgentAcctNum quickfix.Tag = 184 + CashSettlAgentCode quickfix.Tag = 183 + CashSettlAgentContactName quickfix.Tag = 186 + CashSettlAgentContactPhone quickfix.Tag = 187 + CashSettlAgentName quickfix.Tag = 182 + CcyAmt quickfix.Tag = 1157 + CheckSum quickfix.Tag = 10 + ClOrdID quickfix.Tag = 11 + ClOrdLinkID quickfix.Tag = 583 + ClearingAccount quickfix.Tag = 440 + ClearingBusinessDate quickfix.Tag = 715 + ClearingFeeIndicator quickfix.Tag = 635 + ClearingFirm quickfix.Tag = 439 + ClearingInstruction quickfix.Tag = 577 + ClientBidID quickfix.Tag = 391 + ClientID quickfix.Tag = 109 + CollAction quickfix.Tag = 944 + CollApplType quickfix.Tag = 1043 + CollAsgnID quickfix.Tag = 902 + CollAsgnReason quickfix.Tag = 895 + CollAsgnRefID quickfix.Tag = 907 + CollAsgnRejectReason quickfix.Tag = 906 + CollAsgnRespType quickfix.Tag = 905 + CollAsgnTransType quickfix.Tag = 903 + CollInquiryID quickfix.Tag = 909 + CollInquiryQualifier quickfix.Tag = 896 + CollInquiryResult quickfix.Tag = 946 + CollInquiryStatus quickfix.Tag = 945 + CollReqID quickfix.Tag = 894 + CollRespID quickfix.Tag = 904 + CollRptID quickfix.Tag = 908 + CollStatus quickfix.Tag = 910 + CommCurrency quickfix.Tag = 479 + CommType quickfix.Tag = 13 + Commission quickfix.Tag = 12 + ComplexEventCondition quickfix.Tag = 1490 + ComplexEventEndDate quickfix.Tag = 1493 + ComplexEventEndTime quickfix.Tag = 1496 + ComplexEventPrice quickfix.Tag = 1486 + ComplexEventPriceBoundaryMethod quickfix.Tag = 1487 + ComplexEventPriceBoundaryPrecision quickfix.Tag = 1488 + ComplexEventPriceTimeType quickfix.Tag = 1489 + ComplexEventStartDate quickfix.Tag = 1492 + ComplexEventStartTime quickfix.Tag = 1495 + ComplexEventType quickfix.Tag = 1484 + ComplexOptPayoutAmount quickfix.Tag = 1485 + ComplianceID quickfix.Tag = 376 + Concession quickfix.Tag = 238 + ConfirmID quickfix.Tag = 664 + ConfirmRefID quickfix.Tag = 772 + ConfirmRejReason quickfix.Tag = 774 + ConfirmReqID quickfix.Tag = 859 + ConfirmStatus quickfix.Tag = 665 + ConfirmTransType quickfix.Tag = 666 + ConfirmType quickfix.Tag = 773 + ContAmtCurr quickfix.Tag = 521 + ContAmtType quickfix.Tag = 519 + ContAmtValue quickfix.Tag = 520 + ContIntRptID quickfix.Tag = 977 + ContextPartyID quickfix.Tag = 1523 + ContextPartyIDSource quickfix.Tag = 1524 + ContextPartyRole quickfix.Tag = 1525 + ContextPartySubID quickfix.Tag = 1527 + ContextPartySubIDType quickfix.Tag = 1528 + ContingencyType quickfix.Tag = 1385 + ContraBroker quickfix.Tag = 375 + ContraLegRefID quickfix.Tag = 655 + ContraTradeQty quickfix.Tag = 437 + ContraTradeTime quickfix.Tag = 438 + ContraTrader quickfix.Tag = 337 + ContractMultiplier quickfix.Tag = 231 + ContractMultiplierUnit quickfix.Tag = 1435 + ContractSettlMonth quickfix.Tag = 667 + ContraryInstructionIndicator quickfix.Tag = 719 + CopyMsgIndicator quickfix.Tag = 797 + CorporateAction quickfix.Tag = 292 + Country quickfix.Tag = 421 + CountryOfIssue quickfix.Tag = 470 + CouponPaymentDate quickfix.Tag = 224 + CouponRate quickfix.Tag = 223 + CoveredOrUncovered quickfix.Tag = 203 + CreditRating quickfix.Tag = 255 + CrossID quickfix.Tag = 548 + CrossPercent quickfix.Tag = 413 + CrossPrioritization quickfix.Tag = 550 + CrossType quickfix.Tag = 549 + CstmApplVerID quickfix.Tag = 1129 + CumQty quickfix.Tag = 14 + Currency quickfix.Tag = 15 + CurrencyRatio quickfix.Tag = 1382 + CustDirectedOrder quickfix.Tag = 1029 + CustOrderCapacity quickfix.Tag = 582 + CustOrderHandlingInst quickfix.Tag = 1031 + CustomerOrFirm quickfix.Tag = 204 + CxlQty quickfix.Tag = 84 + CxlRejReason quickfix.Tag = 102 + CxlRejResponseTo quickfix.Tag = 434 + CxlType quickfix.Tag = 125 + DKReason quickfix.Tag = 127 + DateOfBirth quickfix.Tag = 486 + DatedDate quickfix.Tag = 873 + DayAvgPx quickfix.Tag = 426 + DayBookingInst quickfix.Tag = 589 + DayCumQty quickfix.Tag = 425 + DayOrderQty quickfix.Tag = 424 + DealingCapacity quickfix.Tag = 1048 + DefBidSize quickfix.Tag = 293 + DefOfferSize quickfix.Tag = 294 + DefaultApplExtID quickfix.Tag = 1407 + DefaultApplVerID quickfix.Tag = 1137 + DefaultCstmApplVerID quickfix.Tag = 1408 + DefaultVerIndicator quickfix.Tag = 1410 + DeleteReason quickfix.Tag = 285 + DeliverToCompID quickfix.Tag = 128 + DeliverToLocationID quickfix.Tag = 145 + DeliverToSubID quickfix.Tag = 129 + DeliveryDate quickfix.Tag = 743 + DeliveryForm quickfix.Tag = 668 + DeliveryType quickfix.Tag = 919 + DerivFlexProductEligibilityIndicator quickfix.Tag = 1243 + DerivativeCFICode quickfix.Tag = 1248 + DerivativeCapPrice quickfix.Tag = 1321 + DerivativeContractMultiplier quickfix.Tag = 1266 + DerivativeContractMultiplierUnit quickfix.Tag = 1438 + DerivativeContractSettlMonth quickfix.Tag = 1285 + DerivativeCountryOfIssue quickfix.Tag = 1258 + DerivativeEncodedIssuer quickfix.Tag = 1278 + DerivativeEncodedIssuerLen quickfix.Tag = 1277 + DerivativeEncodedSecurityDesc quickfix.Tag = 1281 + DerivativeEncodedSecurityDescLen quickfix.Tag = 1280 + DerivativeEventDate quickfix.Tag = 1288 + DerivativeEventPx quickfix.Tag = 1290 + DerivativeEventText quickfix.Tag = 1291 + DerivativeEventTime quickfix.Tag = 1289 + DerivativeEventType quickfix.Tag = 1287 + DerivativeExerciseStyle quickfix.Tag = 1299 + DerivativeFloorPrice quickfix.Tag = 1322 + DerivativeFlowScheduleType quickfix.Tag = 1442 + DerivativeFuturesValuationMethod quickfix.Tag = 1319 + DerivativeInstrAttribType quickfix.Tag = 1313 + DerivativeInstrAttribValue quickfix.Tag = 1314 + DerivativeInstrRegistry quickfix.Tag = 1257 + DerivativeInstrmtAssignmentMethod quickfix.Tag = 1255 + DerivativeInstrumentPartyID quickfix.Tag = 1293 + DerivativeInstrumentPartyIDSource quickfix.Tag = 1294 + DerivativeInstrumentPartyRole quickfix.Tag = 1295 + DerivativeInstrumentPartySubID quickfix.Tag = 1297 + DerivativeInstrumentPartySubIDType quickfix.Tag = 1298 + DerivativeIssueDate quickfix.Tag = 1276 + DerivativeIssuer quickfix.Tag = 1275 + DerivativeListMethod quickfix.Tag = 1320 + DerivativeLocaleOfIssue quickfix.Tag = 1260 + DerivativeMaturityDate quickfix.Tag = 1252 + DerivativeMaturityMonthYear quickfix.Tag = 1251 + DerivativeMaturityTime quickfix.Tag = 1253 + DerivativeMinPriceIncrement quickfix.Tag = 1267 + DerivativeMinPriceIncrementAmount quickfix.Tag = 1268 + DerivativeNTPositionLimit quickfix.Tag = 1274 + DerivativeOptAttribute quickfix.Tag = 1265 + DerivativeOptPayAmount quickfix.Tag = 1225 + DerivativePositionLimit quickfix.Tag = 1273 + DerivativePriceQuoteMethod quickfix.Tag = 1318 + DerivativePriceUnitOfMeasure quickfix.Tag = 1315 + DerivativePriceUnitOfMeasureQty quickfix.Tag = 1316 + DerivativeProduct quickfix.Tag = 1246 + DerivativeProductComplex quickfix.Tag = 1228 + DerivativePutOrCall quickfix.Tag = 1323 + DerivativeSecurityAltID quickfix.Tag = 1219 + DerivativeSecurityAltIDSource quickfix.Tag = 1220 + DerivativeSecurityDesc quickfix.Tag = 1279 + DerivativeSecurityExchange quickfix.Tag = 1272 + DerivativeSecurityGroup quickfix.Tag = 1247 + DerivativeSecurityID quickfix.Tag = 1216 + DerivativeSecurityIDSource quickfix.Tag = 1217 + DerivativeSecurityListRequestType quickfix.Tag = 1307 + DerivativeSecurityStatus quickfix.Tag = 1256 + DerivativeSecuritySubType quickfix.Tag = 1250 + DerivativeSecurityType quickfix.Tag = 1249 + DerivativeSecurityXML quickfix.Tag = 1283 + DerivativeSecurityXMLLen quickfix.Tag = 1282 + DerivativeSecurityXMLSchema quickfix.Tag = 1284 + DerivativeSettlMethod quickfix.Tag = 1317 + DerivativeSettleOnOpenFlag quickfix.Tag = 1254 + DerivativeStateOrProvinceOfIssue quickfix.Tag = 1259 + DerivativeStrikeCurrency quickfix.Tag = 1262 + DerivativeStrikeMultiplier quickfix.Tag = 1263 + DerivativeStrikePrice quickfix.Tag = 1261 + DerivativeStrikeValue quickfix.Tag = 1264 + DerivativeSymbol quickfix.Tag = 1214 + DerivativeSymbolSfx quickfix.Tag = 1215 + DerivativeTimeUnit quickfix.Tag = 1271 + DerivativeUnitOfMeasure quickfix.Tag = 1269 + DerivativeUnitOfMeasureQty quickfix.Tag = 1270 + DerivativeValuationMethod quickfix.Tag = 1319 + Designation quickfix.Tag = 494 + DeskID quickfix.Tag = 284 + DeskOrderHandlingInst quickfix.Tag = 1035 + DeskType quickfix.Tag = 1033 + DeskTypeSource quickfix.Tag = 1034 + DetachmentPoint quickfix.Tag = 1458 + DiscretionInst quickfix.Tag = 388 + DiscretionLimitType quickfix.Tag = 843 + DiscretionMoveType quickfix.Tag = 841 + DiscretionOffset quickfix.Tag = 389 + DiscretionOffsetType quickfix.Tag = 842 + DiscretionOffsetValue quickfix.Tag = 389 + DiscretionPrice quickfix.Tag = 845 + DiscretionRoundDirection quickfix.Tag = 844 + DiscretionScope quickfix.Tag = 846 + DisplayHighQty quickfix.Tag = 1086 + DisplayLowQty quickfix.Tag = 1085 + DisplayMethod quickfix.Tag = 1084 + DisplayMinIncr quickfix.Tag = 1087 + DisplayQty quickfix.Tag = 1138 + DisplayWhen quickfix.Tag = 1083 + DistribPaymentMethod quickfix.Tag = 477 + DistribPercentage quickfix.Tag = 512 + DividendYield quickfix.Tag = 1380 + DlvyInst quickfix.Tag = 86 + DlvyInstType quickfix.Tag = 787 + DueToRelated quickfix.Tag = 329 + EFPTrackingError quickfix.Tag = 405 + EffectiveTime quickfix.Tag = 168 + EmailThreadID quickfix.Tag = 164 + EmailType quickfix.Tag = 94 + EncodedAllocText quickfix.Tag = 361 + EncodedAllocTextLen quickfix.Tag = 360 + EncodedHeadline quickfix.Tag = 359 + EncodedHeadlineLen quickfix.Tag = 358 + EncodedIssuer quickfix.Tag = 349 + EncodedIssuerLen quickfix.Tag = 348 + EncodedLegIssuer quickfix.Tag = 619 + EncodedLegIssuerLen quickfix.Tag = 618 + EncodedLegSecurityDesc quickfix.Tag = 622 + EncodedLegSecurityDescLen quickfix.Tag = 621 + EncodedListExecInst quickfix.Tag = 353 + EncodedListExecInstLen quickfix.Tag = 352 + EncodedListStatusText quickfix.Tag = 446 + EncodedListStatusTextLen quickfix.Tag = 445 + EncodedMktSegmDesc quickfix.Tag = 1398 + EncodedMktSegmDescLen quickfix.Tag = 1397 + EncodedSecurityDesc quickfix.Tag = 351 + EncodedSecurityDescLen quickfix.Tag = 350 + EncodedSecurityListDesc quickfix.Tag = 1469 + EncodedSecurityListDescLen quickfix.Tag = 1468 + EncodedSubject quickfix.Tag = 357 + EncodedSubjectLen quickfix.Tag = 356 + EncodedSymbol quickfix.Tag = 1360 + EncodedSymbolLen quickfix.Tag = 1359 + EncodedText quickfix.Tag = 355 + EncodedTextLen quickfix.Tag = 354 + EncodedUnderlyingIssuer quickfix.Tag = 363 + EncodedUnderlyingIssuerLen quickfix.Tag = 362 + EncodedUnderlyingSecurityDesc quickfix.Tag = 365 + EncodedUnderlyingSecurityDescLen quickfix.Tag = 364 + EncryptMethod quickfix.Tag = 98 + EncryptedNewPassword quickfix.Tag = 1404 + EncryptedNewPasswordLen quickfix.Tag = 1403 + EncryptedPassword quickfix.Tag = 1402 + EncryptedPasswordLen quickfix.Tag = 1401 + EncryptedPasswordMethod quickfix.Tag = 1400 + EndAccruedInterestAmt quickfix.Tag = 920 + EndCash quickfix.Tag = 922 + EndDate quickfix.Tag = 917 + EndMaturityMonthYear quickfix.Tag = 1226 + EndSeqNo quickfix.Tag = 16 + EndStrikePxRange quickfix.Tag = 1203 + EndTickPriceRange quickfix.Tag = 1207 + EventDate quickfix.Tag = 866 + EventPx quickfix.Tag = 867 + EventText quickfix.Tag = 868 + EventTime quickfix.Tag = 1145 + EventType quickfix.Tag = 865 + ExDate quickfix.Tag = 230 + ExDestination quickfix.Tag = 100 + ExDestinationIDSource quickfix.Tag = 1133 + ExchangeForPhysical quickfix.Tag = 411 + ExchangeRule quickfix.Tag = 825 + ExchangeSpecialInstructions quickfix.Tag = 1139 + ExecAckStatus quickfix.Tag = 1036 + ExecBroker quickfix.Tag = 76 + ExecID quickfix.Tag = 17 + ExecInst quickfix.Tag = 18 + ExecInstValue quickfix.Tag = 1308 + ExecPriceAdjustment quickfix.Tag = 485 + ExecPriceType quickfix.Tag = 484 + ExecRefID quickfix.Tag = 19 + ExecRestatementReason quickfix.Tag = 378 + ExecTransType quickfix.Tag = 20 + ExecType quickfix.Tag = 150 + ExecValuationPoint quickfix.Tag = 515 + ExerciseMethod quickfix.Tag = 747 + ExerciseStyle quickfix.Tag = 1194 + ExpQty quickfix.Tag = 983 + ExpType quickfix.Tag = 982 + ExpirationCycle quickfix.Tag = 827 + ExpirationQtyType quickfix.Tag = 982 + ExpireDate quickfix.Tag = 432 + ExpireTime quickfix.Tag = 126 + Factor quickfix.Tag = 228 + FairValue quickfix.Tag = 406 + FeeMultiplier quickfix.Tag = 1329 + FillExecID quickfix.Tag = 1363 + FillLiquidityInd quickfix.Tag = 1443 + FillPx quickfix.Tag = 1364 + FillQty quickfix.Tag = 1365 + FinancialStatus quickfix.Tag = 291 + FirmTradeID quickfix.Tag = 1041 + FirstPx quickfix.Tag = 1025 + FlexProductEligibilityIndicator quickfix.Tag = 1242 + FlexibleIndicator quickfix.Tag = 1244 + FloorPrice quickfix.Tag = 1200 + FlowScheduleType quickfix.Tag = 1439 + ForexReq quickfix.Tag = 121 + FundRenewWaiv quickfix.Tag = 497 + FutSettDate quickfix.Tag = 64 + FutSettDate2 quickfix.Tag = 193 + FuturesValuationMethod quickfix.Tag = 1197 + GTBookingInst quickfix.Tag = 427 + GapFillFlag quickfix.Tag = 123 + GrossTradeAmt quickfix.Tag = 381 + HaltReasonChar quickfix.Tag = 327 + HaltReasonInt quickfix.Tag = 327 + HandlInst quickfix.Tag = 21 + Headline quickfix.Tag = 148 + HeartBtInt quickfix.Tag = 108 + HighLimitPrice quickfix.Tag = 1149 + HighPx quickfix.Tag = 332 + HopCompID quickfix.Tag = 628 + HopRefID quickfix.Tag = 630 + HopSendingTime quickfix.Tag = 629 + HostCrossID quickfix.Tag = 961 + IDSource quickfix.Tag = 22 + IOIID quickfix.Tag = 23 + IOINaturalFlag quickfix.Tag = 130 + IOIOthSvc quickfix.Tag = 24 + IOIQltyInd quickfix.Tag = 25 + IOIQty quickfix.Tag = 27 + IOIQualifier quickfix.Tag = 104 + IOIRefID quickfix.Tag = 26 + IOIShares quickfix.Tag = 27 + IOITransType quickfix.Tag = 28 + IOIid quickfix.Tag = 23 + ImpliedMarketIndicator quickfix.Tag = 1144 + InViewOfCommon quickfix.Tag = 328 + IncTaxInd quickfix.Tag = 416 + IndividualAllocID quickfix.Tag = 467 + IndividualAllocRejCode quickfix.Tag = 776 + IndividualAllocType quickfix.Tag = 992 + InputSource quickfix.Tag = 979 + InstrAttribType quickfix.Tag = 871 + InstrAttribValue quickfix.Tag = 872 + InstrRegistry quickfix.Tag = 543 + InstrmtAssignmentMethod quickfix.Tag = 1049 + InstrumentPartyID quickfix.Tag = 1019 + InstrumentPartyIDSource quickfix.Tag = 1050 + InstrumentPartyRole quickfix.Tag = 1051 + InstrumentPartySubID quickfix.Tag = 1053 + InstrumentPartySubIDType quickfix.Tag = 1054 + InterestAccrualDate quickfix.Tag = 874 + InterestAtMaturity quickfix.Tag = 738 + InvestorCountryOfResidence quickfix.Tag = 475 + IssueDate quickfix.Tag = 225 + Issuer quickfix.Tag = 106 + LanguageCode quickfix.Tag = 1474 + LastCapacity quickfix.Tag = 29 + LastForwardPoints quickfix.Tag = 195 + LastForwardPoints2 quickfix.Tag = 641 + LastFragment quickfix.Tag = 893 + LastLiquidityInd quickfix.Tag = 851 + LastMkt quickfix.Tag = 30 + LastMsgSeqNumProcessed quickfix.Tag = 369 + LastNetworkResponseID quickfix.Tag = 934 + LastParPx quickfix.Tag = 669 + LastPx quickfix.Tag = 31 + LastQty quickfix.Tag = 32 + LastRptRequested quickfix.Tag = 912 + LastShares quickfix.Tag = 32 + LastSpotRate quickfix.Tag = 194 + LastSwapPoints quickfix.Tag = 1071 + LastUpdateTime quickfix.Tag = 779 + LateIndicator quickfix.Tag = 978 + LeavesQty quickfix.Tag = 151 + LegAllocAccount quickfix.Tag = 671 + LegAllocAcctIDSource quickfix.Tag = 674 + LegAllocID quickfix.Tag = 1366 + LegAllocQty quickfix.Tag = 673 + LegAllocSettlCurrency quickfix.Tag = 1367 + LegBenchmarkCurveCurrency quickfix.Tag = 676 + LegBenchmarkCurveName quickfix.Tag = 677 + LegBenchmarkCurvePoint quickfix.Tag = 678 + LegBenchmarkPrice quickfix.Tag = 679 + LegBenchmarkPriceType quickfix.Tag = 680 + LegBidForwardPoints quickfix.Tag = 1067 + LegBidPx quickfix.Tag = 681 + LegCFICode quickfix.Tag = 608 + LegCalculatedCcyLastQty quickfix.Tag = 1074 + LegContractMultiplier quickfix.Tag = 614 + LegContractMultiplierUnit quickfix.Tag = 1436 + LegContractSettlMonth quickfix.Tag = 955 + LegCountryOfIssue quickfix.Tag = 596 + LegCouponPaymentDate quickfix.Tag = 248 + LegCouponRate quickfix.Tag = 615 + LegCoveredOrUncovered quickfix.Tag = 565 + LegCreditRating quickfix.Tag = 257 + LegCurrency quickfix.Tag = 556 + LegCurrencyRatio quickfix.Tag = 1383 + LegDatedDate quickfix.Tag = 739 + LegDividendYield quickfix.Tag = 1381 + LegExecInst quickfix.Tag = 1384 + LegExerciseStyle quickfix.Tag = 1420 + LegFactor quickfix.Tag = 253 + LegFlowScheduleType quickfix.Tag = 1440 + LegFutSettDate quickfix.Tag = 588 + LegGrossTradeAmt quickfix.Tag = 1075 + LegIOIQty quickfix.Tag = 682 + LegIndividualAllocID quickfix.Tag = 672 + LegInstrRegistry quickfix.Tag = 599 + LegInterestAccrualDate quickfix.Tag = 956 + LegIssueDate quickfix.Tag = 249 + LegIssuer quickfix.Tag = 617 + LegLastForwardPoints quickfix.Tag = 1073 + LegLastPx quickfix.Tag = 637 + LegLastQty quickfix.Tag = 1418 + LegLocaleOfIssue quickfix.Tag = 598 + LegMaturityDate quickfix.Tag = 611 + LegMaturityMonthYear quickfix.Tag = 610 + LegMaturityTime quickfix.Tag = 1212 + LegNumber quickfix.Tag = 1152 + LegOfferForwardPoints quickfix.Tag = 1068 + LegOfferPx quickfix.Tag = 684 + LegOptAttribute quickfix.Tag = 613 + LegOptionRatio quickfix.Tag = 1017 + LegOrderQty quickfix.Tag = 685 + LegPool quickfix.Tag = 740 + LegPositionEffect quickfix.Tag = 564 + LegPrice quickfix.Tag = 566 + LegPriceType quickfix.Tag = 686 + LegPriceUnitOfMeasure quickfix.Tag = 1421 + LegPriceUnitOfMeasureQty quickfix.Tag = 1422 + LegProduct quickfix.Tag = 607 + LegPutOrCall quickfix.Tag = 1358 + LegQty quickfix.Tag = 687 + LegRatioQty quickfix.Tag = 623 + LegRedemptionDate quickfix.Tag = 254 + LegRefID quickfix.Tag = 654 + LegRepoCollateralSecurityType quickfix.Tag = 250 + LegReportID quickfix.Tag = 990 + LegRepurchaseRate quickfix.Tag = 252 + LegRepurchaseTerm quickfix.Tag = 251 + LegSecurityAltID quickfix.Tag = 605 + LegSecurityAltIDSource quickfix.Tag = 606 + LegSecurityDesc quickfix.Tag = 620 + LegSecurityExchange quickfix.Tag = 616 + LegSecurityID quickfix.Tag = 602 + LegSecurityIDSource quickfix.Tag = 603 + LegSecuritySubType quickfix.Tag = 764 + LegSecurityType quickfix.Tag = 609 + LegSettlCurrency quickfix.Tag = 675 + LegSettlDate quickfix.Tag = 588 + LegSettlType quickfix.Tag = 587 + LegSettlmntTyp quickfix.Tag = 587 + LegSide quickfix.Tag = 624 + LegStateOrProvinceOfIssue quickfix.Tag = 597 + LegStipulationType quickfix.Tag = 688 + LegStipulationValue quickfix.Tag = 689 + LegStrikeCurrency quickfix.Tag = 942 + LegStrikePrice quickfix.Tag = 612 + LegSwapType quickfix.Tag = 690 + LegSymbol quickfix.Tag = 600 + LegSymbolSfx quickfix.Tag = 601 + LegTimeUnit quickfix.Tag = 1001 + LegUnitOfMeasure quickfix.Tag = 999 + LegUnitOfMeasureQty quickfix.Tag = 1224 + LegVolatility quickfix.Tag = 1379 + LegalConfirm quickfix.Tag = 650 + LinesOfText quickfix.Tag = 33 + LiquidityIndType quickfix.Tag = 409 + LiquidityNumSecurities quickfix.Tag = 441 + LiquidityPctHigh quickfix.Tag = 403 + LiquidityPctLow quickfix.Tag = 402 + LiquidityValue quickfix.Tag = 404 + ListExecInst quickfix.Tag = 69 + ListExecInstType quickfix.Tag = 433 + ListID quickfix.Tag = 66 + ListMethod quickfix.Tag = 1198 + ListName quickfix.Tag = 392 + ListNoOrds quickfix.Tag = 68 + ListOrderStatus quickfix.Tag = 431 + ListRejectReason quickfix.Tag = 1386 + ListSeqNo quickfix.Tag = 67 + ListStatusText quickfix.Tag = 444 + ListStatusType quickfix.Tag = 429 + ListUpdateAction quickfix.Tag = 1324 + LocaleOfIssue quickfix.Tag = 472 + LocateReqd quickfix.Tag = 114 + LocationID quickfix.Tag = 283 + LongQty quickfix.Tag = 704 + LotType quickfix.Tag = 1093 + LowLimitPrice quickfix.Tag = 1148 + LowPx quickfix.Tag = 333 + MDBookType quickfix.Tag = 1021 + MDEntryBuyer quickfix.Tag = 288 + MDEntryDate quickfix.Tag = 272 + MDEntryForwardPoints quickfix.Tag = 1027 + MDEntryID quickfix.Tag = 278 + MDEntryOriginator quickfix.Tag = 282 + MDEntryPositionNo quickfix.Tag = 290 + MDEntryPx quickfix.Tag = 270 + MDEntryRefID quickfix.Tag = 280 + MDEntrySeller quickfix.Tag = 289 + MDEntrySize quickfix.Tag = 271 + MDEntrySpotRate quickfix.Tag = 1026 + MDEntryTime quickfix.Tag = 273 + MDEntryType quickfix.Tag = 269 + MDFeedType quickfix.Tag = 1022 + MDImplicitDelete quickfix.Tag = 547 + MDMkt quickfix.Tag = 275 + MDOriginType quickfix.Tag = 1024 + MDPriceLevel quickfix.Tag = 1023 + MDQuoteType quickfix.Tag = 1070 + MDReportID quickfix.Tag = 963 + MDReqID quickfix.Tag = 262 + MDReqRejReason quickfix.Tag = 281 + MDSecSize quickfix.Tag = 1179 + MDSecSizeType quickfix.Tag = 1178 + MDStreamID quickfix.Tag = 1500 + MDSubBookType quickfix.Tag = 1173 + MDUpdateAction quickfix.Tag = 279 + MDUpdateType quickfix.Tag = 265 + MailingDtls quickfix.Tag = 474 + MailingInst quickfix.Tag = 482 + ManualOrderIndicator quickfix.Tag = 1028 + MarginExcess quickfix.Tag = 899 + MarginRatio quickfix.Tag = 898 + MarketDepth quickfix.Tag = 264 + MarketID quickfix.Tag = 1301 + MarketReportID quickfix.Tag = 1394 + MarketReqID quickfix.Tag = 1393 + MarketSegmentDesc quickfix.Tag = 1396 + MarketSegmentID quickfix.Tag = 1300 + MarketUpdateAction quickfix.Tag = 1395 + MassActionRejectReason quickfix.Tag = 1376 + MassActionReportID quickfix.Tag = 1369 + MassActionResponse quickfix.Tag = 1375 + MassActionScope quickfix.Tag = 1374 + MassActionType quickfix.Tag = 1373 + MassCancelRejectReason quickfix.Tag = 532 + MassCancelRequestType quickfix.Tag = 530 + MassCancelResponse quickfix.Tag = 531 + MassStatusReqID quickfix.Tag = 584 + MassStatusReqType quickfix.Tag = 585 + MatchAlgorithm quickfix.Tag = 1142 + MatchIncrement quickfix.Tag = 1089 + MatchStatus quickfix.Tag = 573 + MatchType quickfix.Tag = 574 + MaturityDate quickfix.Tag = 541 + MaturityDay quickfix.Tag = 205 + MaturityMonthYear quickfix.Tag = 200 + MaturityMonthYearFormat quickfix.Tag = 1303 + MaturityMonthYearIncrement quickfix.Tag = 1229 + MaturityMonthYearIncrementUnits quickfix.Tag = 1302 + MaturityNetMoney quickfix.Tag = 890 + MaturityRuleID quickfix.Tag = 1222 + MaturityTime quickfix.Tag = 1079 + MaxFloor quickfix.Tag = 111 + MaxMessageSize quickfix.Tag = 383 + MaxPriceLevels quickfix.Tag = 1090 + MaxPriceVariation quickfix.Tag = 1143 + MaxShow quickfix.Tag = 210 + MaxTradeVol quickfix.Tag = 1140 + MessageEncoding quickfix.Tag = 347 + MessageEventSource quickfix.Tag = 1011 + MidPx quickfix.Tag = 631 + MidYield quickfix.Tag = 633 + MinBidSize quickfix.Tag = 647 + MinLotSize quickfix.Tag = 1231 + MinOfferSize quickfix.Tag = 648 + MinPriceIncrement quickfix.Tag = 969 + MinPriceIncrementAmount quickfix.Tag = 1146 + MinQty quickfix.Tag = 110 + MinTradeVol quickfix.Tag = 562 + MiscFeeAmt quickfix.Tag = 137 + MiscFeeBasis quickfix.Tag = 891 + MiscFeeCurr quickfix.Tag = 138 + MiscFeeType quickfix.Tag = 139 + MktBidPx quickfix.Tag = 645 + MktOfferPx quickfix.Tag = 646 + ModelType quickfix.Tag = 1434 + MoneyLaunderingStatus quickfix.Tag = 481 + MsgDirection quickfix.Tag = 385 + MsgSeqNum quickfix.Tag = 34 + MsgType quickfix.Tag = 35 + MultiLegReportingType quickfix.Tag = 442 + MultiLegRptTypeReq quickfix.Tag = 563 + MultilegModel quickfix.Tag = 1377 + MultilegPriceMethod quickfix.Tag = 1378 + NTPositionLimit quickfix.Tag = 971 + Nested2PartyID quickfix.Tag = 757 + Nested2PartyIDSource quickfix.Tag = 758 + Nested2PartyRole quickfix.Tag = 759 + Nested2PartySubID quickfix.Tag = 760 + Nested2PartySubIDType quickfix.Tag = 807 + Nested3PartyID quickfix.Tag = 949 + Nested3PartyIDSource quickfix.Tag = 950 + Nested3PartyRole quickfix.Tag = 951 + Nested3PartySubID quickfix.Tag = 953 + Nested3PartySubIDType quickfix.Tag = 954 + Nested4PartyID quickfix.Tag = 1415 + Nested4PartyIDSource quickfix.Tag = 1416 + Nested4PartyRole quickfix.Tag = 1417 + Nested4PartySubID quickfix.Tag = 1412 + Nested4PartySubIDType quickfix.Tag = 1411 + NestedInstrAttribType quickfix.Tag = 1210 + NestedInstrAttribValue quickfix.Tag = 1211 + NestedPartyID quickfix.Tag = 524 + NestedPartyIDSource quickfix.Tag = 525 + NestedPartyRole quickfix.Tag = 538 + NestedPartySubID quickfix.Tag = 545 + NestedPartySubIDType quickfix.Tag = 805 + NetChgPrevDay quickfix.Tag = 451 + NetGrossInd quickfix.Tag = 430 + NetMoney quickfix.Tag = 118 + NetworkRequestID quickfix.Tag = 933 + NetworkRequestType quickfix.Tag = 935 + NetworkResponseID quickfix.Tag = 932 + NetworkStatusResponseType quickfix.Tag = 937 + NewPassword quickfix.Tag = 925 + NewSeqNo quickfix.Tag = 36 + NewsCategory quickfix.Tag = 1473 + NewsID quickfix.Tag = 1472 + NewsRefID quickfix.Tag = 1476 + NewsRefType quickfix.Tag = 1477 + NextExpectedMsgSeqNum quickfix.Tag = 789 + NoAffectedOrders quickfix.Tag = 534 + NoAllocs quickfix.Tag = 78 + NoAltMDSource quickfix.Tag = 816 + NoApplIDs quickfix.Tag = 1351 + NoAsgnReqs quickfix.Tag = 1499 + NoBidComponents quickfix.Tag = 420 + NoBidDescriptors quickfix.Tag = 398 + NoCapacities quickfix.Tag = 862 + NoClearingInstructions quickfix.Tag = 576 + NoCollInquiryQualifier quickfix.Tag = 938 + NoCompIDs quickfix.Tag = 936 + NoComplexEventDates quickfix.Tag = 1491 + NoComplexEventTimes quickfix.Tag = 1494 + NoComplexEvents quickfix.Tag = 1483 + NoContAmts quickfix.Tag = 518 + NoContextPartyIDs quickfix.Tag = 1522 + NoContextPartySubIDs quickfix.Tag = 1526 + NoContraBrokers quickfix.Tag = 382 + NoDates quickfix.Tag = 580 + NoDerivativeEvents quickfix.Tag = 1286 + NoDerivativeInstrAttrib quickfix.Tag = 1311 + NoDerivativeInstrumentParties quickfix.Tag = 1292 + NoDerivativeInstrumentPartySubIDs quickfix.Tag = 1296 + NoDerivativeSecurityAltID quickfix.Tag = 1218 + NoDistribInsts quickfix.Tag = 510 + NoDlvyInst quickfix.Tag = 85 + NoEvents quickfix.Tag = 864 + NoExecInstRules quickfix.Tag = 1232 + NoExecs quickfix.Tag = 124 + NoExpiration quickfix.Tag = 981 + NoFills quickfix.Tag = 1362 + NoHops quickfix.Tag = 627 + NoIOIQualifiers quickfix.Tag = 199 + NoInstrAttrib quickfix.Tag = 870 + NoInstrumentParties quickfix.Tag = 1018 + NoInstrumentPartySubIDs quickfix.Tag = 1052 + NoLegAllocs quickfix.Tag = 670 + NoLegSecurityAltID quickfix.Tag = 604 + NoLegStipulations quickfix.Tag = 683 + NoLegs quickfix.Tag = 555 + NoLinesOfText quickfix.Tag = 33 + NoLotTypeRules quickfix.Tag = 1234 + NoMDEntries quickfix.Tag = 268 + NoMDEntryTypes quickfix.Tag = 267 + NoMDFeedTypes quickfix.Tag = 1141 + NoMarketSegments quickfix.Tag = 1310 + NoMatchRules quickfix.Tag = 1235 + NoMaturityRules quickfix.Tag = 1236 + NoMiscFees quickfix.Tag = 136 + NoMsgTypes quickfix.Tag = 384 + NoNested2PartyIDs quickfix.Tag = 756 + NoNested2PartySubIDs quickfix.Tag = 806 + NoNested3PartyIDs quickfix.Tag = 948 + NoNested3PartySubIDs quickfix.Tag = 952 + NoNested4PartyIDs quickfix.Tag = 1414 + NoNested4PartySubIDs quickfix.Tag = 1413 + NoNestedInstrAttrib quickfix.Tag = 1312 + NoNestedPartyIDs quickfix.Tag = 539 + NoNestedPartySubIDs quickfix.Tag = 804 + NoNewsRefIDs quickfix.Tag = 1475 + NoNotAffectedOrders quickfix.Tag = 1370 + NoOfLegUnderlyings quickfix.Tag = 1342 + NoOfSecSizes quickfix.Tag = 1177 + NoOrdTypeRules quickfix.Tag = 1237 + NoOrders quickfix.Tag = 73 + NoPartyAltIDs quickfix.Tag = 1516 + NoPartyAltSubIDs quickfix.Tag = 1519 + NoPartyIDs quickfix.Tag = 453 + NoPartyList quickfix.Tag = 1513 + NoPartyListResponseTypes quickfix.Tag = 1506 + NoPartyRelationships quickfix.Tag = 1514 + NoPartySubIDs quickfix.Tag = 802 + NoPosAmt quickfix.Tag = 753 + NoPositions quickfix.Tag = 702 + NoQuoteEntries quickfix.Tag = 295 + NoQuoteQualifiers quickfix.Tag = 735 + NoQuoteSets quickfix.Tag = 296 + NoRateSources quickfix.Tag = 1445 + NoRegistDtls quickfix.Tag = 473 + NoRelatedContextPartyIDs quickfix.Tag = 1575 + NoRelatedContextPartySubIDs quickfix.Tag = 1579 + NoRelatedPartyAltIDs quickfix.Tag = 1569 + NoRelatedPartyAltSubIDs quickfix.Tag = 1572 + NoRelatedPartyIDs quickfix.Tag = 1562 + NoRelatedPartySubIDs quickfix.Tag = 1566 + NoRelatedSym quickfix.Tag = 146 + NoRelationshipRiskInstruments quickfix.Tag = 1587 + NoRelationshipRiskLimits quickfix.Tag = 1582 + NoRelationshipRiskSecurityAltID quickfix.Tag = 1593 + NoRelationshipRiskWarningLevels quickfix.Tag = 1613 + NoRequestedPartyRoles quickfix.Tag = 1508 + NoRiskInstruments quickfix.Tag = 1534 + NoRiskLimits quickfix.Tag = 1529 + NoRiskSecurityAltID quickfix.Tag = 1540 + NoRiskWarningLevels quickfix.Tag = 1559 + NoRootPartyIDs quickfix.Tag = 1116 + NoRootPartySubIDs quickfix.Tag = 1120 + NoRoutingIDs quickfix.Tag = 215 + NoRpts quickfix.Tag = 82 + NoSecurityAltID quickfix.Tag = 454 + NoSecurityTypes quickfix.Tag = 558 + NoSettlDetails quickfix.Tag = 1158 + NoSettlInst quickfix.Tag = 778 + NoSettlOblig quickfix.Tag = 1165 + NoSettlPartyIDs quickfix.Tag = 781 + NoSettlPartySubIDs quickfix.Tag = 801 + NoSideTrdRegTS quickfix.Tag = 1016 + NoSides quickfix.Tag = 552 + NoStatsIndicators quickfix.Tag = 1175 + NoStipulations quickfix.Tag = 232 + NoStrategyParameters quickfix.Tag = 957 + NoStrikeRules quickfix.Tag = 1201 + NoStrikes quickfix.Tag = 428 + NoTargetPartyIDs quickfix.Tag = 1461 + NoTickRules quickfix.Tag = 1205 + NoTimeInForceRules quickfix.Tag = 1239 + NoTrades quickfix.Tag = 897 + NoTradingSessionRules quickfix.Tag = 1309 + NoTradingSessions quickfix.Tag = 386 + NoTrdRegTimestamps quickfix.Tag = 768 + NoTrdRepIndicators quickfix.Tag = 1387 + NoUnderlyingAmounts quickfix.Tag = 984 + NoUnderlyingLegSecurityAltID quickfix.Tag = 1334 + NoUnderlyingSecurityAltID quickfix.Tag = 457 + NoUnderlyingStips quickfix.Tag = 887 + NoUnderlyings quickfix.Tag = 711 + NoUndlyInstrumentParties quickfix.Tag = 1058 + NoUndlyInstrumentPartySubIDs quickfix.Tag = 1062 + NotAffOrigClOrdID quickfix.Tag = 1372 + NotAffectedOrderID quickfix.Tag = 1371 + NotifyBrokerOfCredit quickfix.Tag = 208 + NotionalPercentageOutstanding quickfix.Tag = 1451 + NumBidders quickfix.Tag = 417 + NumDaysInterest quickfix.Tag = 157 + NumTickets quickfix.Tag = 395 + NumberOfOrders quickfix.Tag = 346 + OddLot quickfix.Tag = 575 + OfferForwardPoints quickfix.Tag = 191 + OfferForwardPoints2 quickfix.Tag = 643 + OfferPx quickfix.Tag = 133 + OfferSize quickfix.Tag = 135 + OfferSpotRate quickfix.Tag = 190 + OfferSwapPoints quickfix.Tag = 1066 + OfferYield quickfix.Tag = 634 + OnBehalfOfCompID quickfix.Tag = 115 + OnBehalfOfLocationID quickfix.Tag = 144 + OnBehalfOfSendingTime quickfix.Tag = 370 + OnBehalfOfSubID quickfix.Tag = 116 + OpenClose quickfix.Tag = 77 + OpenCloseSettlFlag quickfix.Tag = 286 + OpenCloseSettleFlag quickfix.Tag = 286 + OpenInterest quickfix.Tag = 746 + OptAttribute quickfix.Tag = 206 + OptPayAmount quickfix.Tag = 1195 + OptPayoutAmount quickfix.Tag = 1195 + OptPayoutType quickfix.Tag = 1482 + OrdRejReason quickfix.Tag = 103 + OrdStatus quickfix.Tag = 39 + OrdStatusReqID quickfix.Tag = 790 + OrdType quickfix.Tag = 40 + OrderAvgPx quickfix.Tag = 799 + OrderBookingQty quickfix.Tag = 800 + OrderCapacity quickfix.Tag = 528 + OrderCapacityQty quickfix.Tag = 863 + OrderCategory quickfix.Tag = 1115 + OrderDelay quickfix.Tag = 1428 + OrderDelayUnit quickfix.Tag = 1429 + OrderHandlingInstSource quickfix.Tag = 1032 + OrderID quickfix.Tag = 37 + OrderInputDevice quickfix.Tag = 821 + OrderPercent quickfix.Tag = 516 + OrderQty quickfix.Tag = 38 + OrderQty2 quickfix.Tag = 192 + OrderRestrictions quickfix.Tag = 529 + OrigClOrdID quickfix.Tag = 41 + OrigCrossID quickfix.Tag = 551 + OrigCustOrderCapacity quickfix.Tag = 1432 + OrigOrdModTime quickfix.Tag = 586 + OrigPosReqRefID quickfix.Tag = 713 + OrigSecondaryTradeID quickfix.Tag = 1127 + OrigSendingTime quickfix.Tag = 122 + OrigTime quickfix.Tag = 42 + OrigTradeDate quickfix.Tag = 1125 + OrigTradeHandlingInstr quickfix.Tag = 1124 + OrigTradeID quickfix.Tag = 1126 + OriginalNotionalPercentageOutstanding quickfix.Tag = 1452 + OutMainCntryUIndex quickfix.Tag = 412 + OutsideIndexPct quickfix.Tag = 407 + OwnerType quickfix.Tag = 522 + OwnershipType quickfix.Tag = 517 + ParentMktSegmID quickfix.Tag = 1325 + ParticipationRate quickfix.Tag = 849 + PartyAltID quickfix.Tag = 1517 + PartyAltIDSource quickfix.Tag = 1518 + PartyAltSubID quickfix.Tag = 1520 + PartyAltSubIDType quickfix.Tag = 1521 + PartyDetailsListReportID quickfix.Tag = 1510 + PartyDetailsListRequestID quickfix.Tag = 1505 + PartyDetailsRequestResult quickfix.Tag = 1511 + PartyID quickfix.Tag = 448 + PartyIDSource quickfix.Tag = 447 + PartyListResponseType quickfix.Tag = 1507 + PartyRelationship quickfix.Tag = 1515 + PartyRole quickfix.Tag = 452 + PartySubID quickfix.Tag = 523 + PartySubIDType quickfix.Tag = 803 + Password quickfix.Tag = 554 + PaymentDate quickfix.Tag = 504 + PaymentMethod quickfix.Tag = 492 + PaymentRef quickfix.Tag = 476 + PaymentRemitterID quickfix.Tag = 505 + PctAtRisk quickfix.Tag = 869 + PegDifference quickfix.Tag = 211 + PegLimitType quickfix.Tag = 837 + PegMoveType quickfix.Tag = 835 + PegOffsetType quickfix.Tag = 836 + PegOffsetValue quickfix.Tag = 211 + PegPriceType quickfix.Tag = 1094 + PegRoundDirection quickfix.Tag = 838 + PegScope quickfix.Tag = 840 + PegSecurityDesc quickfix.Tag = 1099 + PegSecurityID quickfix.Tag = 1097 + PegSecurityIDSource quickfix.Tag = 1096 + PegSymbol quickfix.Tag = 1098 + PeggedPrice quickfix.Tag = 839 + PeggedRefPrice quickfix.Tag = 1095 + Pool quickfix.Tag = 691 + PosAmt quickfix.Tag = 708 + PosAmtType quickfix.Tag = 707 + PosMaintAction quickfix.Tag = 712 + PosMaintResult quickfix.Tag = 723 + PosMaintRptID quickfix.Tag = 721 + PosMaintRptRefID quickfix.Tag = 714 + PosMaintStatus quickfix.Tag = 722 + PosQtyStatus quickfix.Tag = 706 + PosReqID quickfix.Tag = 710 + PosReqResult quickfix.Tag = 728 + PosReqStatus quickfix.Tag = 729 + PosReqType quickfix.Tag = 724 + PosTransType quickfix.Tag = 709 + PosType quickfix.Tag = 703 + PositionCurrency quickfix.Tag = 1055 + PositionEffect quickfix.Tag = 77 + PositionLimit quickfix.Tag = 970 + PossDupFlag quickfix.Tag = 43 + PossResend quickfix.Tag = 97 + PreTradeAnonymity quickfix.Tag = 1091 + PreallocMethod quickfix.Tag = 591 + PrevClosePx quickfix.Tag = 140 + PreviouslyReported quickfix.Tag = 570 + Price quickfix.Tag = 44 + Price2 quickfix.Tag = 640 + PriceDelta quickfix.Tag = 811 + PriceImprovement quickfix.Tag = 639 + PriceLimitType quickfix.Tag = 1306 + PriceProtectionScope quickfix.Tag = 1092 + PriceQuoteMethod quickfix.Tag = 1196 + PriceType quickfix.Tag = 423 + PriceUnitOfMeasure quickfix.Tag = 1191 + PriceUnitOfMeasureQty quickfix.Tag = 1192 + PriorSettlPrice quickfix.Tag = 734 + PriorSpreadIndicator quickfix.Tag = 720 + PriorityIndicator quickfix.Tag = 638 + PrivateQuote quickfix.Tag = 1171 + ProcessCode quickfix.Tag = 81 + Product quickfix.Tag = 460 + ProductComplex quickfix.Tag = 1227 + ProgPeriodInterval quickfix.Tag = 415 + ProgRptReqs quickfix.Tag = 414 + PublishTrdIndicator quickfix.Tag = 852 + PutOrCall quickfix.Tag = 201 + QtyType quickfix.Tag = 854 + Quantity quickfix.Tag = 53 + QuantityDate quickfix.Tag = 976 + QuantityType quickfix.Tag = 465 + QuoteAckStatus quickfix.Tag = 297 + QuoteCancelType quickfix.Tag = 298 + QuoteCondition quickfix.Tag = 276 + QuoteEntryID quickfix.Tag = 299 + QuoteEntryRejectReason quickfix.Tag = 368 + QuoteEntryStatus quickfix.Tag = 1167 + QuoteID quickfix.Tag = 117 + QuoteMsgID quickfix.Tag = 1166 + QuotePriceType quickfix.Tag = 692 + QuoteQualifier quickfix.Tag = 695 + QuoteRejectReason quickfix.Tag = 300 + QuoteReqID quickfix.Tag = 131 + QuoteRequestRejectReason quickfix.Tag = 658 + QuoteRequestType quickfix.Tag = 303 + QuoteRespID quickfix.Tag = 693 + QuoteRespType quickfix.Tag = 694 + QuoteResponseLevel quickfix.Tag = 301 + QuoteSetID quickfix.Tag = 302 + QuoteSetValidUntilTime quickfix.Tag = 367 + QuoteStatus quickfix.Tag = 297 + QuoteStatusReqID quickfix.Tag = 649 + QuoteType quickfix.Tag = 537 + RFQReqID quickfix.Tag = 644 + RateSource quickfix.Tag = 1446 + RateSourceType quickfix.Tag = 1447 + RatioQty quickfix.Tag = 319 + RawData quickfix.Tag = 96 + RawDataLength quickfix.Tag = 95 + ReceivedDeptID quickfix.Tag = 1030 + RedemptionDate quickfix.Tag = 240 + RefAllocID quickfix.Tag = 72 + RefApplExtID quickfix.Tag = 1406 + RefApplID quickfix.Tag = 1355 + RefApplLastSeqNum quickfix.Tag = 1357 + RefApplReqID quickfix.Tag = 1433 + RefApplVerID quickfix.Tag = 1130 + RefCompID quickfix.Tag = 930 + RefCstmApplVerID quickfix.Tag = 1131 + RefMsgType quickfix.Tag = 372 + RefOrdIDReason quickfix.Tag = 1431 + RefOrderID quickfix.Tag = 1080 + RefOrderIDSource quickfix.Tag = 1081 + RefSeqNum quickfix.Tag = 45 + RefSubID quickfix.Tag = 931 + RefTagID quickfix.Tag = 371 + ReferencePage quickfix.Tag = 1448 + RefreshIndicator quickfix.Tag = 1187 + RefreshQty quickfix.Tag = 1088 + RegistAcctType quickfix.Tag = 493 + RegistDetls quickfix.Tag = 509 + RegistDtls quickfix.Tag = 509 + RegistEmail quickfix.Tag = 511 + RegistID quickfix.Tag = 513 + RegistRefID quickfix.Tag = 508 + RegistRejReasonCode quickfix.Tag = 507 + RegistRejReasonText quickfix.Tag = 496 + RegistStatus quickfix.Tag = 506 + RegistTransType quickfix.Tag = 514 + RejectText quickfix.Tag = 1328 + RelSymTransactTime quickfix.Tag = 1504 + RelatdSym quickfix.Tag = 46 + RelatedContextPartyID quickfix.Tag = 1576 + RelatedContextPartyIDSource quickfix.Tag = 1577 + RelatedContextPartyRole quickfix.Tag = 1578 + RelatedContextPartySubID quickfix.Tag = 1580 + RelatedContextPartySubIDType quickfix.Tag = 1581 + RelatedPartyAltID quickfix.Tag = 1570 + RelatedPartyAltIDSource quickfix.Tag = 1571 + RelatedPartyAltSubID quickfix.Tag = 1573 + RelatedPartyAltSubIDType quickfix.Tag = 1574 + RelatedPartyID quickfix.Tag = 1563 + RelatedPartyIDSource quickfix.Tag = 1564 + RelatedPartyRole quickfix.Tag = 1565 + RelatedPartySubID quickfix.Tag = 1567 + RelatedPartySubIDType quickfix.Tag = 1568 + RelationshipRiskCFICode quickfix.Tag = 1599 + RelationshipRiskCouponRate quickfix.Tag = 1608 + RelationshipRiskEncodedSecurityDesc quickfix.Tag = 1619 + RelationshipRiskEncodedSecurityDescLen quickfix.Tag = 1618 + RelationshipRiskFlexibleIndicator quickfix.Tag = 1607 + RelationshipRiskInstrumentMultiplier quickfix.Tag = 1612 + RelationshipRiskInstrumentOperator quickfix.Tag = 1588 + RelationshipRiskInstrumentSettlType quickfix.Tag = 1611 + RelationshipRiskLimitAmount quickfix.Tag = 1584 + RelationshipRiskLimitCurrency quickfix.Tag = 1585 + RelationshipRiskLimitPlatform quickfix.Tag = 1586 + RelationshipRiskLimitType quickfix.Tag = 1583 + RelationshipRiskMaturityMonthYear quickfix.Tag = 1602 + RelationshipRiskMaturityTime quickfix.Tag = 1603 + RelationshipRiskProduct quickfix.Tag = 1596 + RelationshipRiskProductComplex quickfix.Tag = 1597 + RelationshipRiskPutOrCall quickfix.Tag = 1606 + RelationshipRiskRestructuringType quickfix.Tag = 1604 + RelationshipRiskSecurityAltID quickfix.Tag = 1594 + RelationshipRiskSecurityAltIDSource quickfix.Tag = 1595 + RelationshipRiskSecurityDesc quickfix.Tag = 1610 + RelationshipRiskSecurityExchange quickfix.Tag = 1609 + RelationshipRiskSecurityGroup quickfix.Tag = 1598 + RelationshipRiskSecurityID quickfix.Tag = 1591 + RelationshipRiskSecurityIDSource quickfix.Tag = 1592 + RelationshipRiskSecuritySubType quickfix.Tag = 1601 + RelationshipRiskSecurityType quickfix.Tag = 1600 + RelationshipRiskSeniority quickfix.Tag = 1605 + RelationshipRiskSymbol quickfix.Tag = 1589 + RelationshipRiskSymbolSfx quickfix.Tag = 1590 + RelationshipRiskWarningLevelName quickfix.Tag = 1615 + RelationshipRiskWarningLevelPercent quickfix.Tag = 1614 + RepoCollateralSecurityType quickfix.Tag = 239 + ReportToExch quickfix.Tag = 113 + ReportedPx quickfix.Tag = 861 + ReportedPxDiff quickfix.Tag = 1134 + RepurchaseRate quickfix.Tag = 227 + RepurchaseTerm quickfix.Tag = 226 + RequestedPartyRole quickfix.Tag = 1509 + ResetSeqNumFlag quickfix.Tag = 141 + RespondentType quickfix.Tag = 1172 + ResponseDestination quickfix.Tag = 726 + ResponseTransportType quickfix.Tag = 725 + RestructuringType quickfix.Tag = 1449 + ReversalIndicator quickfix.Tag = 700 + RiskCFICode quickfix.Tag = 1546 + RiskCouponRate quickfix.Tag = 1555 + RiskEncodedSecurityDesc quickfix.Tag = 1621 + RiskEncodedSecurityDescLen quickfix.Tag = 1620 + RiskFlexibleIndicator quickfix.Tag = 1554 + RiskFreeRate quickfix.Tag = 1190 + RiskInstrumentMultiplier quickfix.Tag = 1558 + RiskInstrumentOperator quickfix.Tag = 1535 + RiskInstrumentSettlType quickfix.Tag = 1557 + RiskLimitAmount quickfix.Tag = 1531 + RiskLimitCurrency quickfix.Tag = 1532 + RiskLimitPlatform quickfix.Tag = 1533 + RiskLimitType quickfix.Tag = 1530 + RiskMaturityMonthYear quickfix.Tag = 1549 + RiskMaturityTime quickfix.Tag = 1550 + RiskProduct quickfix.Tag = 1543 + RiskProductComplex quickfix.Tag = 1544 + RiskPutOrCall quickfix.Tag = 1553 + RiskRestructuringType quickfix.Tag = 1551 + RiskSecurityAltID quickfix.Tag = 1541 + RiskSecurityAltIDSource quickfix.Tag = 1542 + RiskSecurityDesc quickfix.Tag = 1556 + RiskSecurityExchange quickfix.Tag = 1616 + RiskSecurityGroup quickfix.Tag = 1545 + RiskSecurityID quickfix.Tag = 1538 + RiskSecurityIDSource quickfix.Tag = 1539 + RiskSecuritySubType quickfix.Tag = 1548 + RiskSecurityType quickfix.Tag = 1547 + RiskSeniority quickfix.Tag = 1552 + RiskSymbol quickfix.Tag = 1536 + RiskSymbolSfx quickfix.Tag = 1537 + RiskWarningLevelName quickfix.Tag = 1561 + RiskWarningLevelPercent quickfix.Tag = 1560 + RndPx quickfix.Tag = 991 + RootPartyID quickfix.Tag = 1117 + RootPartyIDSource quickfix.Tag = 1118 + RootPartyRole quickfix.Tag = 1119 + RootPartySubID quickfix.Tag = 1121 + RootPartySubIDType quickfix.Tag = 1122 + RoundLot quickfix.Tag = 561 + RoundingDirection quickfix.Tag = 468 + RoundingModulus quickfix.Tag = 469 + RoutingID quickfix.Tag = 217 + RoutingType quickfix.Tag = 216 + RptSeq quickfix.Tag = 83 + RptSys quickfix.Tag = 1135 + Rule80A quickfix.Tag = 47 + Scope quickfix.Tag = 546 + SecDefStatus quickfix.Tag = 653 + SecondaryAllocID quickfix.Tag = 793 + SecondaryClOrdID quickfix.Tag = 526 + SecondaryDisplayQty quickfix.Tag = 1082 + SecondaryExecID quickfix.Tag = 527 + SecondaryFirmTradeID quickfix.Tag = 1042 + SecondaryHighLimitPrice quickfix.Tag = 1230 + SecondaryIndividualAllocID quickfix.Tag = 989 + SecondaryLowLimitPrice quickfix.Tag = 1221 + SecondaryOrderID quickfix.Tag = 198 + SecondaryPriceLimitType quickfix.Tag = 1305 + SecondaryTradeID quickfix.Tag = 1040 + SecondaryTradeReportID quickfix.Tag = 818 + SecondaryTradeReportRefID quickfix.Tag = 881 + SecondaryTradingReferencePrice quickfix.Tag = 1240 + SecondaryTrdType quickfix.Tag = 855 + SecureData quickfix.Tag = 91 + SecureDataLen quickfix.Tag = 90 + SecurityAltID quickfix.Tag = 455 + SecurityAltIDSource quickfix.Tag = 456 + SecurityDesc quickfix.Tag = 107 + SecurityExchange quickfix.Tag = 207 + SecurityGroup quickfix.Tag = 1151 + SecurityID quickfix.Tag = 48 + SecurityIDSource quickfix.Tag = 22 + SecurityListDesc quickfix.Tag = 1467 + SecurityListID quickfix.Tag = 1465 + SecurityListRefID quickfix.Tag = 1466 + SecurityListRequestType quickfix.Tag = 559 + SecurityListType quickfix.Tag = 1470 + SecurityListTypeSource quickfix.Tag = 1471 + SecurityReportID quickfix.Tag = 964 + SecurityReqID quickfix.Tag = 320 + SecurityRequestResult quickfix.Tag = 560 + SecurityRequestType quickfix.Tag = 321 + SecurityResponseID quickfix.Tag = 322 + SecurityResponseType quickfix.Tag = 323 + SecuritySettlAgentAcctName quickfix.Tag = 179 + SecuritySettlAgentAcctNum quickfix.Tag = 178 + SecuritySettlAgentCode quickfix.Tag = 177 + SecuritySettlAgentContactName quickfix.Tag = 180 + SecuritySettlAgentContactPhone quickfix.Tag = 181 + SecuritySettlAgentName quickfix.Tag = 176 + SecurityStatus quickfix.Tag = 965 + SecurityStatusReqID quickfix.Tag = 324 + SecuritySubType quickfix.Tag = 762 + SecurityTradingEvent quickfix.Tag = 1174 + SecurityTradingStatus quickfix.Tag = 326 + SecurityType quickfix.Tag = 167 + SecurityUpdateAction quickfix.Tag = 980 + SecurityXML quickfix.Tag = 1185 + SecurityXMLLen quickfix.Tag = 1184 + SecurityXMLSchema quickfix.Tag = 1186 + SellVolume quickfix.Tag = 331 + SellerDays quickfix.Tag = 287 + SenderCompID quickfix.Tag = 49 + SenderLocationID quickfix.Tag = 142 + SenderSubID quickfix.Tag = 50 + SendingDate quickfix.Tag = 51 + SendingTime quickfix.Tag = 52 + Seniority quickfix.Tag = 1450 + SessionRejectReason quickfix.Tag = 373 + SessionStatus quickfix.Tag = 1409 + SettlBrkrCode quickfix.Tag = 174 + SettlCurrAmt quickfix.Tag = 119 + SettlCurrBidFxRate quickfix.Tag = 656 + SettlCurrFxRate quickfix.Tag = 155 + SettlCurrFxRateCalc quickfix.Tag = 156 + SettlCurrOfferFxRate quickfix.Tag = 657 + SettlCurrency quickfix.Tag = 120 + SettlDate quickfix.Tag = 64 + SettlDate2 quickfix.Tag = 193 + SettlDeliveryType quickfix.Tag = 172 + SettlDepositoryCode quickfix.Tag = 173 + SettlInstCode quickfix.Tag = 175 + SettlInstID quickfix.Tag = 162 + SettlInstMode quickfix.Tag = 160 + SettlInstMsgID quickfix.Tag = 777 + SettlInstRefID quickfix.Tag = 214 + SettlInstReqID quickfix.Tag = 791 + SettlInstReqRejCode quickfix.Tag = 792 + SettlInstSource quickfix.Tag = 165 + SettlInstTransType quickfix.Tag = 163 + SettlLocation quickfix.Tag = 166 + SettlMethod quickfix.Tag = 1193 + SettlObligID quickfix.Tag = 1161 + SettlObligMode quickfix.Tag = 1159 + SettlObligMsgID quickfix.Tag = 1160 + SettlObligRefID quickfix.Tag = 1163 + SettlObligSource quickfix.Tag = 1164 + SettlObligTransType quickfix.Tag = 1162 + SettlPartyID quickfix.Tag = 782 + SettlPartyIDSource quickfix.Tag = 783 + SettlPartyRole quickfix.Tag = 784 + SettlPartySubID quickfix.Tag = 785 + SettlPartySubIDType quickfix.Tag = 786 + SettlPrice quickfix.Tag = 730 + SettlPriceType quickfix.Tag = 731 + SettlSessID quickfix.Tag = 716 + SettlSessSubID quickfix.Tag = 717 + SettlType quickfix.Tag = 63 + SettleOnOpenFlag quickfix.Tag = 966 + SettlementCycleNo quickfix.Tag = 1153 + SettlmntTyp quickfix.Tag = 63 + SharedCommission quickfix.Tag = 858 + Shares quickfix.Tag = 53 + ShortQty quickfix.Tag = 705 + ShortSaleReason quickfix.Tag = 853 + Side quickfix.Tag = 54 + SideComplianceID quickfix.Tag = 659 + SideCurrency quickfix.Tag = 1154 + SideExecID quickfix.Tag = 1427 + SideFillStationCd quickfix.Tag = 1006 + SideGrossTradeAmt quickfix.Tag = 1072 + SideLastQty quickfix.Tag = 1009 + SideLiquidityInd quickfix.Tag = 1444 + SideMultiLegReportingType quickfix.Tag = 752 + SideQty quickfix.Tag = 1009 + SideReasonCd quickfix.Tag = 1007 + SideSettlCurrency quickfix.Tag = 1155 + SideTimeInForce quickfix.Tag = 962 + SideTradeReportID quickfix.Tag = 1005 + SideTrdRegTimestamp quickfix.Tag = 1012 + SideTrdRegTimestampSrc quickfix.Tag = 1014 + SideTrdRegTimestampType quickfix.Tag = 1013 + SideTrdSubTyp quickfix.Tag = 1008 + SideValue1 quickfix.Tag = 396 + SideValue2 quickfix.Tag = 397 + SideValueInd quickfix.Tag = 401 + Signature quickfix.Tag = 89 + SignatureLength quickfix.Tag = 93 + SolicitedFlag quickfix.Tag = 377 + Spread quickfix.Tag = 218 + SpreadToBenchmark quickfix.Tag = 218 + StandInstDbID quickfix.Tag = 171 + StandInstDbName quickfix.Tag = 170 + StandInstDbType quickfix.Tag = 169 + StartCash quickfix.Tag = 921 + StartDate quickfix.Tag = 916 + StartMaturityMonthYear quickfix.Tag = 1241 + StartStrikePxRange quickfix.Tag = 1202 + StartTickPriceRange quickfix.Tag = 1206 + StateOrProvinceOfIssue quickfix.Tag = 471 + StatsType quickfix.Tag = 1176 + StatusText quickfix.Tag = 929 + StatusValue quickfix.Tag = 928 + StipulationType quickfix.Tag = 233 + StipulationValue quickfix.Tag = 234 + StopPx quickfix.Tag = 99 + StrategyParameterName quickfix.Tag = 958 + StrategyParameterType quickfix.Tag = 959 + StrategyParameterValue quickfix.Tag = 960 + StreamAsgnAckType quickfix.Tag = 1503 + StreamAsgnRejReason quickfix.Tag = 1502 + StreamAsgnReqID quickfix.Tag = 1497 + StreamAsgnReqType quickfix.Tag = 1498 + StreamAsgnRptID quickfix.Tag = 1501 + StreamAsgnType quickfix.Tag = 1617 + StrikeCurrency quickfix.Tag = 947 + StrikeExerciseStyle quickfix.Tag = 1304 + StrikeIncrement quickfix.Tag = 1204 + StrikeMultiplier quickfix.Tag = 967 + StrikePrice quickfix.Tag = 202 + StrikePriceBoundaryMethod quickfix.Tag = 1479 + StrikePriceBoundaryPrecision quickfix.Tag = 1480 + StrikePriceDeterminationMethod quickfix.Tag = 1478 + StrikeRuleID quickfix.Tag = 1223 + StrikeTime quickfix.Tag = 443 + StrikeValue quickfix.Tag = 968 + Subject quickfix.Tag = 147 + SubscriptionRequestType quickfix.Tag = 263 + SwapPoints quickfix.Tag = 1069 + Symbol quickfix.Tag = 55 + SymbolSfx quickfix.Tag = 65 + TZTransactTime quickfix.Tag = 1132 + TargetCompID quickfix.Tag = 56 + TargetLocationID quickfix.Tag = 143 + TargetPartyID quickfix.Tag = 1462 + TargetPartyIDSource quickfix.Tag = 1463 + TargetPartyRole quickfix.Tag = 1464 + TargetStrategy quickfix.Tag = 847 + TargetStrategyParameters quickfix.Tag = 848 + TargetStrategyPerformance quickfix.Tag = 850 + TargetSubID quickfix.Tag = 57 + TaxAdvantageType quickfix.Tag = 495 + TerminationType quickfix.Tag = 788 + TestMessageIndicator quickfix.Tag = 464 + TestReqID quickfix.Tag = 112 + Text quickfix.Tag = 58 + ThresholdAmount quickfix.Tag = 834 + TickDirection quickfix.Tag = 274 + TickIncrement quickfix.Tag = 1208 + TickRuleType quickfix.Tag = 1209 + TierCode quickfix.Tag = 994 + TimeBracket quickfix.Tag = 943 + TimeInForce quickfix.Tag = 59 + TimeToExpiration quickfix.Tag = 1189 + TimeUnit quickfix.Tag = 997 + TotNoAccQuotes quickfix.Tag = 1169 + TotNoAllocs quickfix.Tag = 892 + TotNoCxldQuotes quickfix.Tag = 1168 + TotNoFills quickfix.Tag = 1361 + TotNoOrders quickfix.Tag = 68 + TotNoPartyList quickfix.Tag = 1512 + TotNoQuoteEntries quickfix.Tag = 304 + TotNoRejQuotes quickfix.Tag = 1170 + TotNoRelatedSym quickfix.Tag = 393 + TotNoSecurityTypes quickfix.Tag = 557 + TotNoStrikes quickfix.Tag = 422 + TotNumAssignmentReports quickfix.Tag = 832 + TotNumReports quickfix.Tag = 911 + TotNumTradeReports quickfix.Tag = 748 + TotQuoteEntries quickfix.Tag = 304 + TotalAccruedInterestAmt quickfix.Tag = 540 + TotalAffectedOrders quickfix.Tag = 533 + TotalNetValue quickfix.Tag = 900 + TotalNumPosReports quickfix.Tag = 727 + TotalNumSecurities quickfix.Tag = 393 + TotalNumSecurityTypes quickfix.Tag = 557 + TotalTakedown quickfix.Tag = 237 + TotalVolumeTraded quickfix.Tag = 387 + TotalVolumeTradedDate quickfix.Tag = 449 + TotalVolumeTradedTime quickfix.Tag = 450 + TradSesCloseTime quickfix.Tag = 344 + TradSesEndTime quickfix.Tag = 345 + TradSesEvent quickfix.Tag = 1368 + TradSesMethod quickfix.Tag = 338 + TradSesMode quickfix.Tag = 339 + TradSesOpenTime quickfix.Tag = 342 + TradSesPreCloseTime quickfix.Tag = 343 + TradSesReqID quickfix.Tag = 335 + TradSesStartTime quickfix.Tag = 341 + TradSesStatus quickfix.Tag = 340 + TradSesStatusRejReason quickfix.Tag = 567 + TradSesUpdateAction quickfix.Tag = 1327 + TradeAllocIndicator quickfix.Tag = 826 + TradeCondition quickfix.Tag = 277 + TradeDate quickfix.Tag = 75 + TradeHandlingInstr quickfix.Tag = 1123 + TradeID quickfix.Tag = 1003 + TradeInputDevice quickfix.Tag = 579 + TradeInputSource quickfix.Tag = 578 + TradeLegRefID quickfix.Tag = 824 + TradeLinkID quickfix.Tag = 820 + TradeOriginationDate quickfix.Tag = 229 + TradePublishIndicator quickfix.Tag = 1390 + TradeReportID quickfix.Tag = 571 + TradeReportRefID quickfix.Tag = 572 + TradeReportRejectReason quickfix.Tag = 751 + TradeReportTransType quickfix.Tag = 487 + TradeReportType quickfix.Tag = 856 + TradeRequestID quickfix.Tag = 568 + TradeRequestResult quickfix.Tag = 749 + TradeRequestStatus quickfix.Tag = 750 + TradeRequestType quickfix.Tag = 569 + TradeType quickfix.Tag = 418 + TradeVolume quickfix.Tag = 1020 + TradedFlatSwitch quickfix.Tag = 258 + TradingCurrency quickfix.Tag = 1245 + TradingReferencePrice quickfix.Tag = 1150 + TradingSessionDesc quickfix.Tag = 1326 + TradingSessionID quickfix.Tag = 336 + TradingSessionSubID quickfix.Tag = 625 + TransBkdTime quickfix.Tag = 483 + TransactTime quickfix.Tag = 60 + TransferReason quickfix.Tag = 830 + TrdMatchID quickfix.Tag = 880 + TrdRegTimestamp quickfix.Tag = 769 + TrdRegTimestampOrigin quickfix.Tag = 771 + TrdRegTimestampType quickfix.Tag = 770 + TrdRepIndicator quickfix.Tag = 1389 + TrdRepPartyRole quickfix.Tag = 1388 + TrdRptStatus quickfix.Tag = 939 + TrdSubType quickfix.Tag = 829 + TrdType quickfix.Tag = 828 + TriggerAction quickfix.Tag = 1101 + TriggerNewPrice quickfix.Tag = 1110 + TriggerNewQty quickfix.Tag = 1112 + TriggerOrderType quickfix.Tag = 1111 + TriggerPrice quickfix.Tag = 1102 + TriggerPriceDirection quickfix.Tag = 1109 + TriggerPriceType quickfix.Tag = 1107 + TriggerPriceTypeScope quickfix.Tag = 1108 + TriggerSecurityDesc quickfix.Tag = 1106 + TriggerSecurityID quickfix.Tag = 1104 + TriggerSecurityIDSource quickfix.Tag = 1105 + TriggerSymbol quickfix.Tag = 1103 + TriggerTradingSessionID quickfix.Tag = 1113 + TriggerTradingSessionSubID quickfix.Tag = 1114 + TriggerType quickfix.Tag = 1100 + URLLink quickfix.Tag = 149 + UnderlyingAdjustedQuantity quickfix.Tag = 1044 + UnderlyingAllocationPercent quickfix.Tag = 972 + UnderlyingAttachmentPoint quickfix.Tag = 1459 + UnderlyingCFICode quickfix.Tag = 463 + UnderlyingCPProgram quickfix.Tag = 877 + UnderlyingCPRegType quickfix.Tag = 878 + UnderlyingCapValue quickfix.Tag = 1038 + UnderlyingCashAmount quickfix.Tag = 973 + UnderlyingCashType quickfix.Tag = 974 + UnderlyingCollectAmount quickfix.Tag = 986 + UnderlyingContractMultiplier quickfix.Tag = 436 + UnderlyingContractMultiplierUnit quickfix.Tag = 1437 + UnderlyingCountryOfIssue quickfix.Tag = 592 + UnderlyingCouponPaymentDate quickfix.Tag = 241 + UnderlyingCouponRate quickfix.Tag = 435 + UnderlyingCreditRating quickfix.Tag = 256 + UnderlyingCurrency quickfix.Tag = 318 + UnderlyingCurrentValue quickfix.Tag = 885 + UnderlyingDeliveryAmount quickfix.Tag = 1037 + UnderlyingDetachmentPoint quickfix.Tag = 1460 + UnderlyingDirtyPrice quickfix.Tag = 882 + UnderlyingEndPrice quickfix.Tag = 883 + UnderlyingEndValue quickfix.Tag = 886 + UnderlyingExerciseStyle quickfix.Tag = 1419 + UnderlyingFXRate quickfix.Tag = 1045 + UnderlyingFXRateCalc quickfix.Tag = 1046 + UnderlyingFactor quickfix.Tag = 246 + UnderlyingFlowScheduleType quickfix.Tag = 1441 + UnderlyingIDSource quickfix.Tag = 305 + UnderlyingInstrRegistry quickfix.Tag = 595 + UnderlyingInstrumentPartyID quickfix.Tag = 1059 + UnderlyingInstrumentPartyIDSource quickfix.Tag = 1060 + UnderlyingInstrumentPartyRole quickfix.Tag = 1061 + UnderlyingInstrumentPartySubID quickfix.Tag = 1063 + UnderlyingInstrumentPartySubIDType quickfix.Tag = 1064 + UnderlyingIssueDate quickfix.Tag = 242 + UnderlyingIssuer quickfix.Tag = 306 + UnderlyingLastPx quickfix.Tag = 651 + UnderlyingLastQty quickfix.Tag = 652 + UnderlyingLegCFICode quickfix.Tag = 1344 + UnderlyingLegMaturityDate quickfix.Tag = 1345 + UnderlyingLegMaturityMonthYear quickfix.Tag = 1339 + UnderlyingLegMaturityTime quickfix.Tag = 1405 + UnderlyingLegOptAttribute quickfix.Tag = 1391 + UnderlyingLegPutOrCall quickfix.Tag = 1343 + UnderlyingLegSecurityAltID quickfix.Tag = 1335 + UnderlyingLegSecurityAltIDSource quickfix.Tag = 1336 + UnderlyingLegSecurityDesc quickfix.Tag = 1392 + UnderlyingLegSecurityExchange quickfix.Tag = 1341 + UnderlyingLegSecurityID quickfix.Tag = 1332 + UnderlyingLegSecurityIDSource quickfix.Tag = 1333 + UnderlyingLegSecuritySubType quickfix.Tag = 1338 + UnderlyingLegSecurityType quickfix.Tag = 1337 + UnderlyingLegStrikePrice quickfix.Tag = 1340 + UnderlyingLegSymbol quickfix.Tag = 1330 + UnderlyingLegSymbolSfx quickfix.Tag = 1331 + UnderlyingLocaleOfIssue quickfix.Tag = 594 + UnderlyingMaturityDate quickfix.Tag = 542 + UnderlyingMaturityDay quickfix.Tag = 314 + UnderlyingMaturityMonthYear quickfix.Tag = 313 + UnderlyingMaturityTime quickfix.Tag = 1213 + UnderlyingNotionalPercentageOutstanding quickfix.Tag = 1455 + UnderlyingOptAttribute quickfix.Tag = 317 + UnderlyingOriginalNotionalPercentageOutstanding quickfix.Tag = 1456 + UnderlyingPayAmount quickfix.Tag = 985 + UnderlyingPriceDeterminationMethod quickfix.Tag = 1481 + UnderlyingPriceUnitOfMeasure quickfix.Tag = 1424 + UnderlyingPriceUnitOfMeasureQty quickfix.Tag = 1425 + UnderlyingProduct quickfix.Tag = 462 + UnderlyingPutOrCall quickfix.Tag = 315 + UnderlyingPx quickfix.Tag = 810 + UnderlyingQty quickfix.Tag = 879 + UnderlyingRedemptionDate quickfix.Tag = 247 + UnderlyingRepoCollateralSecurityType quickfix.Tag = 243 + UnderlyingRepurchaseRate quickfix.Tag = 245 + UnderlyingRepurchaseTerm quickfix.Tag = 244 + UnderlyingRestructuringType quickfix.Tag = 1453 + UnderlyingSecurityAltID quickfix.Tag = 458 + UnderlyingSecurityAltIDSource quickfix.Tag = 459 + UnderlyingSecurityDesc quickfix.Tag = 307 + UnderlyingSecurityExchange quickfix.Tag = 308 + UnderlyingSecurityID quickfix.Tag = 309 + UnderlyingSecurityIDSource quickfix.Tag = 305 + UnderlyingSecuritySubType quickfix.Tag = 763 + UnderlyingSecurityType quickfix.Tag = 310 + UnderlyingSeniority quickfix.Tag = 1454 + UnderlyingSettlMethod quickfix.Tag = 1039 + UnderlyingSettlPrice quickfix.Tag = 732 + UnderlyingSettlPriceType quickfix.Tag = 733 + UnderlyingSettlementDate quickfix.Tag = 987 + UnderlyingSettlementStatus quickfix.Tag = 988 + UnderlyingSettlementType quickfix.Tag = 975 + UnderlyingStartValue quickfix.Tag = 884 + UnderlyingStateOrProvinceOfIssue quickfix.Tag = 593 + UnderlyingStipType quickfix.Tag = 888 + UnderlyingStipValue quickfix.Tag = 889 + UnderlyingStrikeCurrency quickfix.Tag = 941 + UnderlyingStrikePrice quickfix.Tag = 316 + UnderlyingSymbol quickfix.Tag = 311 + UnderlyingSymbolSfx quickfix.Tag = 312 + UnderlyingTimeUnit quickfix.Tag = 1000 + UnderlyingTradingSessionID quickfix.Tag = 822 + UnderlyingTradingSessionSubID quickfix.Tag = 823 + UnderlyingUnitOfMeasure quickfix.Tag = 998 + UnderlyingUnitOfMeasureQty quickfix.Tag = 1423 + UndlyInstrumentPartyID quickfix.Tag = 1059 + UndlyInstrumentPartyIDSource quickfix.Tag = 1060 + UndlyInstrumentPartyRole quickfix.Tag = 1061 + UndlyInstrumentPartySubID quickfix.Tag = 1063 + UndlyInstrumentPartySubIDType quickfix.Tag = 1064 + UnitOfMeasure quickfix.Tag = 996 + UnitOfMeasureQty quickfix.Tag = 1147 + UnsolicitedIndicator quickfix.Tag = 325 + Urgency quickfix.Tag = 61 + UserRequestID quickfix.Tag = 923 + UserRequestType quickfix.Tag = 924 + UserStatus quickfix.Tag = 926 + UserStatusText quickfix.Tag = 927 + Username quickfix.Tag = 553 + ValidUntilTime quickfix.Tag = 62 + ValuationMethod quickfix.Tag = 1197 + ValueOfFutures quickfix.Tag = 408 + VenueType quickfix.Tag = 1430 + Volatility quickfix.Tag = 1188 + WaveNo quickfix.Tag = 105 + WorkingIndicator quickfix.Tag = 636 + WtAverageLiquidity quickfix.Tag = 410 + XmlData quickfix.Tag = 213 + XmlDataLen quickfix.Tag = 212 + Yield quickfix.Tag = 236 + YieldCalcDate quickfix.Tag = 701 + YieldRedemptionDate quickfix.Tag = 696 + YieldRedemptionPrice quickfix.Tag = 697 + YieldRedemptionPriceType quickfix.Tag = 698 + YieldType quickfix.Tag = 235 +) diff --git a/vendor/github.com/quickfixgo/quickfix/tag_value.go b/vendor/github.com/quickfixgo/quickfix/tag_value.go new file mode 100644 index 0000000..3234168 --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/tag_value.go @@ -0,0 +1,69 @@ +package quickfix + +import ( + "bytes" + "fmt" + "strconv" +) + +//TagValue is a low-level FIX field abstraction +type TagValue struct { + tag Tag + value []byte + bytes []byte +} + +//TagValues is a slice of TagValue +type TagValues []TagValue + +func (tv *TagValue) init(tag Tag, value []byte) { + var buf bytes.Buffer + buf.WriteString(strconv.Itoa(int(tag))) + buf.WriteString("=") + buf.Write(value) + buf.WriteString("") + + tv.tag = tag + tv.bytes = buf.Bytes() + tv.value = value +} + +func (tv *TagValue) parse(rawFieldBytes []byte) (err error) { + sepIndex := bytes.IndexByte(rawFieldBytes, '=') + + if sepIndex == -1 { + err = fmt.Errorf("tagValue.Parse: No '=' in '%s'", rawFieldBytes) + return + } + + parsedTag, err := atoi(rawFieldBytes[:sepIndex]) + + if err != nil { + err = fmt.Errorf("tagValue.Parse: %s", err.Error()) + return + } + + tv.tag = Tag(parsedTag) + tv.value = rawFieldBytes[(sepIndex + 1):(len(rawFieldBytes) - 1)] + tv.bytes = rawFieldBytes + + return +} + +func (tv TagValue) String() string { + return string(tv.bytes) +} + +func (tv TagValue) total() int { + total := 0 + + for _, b := range []byte(tv.bytes) { + total += int(b) + } + + return total +} + +func (tv TagValue) length() int { + return len(tv.bytes) +} diff --git a/vendor/github.com/quickfixgo/quickfix/tls.go b/vendor/github.com/quickfixgo/quickfix/tls.go new file mode 100644 index 0000000..7cb830d --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/tls.go @@ -0,0 +1,74 @@ +package quickfix + +import ( + "crypto/tls" + "crypto/x509" + "fmt" + "io/ioutil" + + "github.com/quickfixgo/quickfix/config" +) + +func loadTLSConfig(settings *SessionSettings) (tlsConfig *tls.Config, err error) { + if !settings.HasSetting(config.SocketPrivateKeyFile) && !settings.HasSetting(config.SocketCertificateFile) { + return + } + + privateKeyFile, err := settings.Setting(config.SocketPrivateKeyFile) + if err != nil { + return + } + + certificateFile, err := settings.Setting(config.SocketCertificateFile) + if err != nil { + return + } + + tlsConfig = defaultTLSConfig() + tlsConfig.Certificates = make([]tls.Certificate, 1) + + if tlsConfig.Certificates[0], err = tls.LoadX509KeyPair(certificateFile, privateKeyFile); err != nil { + return + } + + if !settings.HasSetting(config.SocketCAFile) { + return + } + + caFile, err := settings.Setting(config.SocketCAFile) + if err != nil { + return + } + + pem, err := ioutil.ReadFile(caFile) + if err != nil { + return + } + + certPool := x509.NewCertPool() + if !certPool.AppendCertsFromPEM(pem) { + err = fmt.Errorf("Failed to parse %v", caFile) + return + } + + tlsConfig.RootCAs = certPool + tlsConfig.ClientCAs = certPool + tlsConfig.ClientAuth = tls.RequireAndVerifyClientCert + + return +} + +//defaultTLSConfig brought to you by https://github.com/gtank/cryptopasta/ +func defaultTLSConfig() *tls.Config { + return &tls.Config{ + // Avoids most of the memorably-named TLS attacks + MinVersion: tls.VersionTLS12, + // Causes servers to use Go's default ciphersuite preferences, + // which are tuned to avoid attacks. Does nothing on clients. + PreferServerCipherSuites: true, + // Only use curves which have constant-time implementations + CurvePreferences: []tls.CurveID{ + tls.CurveP256, + }, + } +} diff --git a/vendor/github.com/quickfixgo/quickfix/validation.go b/vendor/github.com/quickfixgo/quickfix/validation.go new file mode 100644 index 0000000..5c4013b --- /dev/null +++ b/vendor/github.com/quickfixgo/quickfix/validation.go @@ -0,0 +1,381 @@ +package quickfix + +import ( + "github.com/quickfixgo/quickfix/datadictionary" +) + +type validator interface { + Validate(Message) MessageRejectError +} + +type validatorSettings struct { + CheckFieldsOutOfOrder bool +} + +//Default configuration for message validation. +//See http://www.quickfixengine.org/quickfix/doc/html/configuration.html. +var defaultValidatorSettings = validatorSettings{ + CheckFieldsOutOfOrder: true, +} + +type fixValidator struct { + dataDictionary *datadictionary.DataDictionary + settings validatorSettings +} + +type fixtValidator struct { + transportDataDictionary *datadictionary.DataDictionary + appDataDictionary *datadictionary.DataDictionary + settings validatorSettings +} + +//Validate tests the message against the provided data dictionary. +func (v *fixValidator) Validate(msg Message) MessageRejectError { + if !msg.Header.Has(tagMsgType) { + return RequiredTagMissing(tagMsgType) + } + msgType, err := msg.Header.GetString(tagMsgType) + if err != nil { + return err + } + + return validateFIX(v.dataDictionary, v.settings, msgType, msg) +} + +//Validate tests the message against the provided transport and app data dictionaries. +//If the message is an admin message, it will be validated against the transport data dictionary. +func (v *fixtValidator) Validate(msg Message) MessageRejectError { + if !msg.Header.Has(tagMsgType) { + return RequiredTagMissing(tagMsgType) + } + msgType, err := msg.Header.GetString(tagMsgType) + if err != nil { + return err + } + + if isAdminMessageType(msgType) { + return validateFIX(v.transportDataDictionary, v.settings, msgType, msg) + } + return validateFIXT(v.transportDataDictionary, v.appDataDictionary, v.settings, msgType, msg) +} + +func validateFIX(d *datadictionary.DataDictionary, settings validatorSettings, msgType string, msg Message) MessageRejectError { + if err := validateMsgType(d, msgType, msg); err != nil { + return err + } + + if err := validateRequired(d, d, msgType, msg); err != nil { + return err + } + + if settings.CheckFieldsOutOfOrder { + if err := validateOrder(msg); err != nil { + return err + } + } + + if err := validateFields(d, d, msgType, msg); err != nil { + return err + } + + if err := validateWalk(d, d, msgType, msg); err != nil { + return err + } + + return nil +} + +func validateFIXT(transportDD, appDD *datadictionary.DataDictionary, settings validatorSettings, msgType string, msg Message) MessageRejectError { + if err := validateMsgType(appDD, msgType, msg); err != nil { + return err + } + + if err := validateRequired(transportDD, appDD, msgType, msg); err != nil { + return err + } + + if settings.CheckFieldsOutOfOrder { + if err := validateOrder(msg); err != nil { + return err + } + } + + if err := validateWalk(transportDD, appDD, msgType, msg); err != nil { + return err + } + + if err := validateFields(transportDD, appDD, msgType, msg); err != nil { + return err + } + + return nil +} + +func validateMsgType(d *datadictionary.DataDictionary, msgType string, msg Message) MessageRejectError { + if _, validMsgType := d.Messages[msgType]; validMsgType == false { + return InvalidMessageType() + } + return nil +} + +func validateWalk(transportDD *datadictionary.DataDictionary, appDD *datadictionary.DataDictionary, msgType string, msg Message) MessageRejectError { + remainingFields := msg.fields + iteratedTags := make(datadictionary.TagSet) + + var messageDef *datadictionary.MessageDef + var fieldDef *datadictionary.FieldDef + var err MessageRejectError + var ok bool + + for len(remainingFields) > 0 { + field := remainingFields[0] + tag := field.tag + + switch { + case tag.IsHeader(): + messageDef = transportDD.Header + case tag.IsTrailer(): + messageDef = transportDD.Trailer + default: // is body + messageDef = appDD.Messages[msgType] + } + + if fieldDef, ok = messageDef.Fields[int(tag)]; !ok { + return TagNotDefinedForThisMessageType(tag) + } + + if _, duplicate := iteratedTags[int(tag)]; duplicate { + return tagAppearsMoreThanOnce(tag) + } + iteratedTags.Add(int(tag)) + + if remainingFields, err = validateVisitField(fieldDef, remainingFields); err != nil { + return err + } + } + + if len(remainingFields) != 0 { + return TagNotDefinedForThisMessageType(remainingFields[0].tag) + } + + return nil +} + +func validateVisitField(fieldDef *datadictionary.FieldDef, fields []TagValue) ([]TagValue, MessageRejectError) { + if fieldDef.IsGroup() { + var err MessageRejectError + if fields, err = validateVisitGroupField(fieldDef, fields); err != nil { + return nil, err + } + return fields, nil + } + + return fields[1:], nil +} + +func validateVisitGroupField(fieldDef *datadictionary.FieldDef, fieldStack []TagValue) ([]TagValue, MessageRejectError) { + numInGroupTag := fieldStack[0].tag + var numInGroup FIXInt + + if err := numInGroup.Read(fieldStack[0].value); err != nil { + return nil, IncorrectDataFormatForValue(numInGroupTag) + } + + fieldStack = fieldStack[1:] + + var childDefs []*datadictionary.FieldDef + groupCount := 0 + + for len(fieldStack) > 0 { + + //start of repeating group + if int(fieldStack[0].tag) == fieldDef.Fields[0].Tag() { + childDefs = fieldDef.Fields + groupCount++ + } + + //group complete + if len(childDefs) == 0 { + break + } + + if int(fieldStack[0].tag) == childDefs[0].Tag() { + var err MessageRejectError + if fieldStack, err = validateVisitField(childDefs[0], fieldStack); err != nil { + return fieldStack, err + } + } else { + if childDefs[0].Required() { + return fieldStack, RequiredTagMissing(Tag(childDefs[0].Tag())) + } + } + + childDefs = childDefs[1:] + } + + if groupCount != int(numInGroup) { + return fieldStack, incorrectNumInGroupCountForRepeatingGroup(numInGroupTag) + } + + return fieldStack, nil +} + +func validateOrder(msg Message) MessageRejectError { + inHeader := true + inTrailer := false + for _, field := range msg.fields { + t := field.tag + switch { + case inHeader && t.IsHeader(): + case inHeader && !t.IsHeader(): + inHeader = false + case !inHeader && t.IsHeader(): + return tagSpecifiedOutOfRequiredOrder(t) + case t.IsTrailer(): + inTrailer = true + case inTrailer && !t.IsTrailer(): + return tagSpecifiedOutOfRequiredOrder(t) + } + } + + return nil +} + +func validateRequired(transportDD *datadictionary.DataDictionary, appDD *datadictionary.DataDictionary, msgType string, message Message) MessageRejectError { + if err := validateRequiredFieldMap(message, transportDD.Header.RequiredTags, message.Header.FieldMap); err != nil { + return err + } + + if err := validateRequiredFieldMap(message, appDD.Messages[msgType].RequiredTags, message.Body.FieldMap); err != nil { + return err + } + + if err := validateRequiredFieldMap(message, transportDD.Trailer.RequiredTags, message.Trailer.FieldMap); err != nil { + return err + } + + return nil +} + +func validateRequiredFieldMap(msg Message, requiredTags map[int]struct{}, fieldMap FieldMap) MessageRejectError { + for required := range requiredTags { + requiredTag := Tag(required) + if !fieldMap.Has(requiredTag) { + return RequiredTagMissing(requiredTag) + } + } + + return nil +} + +func validateFields(transportDD *datadictionary.DataDictionary, appDD *datadictionary.DataDictionary, msgType string, message Message) MessageRejectError { + for _, field := range message.fields { + switch { + case field.tag.IsHeader(): + if err := validateField(transportDD, transportDD.Header.Tags, field); err != nil { + return err + } + case field.tag.IsTrailer(): + if err := validateField(transportDD, transportDD.Trailer.Tags, field); err != nil { + return err + } + default: + if err := validateField(appDD, appDD.Messages[msgType].Tags, field); err != nil { + return err + } + } + } + + return nil +} + +func validateField(d *datadictionary.DataDictionary, validFields datadictionary.TagSet, field TagValue) MessageRejectError { + if len(field.value) == 0 { + return TagSpecifiedWithoutAValue(field.tag) + } + + if _, valid := d.FieldTypeByTag[int(field.tag)]; !valid { + return InvalidTagNumber(field.tag) + } + + allowedValues := d.FieldTypeByTag[int(field.tag)].Enums + if len(allowedValues) != 0 { + if _, validValue := allowedValues[string(field.value)]; !validValue { + return ValueIsIncorrect(field.tag) + } + } + + fieldType := d.FieldTypeByTag[int(field.tag)] + var prototype FieldValue + switch fieldType.Type { + case "MULTIPLESTRINGVALUE", "MULTIPLEVALUESTRING": + fallthrough + case "MULTIPLECHARVALUE": + fallthrough + case "CHAR": + fallthrough + case "CURRENCY": + fallthrough + case "DATA": + fallthrough + case "MONTHYEAR": + fallthrough + case "LOCALMKTDATE", "DATE": + fallthrough + case "EXCHANGE": + fallthrough + case "LANGUAGE": + fallthrough + case "XMLDATA": + fallthrough + case "COUNTRY": + fallthrough + case "UTCTIMEONLY": + fallthrough + case "UTCDATEONLY", "UTCDATE": + fallthrough + case "TZTIMEONLY": + fallthrough + case "TZTIMESTAMP": + fallthrough + case "STRING": + prototype = new(FIXString) + + case "BOOLEAN": + prototype = new(FIXBoolean) + + case "LENGTH": + fallthrough + case "DAYOFMONTH": + fallthrough + case "NUMINGROUP": + fallthrough + case "SEQNUM": + fallthrough + case "INT": + prototype = new(FIXInt) + + case "UTCTIMESTAMP", "TIME": + prototype = new(FIXUTCTimestamp) + + case "QTY", "QUANTITY": + fallthrough + case "AMT": + fallthrough + case "PRICE": + fallthrough + case "PRICEOFFSET": + fallthrough + case "PERCENTAGE": + fallthrough + case "FLOAT": + prototype = new(FIXFloat) + + } + + if err := prototype.Read(field.value); err != nil { + return IncorrectDataFormatForValue(field.tag) + } + + return nil +} diff --git a/vendor/vendor.json b/vendor/vendor.json new file mode 100644 index 0000000..e05cd69 --- /dev/null +++ b/vendor/vendor.json @@ -0,0 +1,217 @@ +{ + "comment": "", + "ignore": "test", + "package": [ + { + "checksumSHA1": "c0qwdpGplguBbiS4Jy/LbnhcBlg=", + "path": "github.com/quickfixgo/quickfix", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "GeTAE3gwSUArmfyvtkui8nZhP5Q=", + "path": "github.com/quickfixgo/quickfix/config", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "xI+yIzVkLijTjZSLMj7FYjlYbJ4=", + "path": "github.com/quickfixgo/quickfix/datadictionary", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "7vbog/p6qHM83fj/tf8+t/9BFNc=", + "path": "github.com/quickfixgo/quickfix/enum", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "9KKkoj97S2xI/spW4VG4RPglJLE=", + "path": "github.com/quickfixgo/quickfix/field", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "SccUGK1rp+651wucUvGhsR5OYB8=", + "path": "github.com/quickfixgo/quickfix/fix40", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "HxitcuKGBvFO/vmEiUjCjOfhzSE=", + "path": "github.com/quickfixgo/quickfix/fix40/executionreport", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "pV7xTABxsNRmmz9eX1u1fUdUQBs=", + "path": "github.com/quickfixgo/quickfix/fix40/newordersingle", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "RK/JoFicYzdN8gZobx2KdvjHDfQ=", + "path": "github.com/quickfixgo/quickfix/fix40/ordercancelrequest", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "o5jle4y4miPIERVzfTjIAeHEgqc=", + "path": "github.com/quickfixgo/quickfix/fix41", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "ajbvZVpnRZazu3s29DBw/MWztD4=", + "path": "github.com/quickfixgo/quickfix/fix41/executionreport", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "5yD/BsOPaWaEInN2aAU9BkdFkPg=", + "path": "github.com/quickfixgo/quickfix/fix41/newordersingle", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "O78lDUhbrgL2RhirgAc3lYC3c+c=", + "path": "github.com/quickfixgo/quickfix/fix41/ordercancelrequest", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "BNGNuU9P+LRDe/5h5cd+uFC3llc=", + "path": "github.com/quickfixgo/quickfix/fix42", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "v6WuA4G5R543gbS2rQ/nyeLi6u4=", + "path": "github.com/quickfixgo/quickfix/fix42/executionreport", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "EaDLIp2MGUnwpOCW6QoMXC2nIzE=", + "path": "github.com/quickfixgo/quickfix/fix42/marketdatarequest", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "gMJMPxK7wGtzJCvlS5CTWiwpc64=", + "path": "github.com/quickfixgo/quickfix/fix42/newordersingle", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "iqLILtkc6WEezK+LSyuoPOJymho=", + "path": "github.com/quickfixgo/quickfix/fix42/ordercancelrequest", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "0n6KKUwJe2/cznaGk5CPSCSiXh8=", + "path": "github.com/quickfixgo/quickfix/fix43", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "WEYs/xi0QWgFUc1PTi+wLI2hjBg=", + "path": "github.com/quickfixgo/quickfix/fix43/executionreport", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "BQArMHPpSEKP3vHjQLFceyH3vzo=", + "path": "github.com/quickfixgo/quickfix/fix43/marketdatarequest", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "A7Rm6VMvZ/s0TSjnhZeIwrpKsOw=", + "path": "github.com/quickfixgo/quickfix/fix43/newordersingle", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "UEG2dtqmBP1d2/WfEOZEiGN5g3Q=", + "path": "github.com/quickfixgo/quickfix/fix43/ordercancelrequest", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "+FkPQdqSEp0juWcxlx7jamFWbvk=", + "path": "github.com/quickfixgo/quickfix/fix44", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "P7x6hsARWdn56HuwEsbeI+nJei0=", + "path": "github.com/quickfixgo/quickfix/fix44/executionreport", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "wdYpHKVmOV00iIzxBMiizCDbslc=", + "path": "github.com/quickfixgo/quickfix/fix44/marketdatarequest", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "AZzM0xa7oRz2E2CoPfVN3Vkp3q8=", + "path": "github.com/quickfixgo/quickfix/fix44/newordersingle", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "VmQpWaSQm1pZi2t461ErhWUVF2M=", + "path": "github.com/quickfixgo/quickfix/fix44/ordercancelrequest", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "2jeaKbAAa0l73RIpR92dNeeFEsQ=", + "path": "github.com/quickfixgo/quickfix/fix50/executionreport", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "XjjtU0hgr+TbaiA3s5rtdy6ntog=", + "path": "github.com/quickfixgo/quickfix/fix50/marketdatarequest", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "wXY5Zx4t2P4zTGl9oro+7eMjF0E=", + "path": "github.com/quickfixgo/quickfix/fix50/newordersingle", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "HaqaMyLHcQNbHYb/SPYryNihxQs=", + "path": "github.com/quickfixgo/quickfix/fix50/ordercancelrequest", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "S1ZzSdXOqe//QQUNxPaAksZZzVw=", + "path": "github.com/quickfixgo/quickfix/fixt11", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "CbVW0tgVDeYce/7dU0iSmJQ9JiM=", + "path": "github.com/quickfixgo/quickfix/internal", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + }, + { + "checksumSHA1": "N8Ite5SbLcV2jVE6uiuKuL4rNY4=", + "path": "github.com/quickfixgo/quickfix/tag", + "revision": "666d295eba4d271c4b55acca5e363c97bee42742", + "revisionTime": "2016-08-16T20:57:37Z" + } + ], + "rootPath": "github.com/quickfixgo/examples" +}