forked from quickfixgo/quickfix
-
Notifications
You must be signed in to change notification settings - Fork 1
/
session_settings.go
135 lines (105 loc) · 3.24 KB
/
session_settings.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
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
}