-
Notifications
You must be signed in to change notification settings - Fork 40
/
constants.go
124 lines (102 loc) · 3.39 KB
/
constants.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
package outputs
import "strings"
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See NOTICE.txt in the project root for license information.
type AuthenticationMode string
const (
AuthenticationModeConnectionString AuthenticationMode = "ConnectionString"
AuthenticationModeMsi AuthenticationMode = "Msi"
AuthenticationModeUserToken AuthenticationMode = "UserToken"
)
func PossibleValuesForAuthenticationMode() []string {
return []string{
string(AuthenticationModeConnectionString),
string(AuthenticationModeMsi),
string(AuthenticationModeUserToken),
}
}
func parseAuthenticationMode(input string) (*AuthenticationMode, error) {
vals := map[string]AuthenticationMode{
"connectionstring": AuthenticationModeConnectionString,
"msi": AuthenticationModeMsi,
"usertoken": AuthenticationModeUserToken,
}
if v, ok := vals[strings.ToLower(input)]; ok {
return &v, nil
}
// otherwise presume it's an undefined value and best-effort it
out := AuthenticationMode(input)
return &out, nil
}
type Encoding string
const (
EncodingUTFEight Encoding = "UTF8"
)
func PossibleValuesForEncoding() []string {
return []string{
string(EncodingUTFEight),
}
}
func parseEncoding(input string) (*Encoding, error) {
vals := map[string]Encoding{
"utf8": EncodingUTFEight,
}
if v, ok := vals[strings.ToLower(input)]; ok {
return &v, nil
}
// otherwise presume it's an undefined value and best-effort it
out := Encoding(input)
return &out, nil
}
type EventSerializationType string
const (
EventSerializationTypeAvro EventSerializationType = "Avro"
EventSerializationTypeCsv EventSerializationType = "Csv"
EventSerializationTypeJson EventSerializationType = "Json"
EventSerializationTypeParquet EventSerializationType = "Parquet"
)
func PossibleValuesForEventSerializationType() []string {
return []string{
string(EventSerializationTypeAvro),
string(EventSerializationTypeCsv),
string(EventSerializationTypeJson),
string(EventSerializationTypeParquet),
}
}
func parseEventSerializationType(input string) (*EventSerializationType, error) {
vals := map[string]EventSerializationType{
"avro": EventSerializationTypeAvro,
"csv": EventSerializationTypeCsv,
"json": EventSerializationTypeJson,
"parquet": EventSerializationTypeParquet,
}
if v, ok := vals[strings.ToLower(input)]; ok {
return &v, nil
}
// otherwise presume it's an undefined value and best-effort it
out := EventSerializationType(input)
return &out, nil
}
type JsonOutputSerializationFormat string
const (
JsonOutputSerializationFormatArray JsonOutputSerializationFormat = "Array"
JsonOutputSerializationFormatLineSeparated JsonOutputSerializationFormat = "LineSeparated"
)
func PossibleValuesForJsonOutputSerializationFormat() []string {
return []string{
string(JsonOutputSerializationFormatArray),
string(JsonOutputSerializationFormatLineSeparated),
}
}
func parseJsonOutputSerializationFormat(input string) (*JsonOutputSerializationFormat, error) {
vals := map[string]JsonOutputSerializationFormat{
"array": JsonOutputSerializationFormatArray,
"lineseparated": JsonOutputSerializationFormatLineSeparated,
}
if v, ok := vals[strings.ToLower(input)]; ok {
return &v, nil
}
// otherwise presume it's an undefined value and best-effort it
out := JsonOutputSerializationFormat(input)
return &out, nil
}