id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
14,400 | ardielle/ardielle-go | tbin/common.go | TagName | func TagName(tag int) string {
if (tag & TinyStrTagMask) == TinyStrTag {
return "String"
}
switch tag {
case NullTag:
return "Null"
case BoolTag:
return "Bool"
case Int8Tag:
return "Int8"
case Int16Tag:
return "Int16"
case Int32Tag:
return "Int32"
case Int64Tag:
return "Int64"
case Float32Tag:
return "Float32"
case Float64Tag:
return "Float64"
case BytesTag:
return "Bytes"
case StringTag:
return "String"
case TimestampTag:
return "Timestamp"
case SymbolTag:
return "Symbol"
case UUIDTag:
return "UUID"
case ArrayTag:
return "Array"
case MapTag:
return "Map"
case StructTag:
return "Struct"
case AnyTag:
return "Any"
case EnumTag:
return "Enum"
default:
return fmt.Sprintf("0x%02x", tag)
}
} | go | func TagName(tag int) string {
if (tag & TinyStrTagMask) == TinyStrTag {
return "String"
}
switch tag {
case NullTag:
return "Null"
case BoolTag:
return "Bool"
case Int8Tag:
return "Int8"
case Int16Tag:
return "Int16"
case Int32Tag:
return "Int32"
case Int64Tag:
return "Int64"
case Float32Tag:
return "Float32"
case Float64Tag:
return "Float64"
case BytesTag:
return "Bytes"
case StringTag:
return "String"
case TimestampTag:
return "Timestamp"
case SymbolTag:
return "Symbol"
case UUIDTag:
return "UUID"
case ArrayTag:
return "Array"
case MapTag:
return "Map"
case StructTag:
return "Struct"
case AnyTag:
return "Any"
case EnumTag:
return "Enum"
default:
return fmt.Sprintf("0x%02x", tag)
}
} | [
"func",
"TagName",
"(",
"tag",
"int",
")",
"string",
"{",
"if",
"(",
"tag",
"&",
"TinyStrTagMask",
")",
"==",
"TinyStrTag",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"switch",
"tag",
"{",
"case",
"NullTag",
":",
"return",
"\"",
"\"",
"\n",
"case",
"BoolTag",
":",
"return",
"\"",
"\"",
"\n",
"case",
"Int8Tag",
":",
"return",
"\"",
"\"",
"\n",
"case",
"Int16Tag",
":",
"return",
"\"",
"\"",
"\n",
"case",
"Int32Tag",
":",
"return",
"\"",
"\"",
"\n",
"case",
"Int64Tag",
":",
"return",
"\"",
"\"",
"\n",
"case",
"Float32Tag",
":",
"return",
"\"",
"\"",
"\n",
"case",
"Float64Tag",
":",
"return",
"\"",
"\"",
"\n",
"case",
"BytesTag",
":",
"return",
"\"",
"\"",
"\n",
"case",
"StringTag",
":",
"return",
"\"",
"\"",
"\n",
"case",
"TimestampTag",
":",
"return",
"\"",
"\"",
"\n",
"case",
"SymbolTag",
":",
"return",
"\"",
"\"",
"\n",
"case",
"UUIDTag",
":",
"return",
"\"",
"\"",
"\n",
"case",
"ArrayTag",
":",
"return",
"\"",
"\"",
"\n",
"case",
"MapTag",
":",
"return",
"\"",
"\"",
"\n",
"case",
"StructTag",
":",
"return",
"\"",
"\"",
"\n",
"case",
"AnyTag",
":",
"return",
"\"",
"\"",
"\n",
"case",
"EnumTag",
":",
"return",
"\"",
"\"",
"\n",
"default",
":",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"tag",
")",
"\n",
"}",
"\n",
"}"
] | // TagName returns the tag name for the tag. | [
"TagName",
"returns",
"the",
"tag",
"name",
"for",
"the",
"tag",
"."
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/common.go#L70-L114 |
14,401 | ardielle/ardielle-go | tbin/common.go | String | func (sig *Signature) String() string {
if sig.key == "" {
sig.key = sig.cacheKey()
}
return sig.key
} | go | func (sig *Signature) String() string {
if sig.key == "" {
sig.key = sig.cacheKey()
}
return sig.key
} | [
"func",
"(",
"sig",
"*",
"Signature",
")",
"String",
"(",
")",
"string",
"{",
"if",
"sig",
".",
"key",
"==",
"\"",
"\"",
"{",
"sig",
".",
"key",
"=",
"sig",
".",
"cacheKey",
"(",
")",
"\n",
"}",
"\n",
"return",
"sig",
".",
"key",
"\n",
"}"
] | //
// String produces a compact flat representation of the signature.
// | [
"String",
"produces",
"a",
"compact",
"flat",
"representation",
"of",
"the",
"signature",
"."
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/common.go#L146-L151 |
14,402 | ardielle/ardielle-go | tbin/common.go | EncodeUvarint | func EncodeUvarint(out io.Writer, n int) error {
var buf [16]byte
var err error
i := 0
if (n & 0xffffff80) != 0 {
buf[i] = byte((n | 0x80) & 0xff)
i++
n >>= 7
if (n & 0xffffff80) != 0 {
buf[i] = byte((n | 0x80) & 0xff)
i++
n >>= 7
if (n & 0xffffff80) != 0 {
buf[i] = byte((n | 0x80) & 0xff)
i++
n >>= 7
if (n & 0xffffff80) != 0 {
buf[i] = byte((n | 0x80) & 0xff)
i++
n >>= 7
}
}
}
}
buf[i] = byte(n)
_, err = out.Write(buf[:i+1])
return err
} | go | func EncodeUvarint(out io.Writer, n int) error {
var buf [16]byte
var err error
i := 0
if (n & 0xffffff80) != 0 {
buf[i] = byte((n | 0x80) & 0xff)
i++
n >>= 7
if (n & 0xffffff80) != 0 {
buf[i] = byte((n | 0x80) & 0xff)
i++
n >>= 7
if (n & 0xffffff80) != 0 {
buf[i] = byte((n | 0x80) & 0xff)
i++
n >>= 7
if (n & 0xffffff80) != 0 {
buf[i] = byte((n | 0x80) & 0xff)
i++
n >>= 7
}
}
}
}
buf[i] = byte(n)
_, err = out.Write(buf[:i+1])
return err
} | [
"func",
"EncodeUvarint",
"(",
"out",
"io",
".",
"Writer",
",",
"n",
"int",
")",
"error",
"{",
"var",
"buf",
"[",
"16",
"]",
"byte",
"\n",
"var",
"err",
"error",
"\n",
"i",
":=",
"0",
"\n",
"if",
"(",
"n",
"&",
"0xffffff80",
")",
"!=",
"0",
"{",
"buf",
"[",
"i",
"]",
"=",
"byte",
"(",
"(",
"n",
"|",
"0x80",
")",
"&",
"0xff",
")",
"\n",
"i",
"++",
"\n",
"n",
">>=",
"7",
"\n",
"if",
"(",
"n",
"&",
"0xffffff80",
")",
"!=",
"0",
"{",
"buf",
"[",
"i",
"]",
"=",
"byte",
"(",
"(",
"n",
"|",
"0x80",
")",
"&",
"0xff",
")",
"\n",
"i",
"++",
"\n",
"n",
">>=",
"7",
"\n",
"if",
"(",
"n",
"&",
"0xffffff80",
")",
"!=",
"0",
"{",
"buf",
"[",
"i",
"]",
"=",
"byte",
"(",
"(",
"n",
"|",
"0x80",
")",
"&",
"0xff",
")",
"\n",
"i",
"++",
"\n",
"n",
">>=",
"7",
"\n",
"if",
"(",
"n",
"&",
"0xffffff80",
")",
"!=",
"0",
"{",
"buf",
"[",
"i",
"]",
"=",
"byte",
"(",
"(",
"n",
"|",
"0x80",
")",
"&",
"0xff",
")",
"\n",
"i",
"++",
"\n",
"n",
">>=",
"7",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"buf",
"[",
"i",
"]",
"=",
"byte",
"(",
"n",
")",
"\n",
"_",
",",
"err",
"=",
"out",
".",
"Write",
"(",
"buf",
"[",
":",
"i",
"+",
"1",
"]",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // EncodeUvarint encodes the uvarint to the Writer. | [
"EncodeUvarint",
"encodes",
"the",
"uvarint",
"to",
"the",
"Writer",
"."
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/common.go#L240-L267 |
14,403 | ardielle/ardielle-go | tbin/common.go | EncodeVarint | func EncodeVarint(out io.Writer, n int) error {
return EncodeUvarint(out, (n<<1)^(n>>31))
} | go | func EncodeVarint(out io.Writer, n int) error {
return EncodeUvarint(out, (n<<1)^(n>>31))
} | [
"func",
"EncodeVarint",
"(",
"out",
"io",
".",
"Writer",
",",
"n",
"int",
")",
"error",
"{",
"return",
"EncodeUvarint",
"(",
"out",
",",
"(",
"n",
"<<",
"1",
")",
"^",
"(",
"n",
">>",
"31",
")",
")",
"\n",
"}"
] | // EncodeVarint encodes the varint to the Writer. | [
"EncodeVarint",
"encodes",
"the",
"varint",
"to",
"the",
"Writer",
"."
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/common.go#L270-L272 |
14,404 | ardielle/ardielle-go | tbin/common.go | DecodeUvarint | func DecodeUvarint(in io.Reader) (uint, error) {
var abuf [1]byte
buf := abuf[:]
var n uint
var shift uint
for shift < 32 {
c, err := in.Read(buf)
if c == 1 {
b := buf[0]
n |= (uint(b) & 0x7f) << shift
if (b & 0x80) == 0 {
return n, nil
}
}
if err != nil {
return 0, err
}
shift += 7
}
return 0, fmt.Errorf("Bad varint encoding")
} | go | func DecodeUvarint(in io.Reader) (uint, error) {
var abuf [1]byte
buf := abuf[:]
var n uint
var shift uint
for shift < 32 {
c, err := in.Read(buf)
if c == 1 {
b := buf[0]
n |= (uint(b) & 0x7f) << shift
if (b & 0x80) == 0 {
return n, nil
}
}
if err != nil {
return 0, err
}
shift += 7
}
return 0, fmt.Errorf("Bad varint encoding")
} | [
"func",
"DecodeUvarint",
"(",
"in",
"io",
".",
"Reader",
")",
"(",
"uint",
",",
"error",
")",
"{",
"var",
"abuf",
"[",
"1",
"]",
"byte",
"\n",
"buf",
":=",
"abuf",
"[",
":",
"]",
"\n",
"var",
"n",
"uint",
"\n",
"var",
"shift",
"uint",
"\n",
"for",
"shift",
"<",
"32",
"{",
"c",
",",
"err",
":=",
"in",
".",
"Read",
"(",
"buf",
")",
"\n",
"if",
"c",
"==",
"1",
"{",
"b",
":=",
"buf",
"[",
"0",
"]",
"\n",
"n",
"|=",
"(",
"uint",
"(",
"b",
")",
"&",
"0x7f",
")",
"<<",
"shift",
"\n",
"if",
"(",
"b",
"&",
"0x80",
")",
"==",
"0",
"{",
"return",
"n",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"shift",
"+=",
"7",
"\n",
"}",
"\n",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // DecodeUvarint decodes the uvarint from the Reader. | [
"DecodeUvarint",
"decodes",
"the",
"uvarint",
"from",
"the",
"Reader",
"."
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/common.go#L275-L295 |
14,405 | ardielle/ardielle-go | tbin/common.go | DecodeVarint | func DecodeVarint(in io.Reader) (int, error) {
u, err := DecodeUvarint(in)
n := int(u)
return (n >> 1) ^ -(n & 1), err
} | go | func DecodeVarint(in io.Reader) (int, error) {
u, err := DecodeUvarint(in)
n := int(u)
return (n >> 1) ^ -(n & 1), err
} | [
"func",
"DecodeVarint",
"(",
"in",
"io",
".",
"Reader",
")",
"(",
"int",
",",
"error",
")",
"{",
"u",
",",
"err",
":=",
"DecodeUvarint",
"(",
"in",
")",
"\n",
"n",
":=",
"int",
"(",
"u",
")",
"\n",
"return",
"(",
"n",
">>",
"1",
")",
"^",
"-",
"(",
"n",
"&",
"1",
")",
",",
"err",
"\n",
"}"
] | // DecodeVarint decodes the varint from the Reader. | [
"DecodeVarint",
"decodes",
"the",
"varint",
"from",
"the",
"Reader",
"."
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/common.go#L298-L302 |
14,406 | ardielle/ardielle-go | rdl/schema.go | NewBaseType | func NewBaseType(init ...interface{}) BaseType {
if len(init) == 1 {
switch v := init[0].(type) {
case BaseType:
return v
case int:
return BaseType(v)
case int32:
return BaseType(v)
case string:
for i, s := range namesBaseType {
if s == v {
return BaseType(i)
}
}
default:
panic("Bad init value for BaseType enum")
}
}
return BaseType(0) //default to the first enum value
} | go | func NewBaseType(init ...interface{}) BaseType {
if len(init) == 1 {
switch v := init[0].(type) {
case BaseType:
return v
case int:
return BaseType(v)
case int32:
return BaseType(v)
case string:
for i, s := range namesBaseType {
if s == v {
return BaseType(i)
}
}
default:
panic("Bad init value for BaseType enum")
}
}
return BaseType(0) //default to the first enum value
} | [
"func",
"NewBaseType",
"(",
"init",
"...",
"interface",
"{",
"}",
")",
"BaseType",
"{",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"switch",
"v",
":=",
"init",
"[",
"0",
"]",
".",
"(",
"type",
")",
"{",
"case",
"BaseType",
":",
"return",
"v",
"\n",
"case",
"int",
":",
"return",
"BaseType",
"(",
"v",
")",
"\n",
"case",
"int32",
":",
"return",
"BaseType",
"(",
"v",
")",
"\n",
"case",
"string",
":",
"for",
"i",
",",
"s",
":=",
"range",
"namesBaseType",
"{",
"if",
"s",
"==",
"v",
"{",
"return",
"BaseType",
"(",
"i",
")",
"\n",
"}",
"\n",
"}",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"BaseType",
"(",
"0",
")",
"//default to the first enum value",
"\n",
"}"
] | //
// NewBaseType - return a string representation of the enum
// | [
"NewBaseType",
"-",
"return",
"a",
"string",
"representation",
"of",
"the",
"enum"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L90-L110 |
14,407 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (e *BaseType) UnmarshalJSON(b []byte) error {
var j string
err := json.Unmarshal(b, &j)
if err == nil {
s := string(j)
for v, s2 := range namesBaseType {
if s == s2 {
*e = BaseType(v)
return nil
}
}
err = fmt.Errorf("Bad enum symbol for type BaseType: %s", s)
}
return err
} | go | func (e *BaseType) UnmarshalJSON(b []byte) error {
var j string
err := json.Unmarshal(b, &j)
if err == nil {
s := string(j)
for v, s2 := range namesBaseType {
if s == s2 {
*e = BaseType(v)
return nil
}
}
err = fmt.Errorf("Bad enum symbol for type BaseType: %s", s)
}
return err
} | [
"func",
"(",
"e",
"*",
"BaseType",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"j",
"string",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"j",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"s",
":=",
"string",
"(",
"j",
")",
"\n",
"for",
"v",
",",
"s2",
":=",
"range",
"namesBaseType",
"{",
"if",
"s",
"==",
"s2",
"{",
"*",
"e",
"=",
"BaseType",
"(",
"v",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"s",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a BaseType
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"BaseType"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L136-L150 |
14,408 | ardielle/ardielle-go | rdl/schema.go | NewTypeDef | func NewTypeDef(init ...*TypeDef) *TypeDef {
var o *TypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(TypeDef)
}
return o
} | go | func NewTypeDef(init ...*TypeDef) *TypeDef {
var o *TypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(TypeDef)
}
return o
} | [
"func",
"NewTypeDef",
"(",
"init",
"...",
"*",
"TypeDef",
")",
"*",
"TypeDef",
"{",
"var",
"o",
"*",
"TypeDef",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"TypeDef",
")",
"\n",
"}",
"\n",
"return",
"o",
"\n",
"}"
] | //
// NewTypeDef - creates an initialized TypeDef instance, returns a pointer to it
// | [
"NewTypeDef",
"-",
"creates",
"an",
"initialized",
"TypeDef",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L190-L198 |
14,409 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (self *TypeDef) UnmarshalJSON(b []byte) error {
var m rawTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := TypeDef(m)
*self = o
err = self.Validate()
}
return err
} | go | func (self *TypeDef) UnmarshalJSON(b []byte) error {
var m rawTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := TypeDef(m)
*self = o
err = self.Validate()
}
return err
} | [
"func",
"(",
"self",
"*",
"TypeDef",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"rawTypeDef",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"m",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"TypeDef",
"(",
"m",
")",
"\n",
"*",
"self",
"=",
"o",
"\n",
"err",
"=",
"self",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a TypeDef
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"TypeDef"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L205-L214 |
14,410 | ardielle/ardielle-go | rdl/schema.go | NewAliasTypeDef | func NewAliasTypeDef(init ...*AliasTypeDef) *AliasTypeDef {
var o *AliasTypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(AliasTypeDef)
}
return o
} | go | func NewAliasTypeDef(init ...*AliasTypeDef) *AliasTypeDef {
var o *AliasTypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(AliasTypeDef)
}
return o
} | [
"func",
"NewAliasTypeDef",
"(",
"init",
"...",
"*",
"AliasTypeDef",
")",
"*",
"AliasTypeDef",
"{",
"var",
"o",
"*",
"AliasTypeDef",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"AliasTypeDef",
")",
"\n",
"}",
"\n",
"return",
"o",
"\n",
"}"
] | //
// NewAliasTypeDef - creates an initialized AliasTypeDef instance, returns a pointer to it
// | [
"NewAliasTypeDef",
"-",
"creates",
"an",
"initialized",
"AliasTypeDef",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L270-L278 |
14,411 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (self *AliasTypeDef) UnmarshalJSON(b []byte) error {
var m rawAliasTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := AliasTypeDef(m)
*self = o
err = self.Validate()
}
return err
} | go | func (self *AliasTypeDef) UnmarshalJSON(b []byte) error {
var m rawAliasTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := AliasTypeDef(m)
*self = o
err = self.Validate()
}
return err
} | [
"func",
"(",
"self",
"*",
"AliasTypeDef",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"rawAliasTypeDef",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"m",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"AliasTypeDef",
"(",
"m",
")",
"\n",
"*",
"self",
"=",
"o",
"\n",
"err",
"=",
"self",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a AliasTypeDef
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"AliasTypeDef"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L285-L294 |
14,412 | ardielle/ardielle-go | rdl/schema.go | NewBytesTypeDef | func NewBytesTypeDef(init ...*BytesTypeDef) *BytesTypeDef {
var o *BytesTypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(BytesTypeDef)
}
return o
} | go | func NewBytesTypeDef(init ...*BytesTypeDef) *BytesTypeDef {
var o *BytesTypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(BytesTypeDef)
}
return o
} | [
"func",
"NewBytesTypeDef",
"(",
"init",
"...",
"*",
"BytesTypeDef",
")",
"*",
"BytesTypeDef",
"{",
"var",
"o",
"*",
"BytesTypeDef",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"BytesTypeDef",
")",
"\n",
"}",
"\n",
"return",
"o",
"\n",
"}"
] | //
// NewBytesTypeDef - creates an initialized BytesTypeDef instance, returns a pointer to it
// | [
"NewBytesTypeDef",
"-",
"creates",
"an",
"initialized",
"BytesTypeDef",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L364-L372 |
14,413 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (self *BytesTypeDef) UnmarshalJSON(b []byte) error {
var m rawBytesTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := BytesTypeDef(m)
*self = o
err = self.Validate()
}
return err
} | go | func (self *BytesTypeDef) UnmarshalJSON(b []byte) error {
var m rawBytesTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := BytesTypeDef(m)
*self = o
err = self.Validate()
}
return err
} | [
"func",
"(",
"self",
"*",
"BytesTypeDef",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"rawBytesTypeDef",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"m",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"BytesTypeDef",
"(",
"m",
")",
"\n",
"*",
"self",
"=",
"o",
"\n",
"err",
"=",
"self",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a BytesTypeDef
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"BytesTypeDef"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L379-L388 |
14,414 | ardielle/ardielle-go | rdl/schema.go | NewStringTypeDef | func NewStringTypeDef(init ...*StringTypeDef) *StringTypeDef {
var o *StringTypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(StringTypeDef)
}
return o
} | go | func NewStringTypeDef(init ...*StringTypeDef) *StringTypeDef {
var o *StringTypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(StringTypeDef)
}
return o
} | [
"func",
"NewStringTypeDef",
"(",
"init",
"...",
"*",
"StringTypeDef",
")",
"*",
"StringTypeDef",
"{",
"var",
"o",
"*",
"StringTypeDef",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"StringTypeDef",
")",
"\n",
"}",
"\n",
"return",
"o",
"\n",
"}"
] | //
// NewStringTypeDef - creates an initialized StringTypeDef instance, returns a pointer to it
// | [
"NewStringTypeDef",
"-",
"creates",
"an",
"initialized",
"StringTypeDef",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L464-L472 |
14,415 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (self *StringTypeDef) UnmarshalJSON(b []byte) error {
var m rawStringTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := StringTypeDef(m)
*self = o
err = self.Validate()
}
return err
} | go | func (self *StringTypeDef) UnmarshalJSON(b []byte) error {
var m rawStringTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := StringTypeDef(m)
*self = o
err = self.Validate()
}
return err
} | [
"func",
"(",
"self",
"*",
"StringTypeDef",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"rawStringTypeDef",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"m",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"StringTypeDef",
"(",
"m",
")",
"\n",
"*",
"self",
"=",
"o",
"\n",
"err",
"=",
"self",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a StringTypeDef
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"StringTypeDef"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L479-L488 |
14,416 | ardielle/ardielle-go | rdl/schema.go | Validate | func (p *Number) Validate() error {
if p.Int8 != nil {
p.Variant = NumberVariantInt8
} else if p.Int16 != nil {
p.Variant = NumberVariantInt16
} else if p.Int32 != nil {
p.Variant = NumberVariantInt32
} else if p.Int64 != nil {
p.Variant = NumberVariantInt64
} else if p.Float32 != nil {
p.Variant = NumberVariantFloat32
} else if p.Float64 != nil {
p.Variant = NumberVariantFloat64
} else {
return fmt.Errorf("Number: Missing required variant")
}
return nil
} | go | func (p *Number) Validate() error {
if p.Int8 != nil {
p.Variant = NumberVariantInt8
} else if p.Int16 != nil {
p.Variant = NumberVariantInt16
} else if p.Int32 != nil {
p.Variant = NumberVariantInt32
} else if p.Int64 != nil {
p.Variant = NumberVariantInt64
} else if p.Float32 != nil {
p.Variant = NumberVariantFloat32
} else if p.Float64 != nil {
p.Variant = NumberVariantFloat64
} else {
return fmt.Errorf("Number: Missing required variant")
}
return nil
} | [
"func",
"(",
"p",
"*",
"Number",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"p",
".",
"Int8",
"!=",
"nil",
"{",
"p",
".",
"Variant",
"=",
"NumberVariantInt8",
"\n",
"}",
"else",
"if",
"p",
".",
"Int16",
"!=",
"nil",
"{",
"p",
".",
"Variant",
"=",
"NumberVariantInt16",
"\n",
"}",
"else",
"if",
"p",
".",
"Int32",
"!=",
"nil",
"{",
"p",
".",
"Variant",
"=",
"NumberVariantInt32",
"\n",
"}",
"else",
"if",
"p",
".",
"Int64",
"!=",
"nil",
"{",
"p",
".",
"Variant",
"=",
"NumberVariantInt64",
"\n",
"}",
"else",
"if",
"p",
".",
"Float32",
"!=",
"nil",
"{",
"p",
".",
"Variant",
"=",
"NumberVariantFloat32",
"\n",
"}",
"else",
"if",
"p",
".",
"Float64",
"!=",
"nil",
"{",
"p",
".",
"Variant",
"=",
"NumberVariantFloat64",
"\n",
"}",
"else",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | //
// Validate for Number
// | [
"Validate",
"for",
"Number"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L566-L583 |
14,417 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (p *Number) UnmarshalJSON(b []byte) error {
var tmp rawNumber
if err := json.Unmarshal(b, &tmp); err != nil {
return err
}
*p = Number(tmp)
return p.Validate()
} | go | func (p *Number) UnmarshalJSON(b []byte) error {
var tmp rawNumber
if err := json.Unmarshal(b, &tmp); err != nil {
return err
}
*p = Number(tmp)
return p.Validate()
} | [
"func",
"(",
"p",
"*",
"Number",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"tmp",
"rawNumber",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"tmp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"*",
"p",
"=",
"Number",
"(",
"tmp",
")",
"\n",
"return",
"p",
".",
"Validate",
"(",
")",
"\n",
"}"
] | //
// UnmarshalJSON for Number
// | [
"UnmarshalJSON",
"for",
"Number"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L590-L597 |
14,418 | ardielle/ardielle-go | rdl/schema.go | NewNumberTypeDef | func NewNumberTypeDef(init ...*NumberTypeDef) *NumberTypeDef {
var o *NumberTypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(NumberTypeDef)
}
return o
} | go | func NewNumberTypeDef(init ...*NumberTypeDef) *NumberTypeDef {
var o *NumberTypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(NumberTypeDef)
}
return o
} | [
"func",
"NewNumberTypeDef",
"(",
"init",
"...",
"*",
"NumberTypeDef",
")",
"*",
"NumberTypeDef",
"{",
"var",
"o",
"*",
"NumberTypeDef",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"NumberTypeDef",
")",
"\n",
"}",
"\n",
"return",
"o",
"\n",
"}"
] | //
// NewNumberTypeDef - creates an initialized NumberTypeDef instance, returns a pointer to it
// | [
"NewNumberTypeDef",
"-",
"creates",
"an",
"initialized",
"NumberTypeDef",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L640-L648 |
14,419 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (self *NumberTypeDef) UnmarshalJSON(b []byte) error {
var m rawNumberTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := NumberTypeDef(m)
*self = o
err = self.Validate()
}
return err
} | go | func (self *NumberTypeDef) UnmarshalJSON(b []byte) error {
var m rawNumberTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := NumberTypeDef(m)
*self = o
err = self.Validate()
}
return err
} | [
"func",
"(",
"self",
"*",
"NumberTypeDef",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"rawNumberTypeDef",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"m",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"NumberTypeDef",
"(",
"m",
")",
"\n",
"*",
"self",
"=",
"o",
"\n",
"err",
"=",
"self",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a NumberTypeDef
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"NumberTypeDef"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L655-L664 |
14,420 | ardielle/ardielle-go | rdl/schema.go | NewArrayTypeDef | func NewArrayTypeDef(init ...*ArrayTypeDef) *ArrayTypeDef {
var o *ArrayTypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(ArrayTypeDef)
}
return o.Init()
} | go | func NewArrayTypeDef(init ...*ArrayTypeDef) *ArrayTypeDef {
var o *ArrayTypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(ArrayTypeDef)
}
return o.Init()
} | [
"func",
"NewArrayTypeDef",
"(",
"init",
"...",
"*",
"ArrayTypeDef",
")",
"*",
"ArrayTypeDef",
"{",
"var",
"o",
"*",
"ArrayTypeDef",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"ArrayTypeDef",
")",
"\n",
"}",
"\n",
"return",
"o",
".",
"Init",
"(",
")",
"\n",
"}"
] | //
// NewArrayTypeDef - creates an initialized ArrayTypeDef instance, returns a pointer to it
// | [
"NewArrayTypeDef",
"-",
"creates",
"an",
"initialized",
"ArrayTypeDef",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L739-L747 |
14,421 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (self *ArrayTypeDef) UnmarshalJSON(b []byte) error {
var m rawArrayTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := ArrayTypeDef(m)
*self = *((&o).Init())
err = self.Validate()
}
return err
} | go | func (self *ArrayTypeDef) UnmarshalJSON(b []byte) error {
var m rawArrayTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := ArrayTypeDef(m)
*self = *((&o).Init())
err = self.Validate()
}
return err
} | [
"func",
"(",
"self",
"*",
"ArrayTypeDef",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"rawArrayTypeDef",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"m",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"ArrayTypeDef",
"(",
"m",
")",
"\n",
"*",
"self",
"=",
"*",
"(",
"(",
"&",
"o",
")",
".",
"Init",
"(",
")",
")",
"\n",
"err",
"=",
"self",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a ArrayTypeDef
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"ArrayTypeDef"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L764-L773 |
14,422 | ardielle/ardielle-go | rdl/schema.go | NewMapTypeDef | func NewMapTypeDef(init ...*MapTypeDef) *MapTypeDef {
var o *MapTypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(MapTypeDef)
}
return o.Init()
} | go | func NewMapTypeDef(init ...*MapTypeDef) *MapTypeDef {
var o *MapTypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(MapTypeDef)
}
return o.Init()
} | [
"func",
"NewMapTypeDef",
"(",
"init",
"...",
"*",
"MapTypeDef",
")",
"*",
"MapTypeDef",
"{",
"var",
"o",
"*",
"MapTypeDef",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"MapTypeDef",
")",
"\n",
"}",
"\n",
"return",
"o",
".",
"Init",
"(",
")",
"\n",
"}"
] | //
// NewMapTypeDef - creates an initialized MapTypeDef instance, returns a pointer to it
// | [
"NewMapTypeDef",
"-",
"creates",
"an",
"initialized",
"MapTypeDef",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L861-L869 |
14,423 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (self *MapTypeDef) UnmarshalJSON(b []byte) error {
var m rawMapTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := MapTypeDef(m)
*self = *((&o).Init())
err = self.Validate()
}
return err
} | go | func (self *MapTypeDef) UnmarshalJSON(b []byte) error {
var m rawMapTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := MapTypeDef(m)
*self = *((&o).Init())
err = self.Validate()
}
return err
} | [
"func",
"(",
"self",
"*",
"MapTypeDef",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"rawMapTypeDef",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"m",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"MapTypeDef",
"(",
"m",
")",
"\n",
"*",
"self",
"=",
"*",
"(",
"(",
"&",
"o",
")",
".",
"Init",
"(",
")",
")",
"\n",
"err",
"=",
"self",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a MapTypeDef
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"MapTypeDef"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L889-L898 |
14,424 | ardielle/ardielle-go | rdl/schema.go | NewStructFieldDef | func NewStructFieldDef(init ...*StructFieldDef) *StructFieldDef {
var o *StructFieldDef
if len(init) == 1 {
o = init[0]
} else {
o = new(StructFieldDef)
}
return o
} | go | func NewStructFieldDef(init ...*StructFieldDef) *StructFieldDef {
var o *StructFieldDef
if len(init) == 1 {
o = init[0]
} else {
o = new(StructFieldDef)
}
return o
} | [
"func",
"NewStructFieldDef",
"(",
"init",
"...",
"*",
"StructFieldDef",
")",
"*",
"StructFieldDef",
"{",
"var",
"o",
"*",
"StructFieldDef",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"StructFieldDef",
")",
"\n",
"}",
"\n",
"return",
"o",
"\n",
"}"
] | //
// NewStructFieldDef - creates an initialized StructFieldDef instance, returns a pointer to it
// | [
"NewStructFieldDef",
"-",
"creates",
"an",
"initialized",
"StructFieldDef",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L988-L996 |
14,425 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (self *StructFieldDef) UnmarshalJSON(b []byte) error {
var m rawStructFieldDef
err := json.Unmarshal(b, &m)
if err == nil {
o := StructFieldDef(m)
*self = o
err = self.Validate()
}
return err
} | go | func (self *StructFieldDef) UnmarshalJSON(b []byte) error {
var m rawStructFieldDef
err := json.Unmarshal(b, &m)
if err == nil {
o := StructFieldDef(m)
*self = o
err = self.Validate()
}
return err
} | [
"func",
"(",
"self",
"*",
"StructFieldDef",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"rawStructFieldDef",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"m",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"StructFieldDef",
"(",
"m",
")",
"\n",
"*",
"self",
"=",
"o",
"\n",
"err",
"=",
"self",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a StructFieldDef
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"StructFieldDef"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1003-L1012 |
14,426 | ardielle/ardielle-go | rdl/schema.go | NewStructTypeDef | func NewStructTypeDef(init ...*StructTypeDef) *StructTypeDef {
var o *StructTypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(StructTypeDef)
}
return o.Init()
} | go | func NewStructTypeDef(init ...*StructTypeDef) *StructTypeDef {
var o *StructTypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(StructTypeDef)
}
return o.Init()
} | [
"func",
"NewStructTypeDef",
"(",
"init",
"...",
"*",
"StructTypeDef",
")",
"*",
"StructTypeDef",
"{",
"var",
"o",
"*",
"StructTypeDef",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"StructTypeDef",
")",
"\n",
"}",
"\n",
"return",
"o",
".",
"Init",
"(",
")",
"\n",
"}"
] | //
// NewStructTypeDef - creates an initialized StructTypeDef instance, returns a pointer to it
// | [
"NewStructTypeDef",
"-",
"creates",
"an",
"initialized",
"StructTypeDef",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1081-L1089 |
14,427 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (self *StructTypeDef) UnmarshalJSON(b []byte) error {
var m rawStructTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := StructTypeDef(m)
*self = *((&o).Init())
err = self.Validate()
}
return err
} | go | func (self *StructTypeDef) UnmarshalJSON(b []byte) error {
var m rawStructTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := StructTypeDef(m)
*self = *((&o).Init())
err = self.Validate()
}
return err
} | [
"func",
"(",
"self",
"*",
"StructTypeDef",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"rawStructTypeDef",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"m",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"StructTypeDef",
"(",
"m",
")",
"\n",
"*",
"self",
"=",
"*",
"(",
"(",
"&",
"o",
")",
".",
"Init",
"(",
")",
")",
"\n",
"err",
"=",
"self",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a StructTypeDef
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"StructTypeDef"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1106-L1115 |
14,428 | ardielle/ardielle-go | rdl/schema.go | NewEnumElementDef | func NewEnumElementDef(init ...*EnumElementDef) *EnumElementDef {
var o *EnumElementDef
if len(init) == 1 {
o = init[0]
} else {
o = new(EnumElementDef)
}
return o
} | go | func NewEnumElementDef(init ...*EnumElementDef) *EnumElementDef {
var o *EnumElementDef
if len(init) == 1 {
o = init[0]
} else {
o = new(EnumElementDef)
}
return o
} | [
"func",
"NewEnumElementDef",
"(",
"init",
"...",
"*",
"EnumElementDef",
")",
"*",
"EnumElementDef",
"{",
"var",
"o",
"*",
"EnumElementDef",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"EnumElementDef",
")",
"\n",
"}",
"\n",
"return",
"o",
"\n",
"}"
] | //
// NewEnumElementDef - creates an initialized EnumElementDef instance, returns a pointer to it
// | [
"NewEnumElementDef",
"-",
"creates",
"an",
"initialized",
"EnumElementDef",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1167-L1175 |
14,429 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (self *EnumElementDef) UnmarshalJSON(b []byte) error {
var m rawEnumElementDef
err := json.Unmarshal(b, &m)
if err == nil {
o := EnumElementDef(m)
*self = o
err = self.Validate()
}
return err
} | go | func (self *EnumElementDef) UnmarshalJSON(b []byte) error {
var m rawEnumElementDef
err := json.Unmarshal(b, &m)
if err == nil {
o := EnumElementDef(m)
*self = o
err = self.Validate()
}
return err
} | [
"func",
"(",
"self",
"*",
"EnumElementDef",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"rawEnumElementDef",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"m",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"EnumElementDef",
"(",
"m",
")",
"\n",
"*",
"self",
"=",
"o",
"\n",
"err",
"=",
"self",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a EnumElementDef
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"EnumElementDef"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1182-L1191 |
14,430 | ardielle/ardielle-go | rdl/schema.go | NewEnumTypeDef | func NewEnumTypeDef(init ...*EnumTypeDef) *EnumTypeDef {
var o *EnumTypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(EnumTypeDef)
}
return o.Init()
} | go | func NewEnumTypeDef(init ...*EnumTypeDef) *EnumTypeDef {
var o *EnumTypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(EnumTypeDef)
}
return o.Init()
} | [
"func",
"NewEnumTypeDef",
"(",
"init",
"...",
"*",
"EnumTypeDef",
")",
"*",
"EnumTypeDef",
"{",
"var",
"o",
"*",
"EnumTypeDef",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"EnumTypeDef",
")",
"\n",
"}",
"\n",
"return",
"o",
".",
"Init",
"(",
")",
"\n",
"}"
] | //
// NewEnumTypeDef - creates an initialized EnumTypeDef instance, returns a pointer to it
// | [
"NewEnumTypeDef",
"-",
"creates",
"an",
"initialized",
"EnumTypeDef",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1244-L1252 |
14,431 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (self *EnumTypeDef) UnmarshalJSON(b []byte) error {
var m rawEnumTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := EnumTypeDef(m)
*self = *((&o).Init())
err = self.Validate()
}
return err
} | go | func (self *EnumTypeDef) UnmarshalJSON(b []byte) error {
var m rawEnumTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := EnumTypeDef(m)
*self = *((&o).Init())
err = self.Validate()
}
return err
} | [
"func",
"(",
"self",
"*",
"EnumTypeDef",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"rawEnumTypeDef",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"m",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"EnumTypeDef",
"(",
"m",
")",
"\n",
"*",
"self",
"=",
"*",
"(",
"(",
"&",
"o",
")",
".",
"Init",
"(",
")",
")",
"\n",
"err",
"=",
"self",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a EnumTypeDef
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"EnumTypeDef"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1269-L1278 |
14,432 | ardielle/ardielle-go | rdl/schema.go | NewUnionTypeDef | func NewUnionTypeDef(init ...*UnionTypeDef) *UnionTypeDef {
var o *UnionTypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(UnionTypeDef)
}
return o.Init()
} | go | func NewUnionTypeDef(init ...*UnionTypeDef) *UnionTypeDef {
var o *UnionTypeDef
if len(init) == 1 {
o = init[0]
} else {
o = new(UnionTypeDef)
}
return o.Init()
} | [
"func",
"NewUnionTypeDef",
"(",
"init",
"...",
"*",
"UnionTypeDef",
")",
"*",
"UnionTypeDef",
"{",
"var",
"o",
"*",
"UnionTypeDef",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"UnionTypeDef",
")",
"\n",
"}",
"\n",
"return",
"o",
".",
"Init",
"(",
")",
"\n",
"}"
] | //
// NewUnionTypeDef - creates an initialized UnionTypeDef instance, returns a pointer to it
// | [
"NewUnionTypeDef",
"-",
"creates",
"an",
"initialized",
"UnionTypeDef",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1342-L1350 |
14,433 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (self *UnionTypeDef) UnmarshalJSON(b []byte) error {
var m rawUnionTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := UnionTypeDef(m)
*self = *((&o).Init())
err = self.Validate()
}
return err
} | go | func (self *UnionTypeDef) UnmarshalJSON(b []byte) error {
var m rawUnionTypeDef
err := json.Unmarshal(b, &m)
if err == nil {
o := UnionTypeDef(m)
*self = *((&o).Init())
err = self.Validate()
}
return err
} | [
"func",
"(",
"self",
"*",
"UnionTypeDef",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"rawUnionTypeDef",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"m",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"UnionTypeDef",
"(",
"m",
")",
"\n",
"*",
"self",
"=",
"*",
"(",
"(",
"&",
"o",
")",
".",
"Init",
"(",
")",
")",
"\n",
"err",
"=",
"self",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a UnionTypeDef
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"UnionTypeDef"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1367-L1376 |
14,434 | ardielle/ardielle-go | rdl/schema.go | Validate | func (p *Type) Validate() error {
if p.BaseType != nil {
p.Variant = TypeVariantBaseType
} else if p.StructTypeDef != nil {
p.Variant = TypeVariantStructTypeDef
} else if p.MapTypeDef != nil {
p.Variant = TypeVariantMapTypeDef
} else if p.ArrayTypeDef != nil {
p.Variant = TypeVariantArrayTypeDef
} else if p.EnumTypeDef != nil {
p.Variant = TypeVariantEnumTypeDef
} else if p.UnionTypeDef != nil {
p.Variant = TypeVariantUnionTypeDef
} else if p.StringTypeDef != nil {
p.Variant = TypeVariantStringTypeDef
} else if p.BytesTypeDef != nil {
p.Variant = TypeVariantBytesTypeDef
} else if p.NumberTypeDef != nil {
p.Variant = TypeVariantNumberTypeDef
} else if p.AliasTypeDef != nil {
p.Variant = TypeVariantAliasTypeDef
} else {
return fmt.Errorf("Type: Missing required variant")
}
return nil
} | go | func (p *Type) Validate() error {
if p.BaseType != nil {
p.Variant = TypeVariantBaseType
} else if p.StructTypeDef != nil {
p.Variant = TypeVariantStructTypeDef
} else if p.MapTypeDef != nil {
p.Variant = TypeVariantMapTypeDef
} else if p.ArrayTypeDef != nil {
p.Variant = TypeVariantArrayTypeDef
} else if p.EnumTypeDef != nil {
p.Variant = TypeVariantEnumTypeDef
} else if p.UnionTypeDef != nil {
p.Variant = TypeVariantUnionTypeDef
} else if p.StringTypeDef != nil {
p.Variant = TypeVariantStringTypeDef
} else if p.BytesTypeDef != nil {
p.Variant = TypeVariantBytesTypeDef
} else if p.NumberTypeDef != nil {
p.Variant = TypeVariantNumberTypeDef
} else if p.AliasTypeDef != nil {
p.Variant = TypeVariantAliasTypeDef
} else {
return fmt.Errorf("Type: Missing required variant")
}
return nil
} | [
"func",
"(",
"p",
"*",
"Type",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"p",
".",
"BaseType",
"!=",
"nil",
"{",
"p",
".",
"Variant",
"=",
"TypeVariantBaseType",
"\n",
"}",
"else",
"if",
"p",
".",
"StructTypeDef",
"!=",
"nil",
"{",
"p",
".",
"Variant",
"=",
"TypeVariantStructTypeDef",
"\n",
"}",
"else",
"if",
"p",
".",
"MapTypeDef",
"!=",
"nil",
"{",
"p",
".",
"Variant",
"=",
"TypeVariantMapTypeDef",
"\n",
"}",
"else",
"if",
"p",
".",
"ArrayTypeDef",
"!=",
"nil",
"{",
"p",
".",
"Variant",
"=",
"TypeVariantArrayTypeDef",
"\n",
"}",
"else",
"if",
"p",
".",
"EnumTypeDef",
"!=",
"nil",
"{",
"p",
".",
"Variant",
"=",
"TypeVariantEnumTypeDef",
"\n",
"}",
"else",
"if",
"p",
".",
"UnionTypeDef",
"!=",
"nil",
"{",
"p",
".",
"Variant",
"=",
"TypeVariantUnionTypeDef",
"\n",
"}",
"else",
"if",
"p",
".",
"StringTypeDef",
"!=",
"nil",
"{",
"p",
".",
"Variant",
"=",
"TypeVariantStringTypeDef",
"\n",
"}",
"else",
"if",
"p",
".",
"BytesTypeDef",
"!=",
"nil",
"{",
"p",
".",
"Variant",
"=",
"TypeVariantBytesTypeDef",
"\n",
"}",
"else",
"if",
"p",
".",
"NumberTypeDef",
"!=",
"nil",
"{",
"p",
".",
"Variant",
"=",
"TypeVariantNumberTypeDef",
"\n",
"}",
"else",
"if",
"p",
".",
"AliasTypeDef",
"!=",
"nil",
"{",
"p",
".",
"Variant",
"=",
"TypeVariantAliasTypeDef",
"\n",
"}",
"else",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | //
// Validate for Type
// | [
"Validate",
"for",
"Type"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1474-L1499 |
14,435 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (p *Type) UnmarshalJSON(b []byte) error {
var tmp rawType
if err := json.Unmarshal(b, &tmp); err != nil {
return err
}
*p = Type(tmp)
return p.Validate()
} | go | func (p *Type) UnmarshalJSON(b []byte) error {
var tmp rawType
if err := json.Unmarshal(b, &tmp); err != nil {
return err
}
*p = Type(tmp)
return p.Validate()
} | [
"func",
"(",
"p",
"*",
"Type",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"tmp",
"rawType",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"tmp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"*",
"p",
"=",
"Type",
"(",
"tmp",
")",
"\n",
"return",
"p",
".",
"Validate",
"(",
")",
"\n",
"}"
] | //
// UnmarshalJSON for Type
// | [
"UnmarshalJSON",
"for",
"Type"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1506-L1513 |
14,436 | ardielle/ardielle-go | rdl/schema.go | NewResourceInput | func NewResourceInput(init ...*ResourceInput) *ResourceInput {
var o *ResourceInput
if len(init) == 1 {
o = init[0]
} else {
o = new(ResourceInput)
}
return o
} | go | func NewResourceInput(init ...*ResourceInput) *ResourceInput {
var o *ResourceInput
if len(init) == 1 {
o = init[0]
} else {
o = new(ResourceInput)
}
return o
} | [
"func",
"NewResourceInput",
"(",
"init",
"...",
"*",
"ResourceInput",
")",
"*",
"ResourceInput",
"{",
"var",
"o",
"*",
"ResourceInput",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"ResourceInput",
")",
"\n",
"}",
"\n",
"return",
"o",
"\n",
"}"
] | //
// NewResourceInput - creates an initialized ResourceInput instance, returns a pointer to it
// | [
"NewResourceInput",
"-",
"creates",
"an",
"initialized",
"ResourceInput",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1585-L1593 |
14,437 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (self *ResourceInput) UnmarshalJSON(b []byte) error {
var m rawResourceInput
err := json.Unmarshal(b, &m)
if err == nil {
o := ResourceInput(m)
*self = o
err = self.Validate()
}
return err
} | go | func (self *ResourceInput) UnmarshalJSON(b []byte) error {
var m rawResourceInput
err := json.Unmarshal(b, &m)
if err == nil {
o := ResourceInput(m)
*self = o
err = self.Validate()
}
return err
} | [
"func",
"(",
"self",
"*",
"ResourceInput",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"rawResourceInput",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"m",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"ResourceInput",
"(",
"m",
")",
"\n",
"*",
"self",
"=",
"o",
"\n",
"err",
"=",
"self",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a ResourceInput
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"ResourceInput"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1600-L1609 |
14,438 | ardielle/ardielle-go | rdl/schema.go | NewResourceOutput | func NewResourceOutput(init ...*ResourceOutput) *ResourceOutput {
var o *ResourceOutput
if len(init) == 1 {
o = init[0]
} else {
o = new(ResourceOutput)
}
return o
} | go | func NewResourceOutput(init ...*ResourceOutput) *ResourceOutput {
var o *ResourceOutput
if len(init) == 1 {
o = init[0]
} else {
o = new(ResourceOutput)
}
return o
} | [
"func",
"NewResourceOutput",
"(",
"init",
"...",
"*",
"ResourceOutput",
")",
"*",
"ResourceOutput",
"{",
"var",
"o",
"*",
"ResourceOutput",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"ResourceOutput",
")",
"\n",
"}",
"\n",
"return",
"o",
"\n",
"}"
] | //
// NewResourceOutput - creates an initialized ResourceOutput instance, returns a pointer to it
// | [
"NewResourceOutput",
"-",
"creates",
"an",
"initialized",
"ResourceOutput",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1673-L1681 |
14,439 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (self *ResourceOutput) UnmarshalJSON(b []byte) error {
var m rawResourceOutput
err := json.Unmarshal(b, &m)
if err == nil {
o := ResourceOutput(m)
*self = o
err = self.Validate()
}
return err
} | go | func (self *ResourceOutput) UnmarshalJSON(b []byte) error {
var m rawResourceOutput
err := json.Unmarshal(b, &m)
if err == nil {
o := ResourceOutput(m)
*self = o
err = self.Validate()
}
return err
} | [
"func",
"(",
"self",
"*",
"ResourceOutput",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"rawResourceOutput",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"m",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"ResourceOutput",
"(",
"m",
")",
"\n",
"*",
"self",
"=",
"o",
"\n",
"err",
"=",
"self",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a ResourceOutput
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"ResourceOutput"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1688-L1697 |
14,440 | ardielle/ardielle-go | rdl/schema.go | NewResourceAuth | func NewResourceAuth(init ...*ResourceAuth) *ResourceAuth {
var o *ResourceAuth
if len(init) == 1 {
o = init[0]
} else {
o = new(ResourceAuth)
}
return o
} | go | func NewResourceAuth(init ...*ResourceAuth) *ResourceAuth {
var o *ResourceAuth
if len(init) == 1 {
o = init[0]
} else {
o = new(ResourceAuth)
}
return o
} | [
"func",
"NewResourceAuth",
"(",
"init",
"...",
"*",
"ResourceAuth",
")",
"*",
"ResourceAuth",
"{",
"var",
"o",
"*",
"ResourceAuth",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"ResourceAuth",
")",
"\n",
"}",
"\n",
"return",
"o",
"\n",
"}"
] | //
// NewResourceAuth - creates an initialized ResourceAuth instance, returns a pointer to it
// | [
"NewResourceAuth",
"-",
"creates",
"an",
"initialized",
"ResourceAuth",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1762-L1770 |
14,441 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (self *ResourceAuth) UnmarshalJSON(b []byte) error {
var m rawResourceAuth
err := json.Unmarshal(b, &m)
if err == nil {
o := ResourceAuth(m)
*self = o
err = self.Validate()
}
return err
} | go | func (self *ResourceAuth) UnmarshalJSON(b []byte) error {
var m rawResourceAuth
err := json.Unmarshal(b, &m)
if err == nil {
o := ResourceAuth(m)
*self = o
err = self.Validate()
}
return err
} | [
"func",
"(",
"self",
"*",
"ResourceAuth",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"rawResourceAuth",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"m",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"ResourceAuth",
"(",
"m",
")",
"\n",
"*",
"self",
"=",
"o",
"\n",
"err",
"=",
"self",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a ResourceAuth
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"ResourceAuth"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1777-L1786 |
14,442 | ardielle/ardielle-go | rdl/schema.go | NewExceptionDef | func NewExceptionDef(init ...*ExceptionDef) *ExceptionDef {
var o *ExceptionDef
if len(init) == 1 {
o = init[0]
} else {
o = new(ExceptionDef)
}
return o
} | go | func NewExceptionDef(init ...*ExceptionDef) *ExceptionDef {
var o *ExceptionDef
if len(init) == 1 {
o = init[0]
} else {
o = new(ExceptionDef)
}
return o
} | [
"func",
"NewExceptionDef",
"(",
"init",
"...",
"*",
"ExceptionDef",
")",
"*",
"ExceptionDef",
"{",
"var",
"o",
"*",
"ExceptionDef",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"ExceptionDef",
")",
"\n",
"}",
"\n",
"return",
"o",
"\n",
"}"
] | //
// NewExceptionDef - creates an initialized ExceptionDef instance, returns a pointer to it
// | [
"NewExceptionDef",
"-",
"creates",
"an",
"initialized",
"ExceptionDef",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1815-L1823 |
14,443 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (self *ExceptionDef) UnmarshalJSON(b []byte) error {
var m rawExceptionDef
err := json.Unmarshal(b, &m)
if err == nil {
o := ExceptionDef(m)
*self = o
err = self.Validate()
}
return err
} | go | func (self *ExceptionDef) UnmarshalJSON(b []byte) error {
var m rawExceptionDef
err := json.Unmarshal(b, &m)
if err == nil {
o := ExceptionDef(m)
*self = o
err = self.Validate()
}
return err
} | [
"func",
"(",
"self",
"*",
"ExceptionDef",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"rawExceptionDef",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"m",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"ExceptionDef",
"(",
"m",
")",
"\n",
"*",
"self",
"=",
"o",
"\n",
"err",
"=",
"self",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a ExceptionDef
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"ExceptionDef"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1830-L1839 |
14,444 | ardielle/ardielle-go | rdl/schema.go | NewResource | func NewResource(init ...*Resource) *Resource {
var o *Resource
if len(init) == 1 {
o = init[0]
} else {
o = new(Resource)
}
return o.Init()
} | go | func NewResource(init ...*Resource) *Resource {
var o *Resource
if len(init) == 1 {
o = init[0]
} else {
o = new(Resource)
}
return o.Init()
} | [
"func",
"NewResource",
"(",
"init",
"...",
"*",
"Resource",
")",
"*",
"Resource",
"{",
"var",
"o",
"*",
"Resource",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"Resource",
")",
"\n",
"}",
"\n",
"return",
"o",
".",
"Init",
"(",
")",
"\n",
"}"
] | //
// NewResource - creates an initialized Resource instance, returns a pointer to it
// | [
"NewResource",
"-",
"creates",
"an",
"initialized",
"Resource",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1941-L1949 |
14,445 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (self *Resource) UnmarshalJSON(b []byte) error {
var m rawResource
err := json.Unmarshal(b, &m)
if err == nil {
o := Resource(m)
*self = *((&o).Init())
err = self.Validate()
}
return err
} | go | func (self *Resource) UnmarshalJSON(b []byte) error {
var m rawResource
err := json.Unmarshal(b, &m)
if err == nil {
o := Resource(m)
*self = *((&o).Init())
err = self.Validate()
}
return err
} | [
"func",
"(",
"self",
"*",
"Resource",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"rawResource",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"m",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"Resource",
"(",
"m",
")",
"\n",
"*",
"self",
"=",
"*",
"(",
"(",
"&",
"o",
")",
".",
"Init",
"(",
")",
")",
"\n",
"err",
"=",
"self",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a Resource
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"Resource"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L1966-L1975 |
14,446 | ardielle/ardielle-go | rdl/schema.go | NewSchema | func NewSchema(init ...*Schema) *Schema {
var o *Schema
if len(init) == 1 {
o = init[0]
} else {
o = new(Schema)
}
return o
} | go | func NewSchema(init ...*Schema) *Schema {
var o *Schema
if len(init) == 1 {
o = init[0]
} else {
o = new(Schema)
}
return o
} | [
"func",
"NewSchema",
"(",
"init",
"...",
"*",
"Schema",
")",
"*",
"Schema",
"{",
"var",
"o",
"*",
"Schema",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"Schema",
")",
"\n",
"}",
"\n",
"return",
"o",
"\n",
"}"
] | //
// NewSchema - creates an initialized Schema instance, returns a pointer to it
// | [
"NewSchema",
"-",
"creates",
"an",
"initialized",
"Schema",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L2066-L2074 |
14,447 | ardielle/ardielle-go | rdl/schema.go | UnmarshalJSON | func (self *Schema) UnmarshalJSON(b []byte) error {
var m rawSchema
err := json.Unmarshal(b, &m)
if err == nil {
o := Schema(m)
*self = o
err = self.Validate()
}
return err
} | go | func (self *Schema) UnmarshalJSON(b []byte) error {
var m rawSchema
err := json.Unmarshal(b, &m)
if err == nil {
o := Schema(m)
*self = o
err = self.Validate()
}
return err
} | [
"func",
"(",
"self",
"*",
"Schema",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"m",
"rawSchema",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"m",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"Schema",
"(",
"m",
")",
"\n",
"*",
"self",
"=",
"o",
"\n",
"err",
"=",
"self",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a Schema
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"Schema"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/schema.go#L2081-L2090 |
14,448 | ardielle/ardielle-go | rdl/basictypes_model.go | NewOptions | func NewOptions(init ...interface{}) Options {
if len(init) == 1 {
switch v := init[0].(type) {
case Options:
return v
case int:
return Options(v)
case int32:
return Options(v)
case string:
for i, s := range namesOptions {
if s == v {
return Options(i)
}
}
default:
panic("Bad init value for Options enum")
}
}
return Options(0) //default to the first enum value
} | go | func NewOptions(init ...interface{}) Options {
if len(init) == 1 {
switch v := init[0].(type) {
case Options:
return v
case int:
return Options(v)
case int32:
return Options(v)
case string:
for i, s := range namesOptions {
if s == v {
return Options(i)
}
}
default:
panic("Bad init value for Options enum")
}
}
return Options(0) //default to the first enum value
} | [
"func",
"NewOptions",
"(",
"init",
"...",
"interface",
"{",
"}",
")",
"Options",
"{",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"switch",
"v",
":=",
"init",
"[",
"0",
"]",
".",
"(",
"type",
")",
"{",
"case",
"Options",
":",
"return",
"v",
"\n",
"case",
"int",
":",
"return",
"Options",
"(",
"v",
")",
"\n",
"case",
"int32",
":",
"return",
"Options",
"(",
"v",
")",
"\n",
"case",
"string",
":",
"for",
"i",
",",
"s",
":=",
"range",
"namesOptions",
"{",
"if",
"s",
"==",
"v",
"{",
"return",
"Options",
"(",
"i",
")",
"\n",
"}",
"\n",
"}",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"Options",
"(",
"0",
")",
"//default to the first enum value",
"\n",
"}"
] | //
// NewOptions - return a string representation of the enum
// | [
"NewOptions",
"-",
"return",
"a",
"string",
"representation",
"of",
"the",
"enum"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/basictypes_model.go#L39-L59 |
14,449 | ardielle/ardielle-go | rdl/basictypes_model.go | UnmarshalJSON | func (pTypeDef *SymTest) UnmarshalJSON(b []byte) error {
var r rawSymTest
err := json.Unmarshal(b, &r)
if err == nil {
o := SymTest(r)
*pTypeDef = *((&o).Init())
err = pTypeDef.Validate()
}
return err
} | go | func (pTypeDef *SymTest) UnmarshalJSON(b []byte) error {
var r rawSymTest
err := json.Unmarshal(b, &r)
if err == nil {
o := SymTest(r)
*pTypeDef = *((&o).Init())
err = pTypeDef.Validate()
}
return err
} | [
"func",
"(",
"pTypeDef",
"*",
"SymTest",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"r",
"rawSymTest",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"SymTest",
"(",
"r",
")",
"\n",
"*",
"pTypeDef",
"=",
"*",
"(",
"(",
"&",
"o",
")",
".",
"Init",
"(",
")",
")",
"\n",
"err",
"=",
"pTypeDef",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a SymTest
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"SymTest"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/basictypes_model.go#L134-L143 |
14,450 | ardielle/ardielle-go | rdl/basictypes_model.go | UnmarshalJSON | func (pTypeDef *StringTest) UnmarshalJSON(b []byte) error {
var r rawStringTest
err := json.Unmarshal(b, &r)
if err == nil {
o := StringTest(r)
*pTypeDef = o
err = pTypeDef.Validate()
}
return err
} | go | func (pTypeDef *StringTest) UnmarshalJSON(b []byte) error {
var r rawStringTest
err := json.Unmarshal(b, &r)
if err == nil {
o := StringTest(r)
*pTypeDef = o
err = pTypeDef.Validate()
}
return err
} | [
"func",
"(",
"pTypeDef",
"*",
"StringTest",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"r",
"rawStringTest",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"StringTest",
"(",
"r",
")",
"\n",
"*",
"pTypeDef",
"=",
"o",
"\n",
"err",
"=",
"pTypeDef",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a StringTest
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"StringTest"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/basictypes_model.go#L189-L198 |
14,451 | ardielle/ardielle-go | rdl/basictypes_model.go | UnmarshalJSON | func (pTypeDef *MapTest) UnmarshalJSON(b []byte) error {
var r rawMapTest
err := json.Unmarshal(b, &r)
if err == nil {
o := MapTest(r)
*pTypeDef = *((&o).Init())
err = pTypeDef.Validate()
}
return err
} | go | func (pTypeDef *MapTest) UnmarshalJSON(b []byte) error {
var r rawMapTest
err := json.Unmarshal(b, &r)
if err == nil {
o := MapTest(r)
*pTypeDef = *((&o).Init())
err = pTypeDef.Validate()
}
return err
} | [
"func",
"(",
"pTypeDef",
"*",
"MapTest",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"r",
"rawMapTest",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"MapTest",
"(",
"r",
")",
"\n",
"*",
"pTypeDef",
"=",
"*",
"(",
"(",
"&",
"o",
")",
".",
"Init",
"(",
")",
")",
"\n",
"err",
"=",
"pTypeDef",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a MapTest
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"MapTest"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/basictypes_model.go#L248-L257 |
14,452 | ardielle/ardielle-go | rdl/basictypes_model.go | UnmarshalJSON | func (pTypeDef *MapArrayTest) UnmarshalJSON(b []byte) error {
var r rawMapArrayTest
err := json.Unmarshal(b, &r)
if err == nil {
o := MapArrayTest(r)
*pTypeDef = *((&o).Init())
err = pTypeDef.Validate()
}
return err
} | go | func (pTypeDef *MapArrayTest) UnmarshalJSON(b []byte) error {
var r rawMapArrayTest
err := json.Unmarshal(b, &r)
if err == nil {
o := MapArrayTest(r)
*pTypeDef = *((&o).Init())
err = pTypeDef.Validate()
}
return err
} | [
"func",
"(",
"pTypeDef",
"*",
"MapArrayTest",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"r",
"rawMapArrayTest",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"MapArrayTest",
"(",
"r",
")",
"\n",
"*",
"pTypeDef",
"=",
"*",
"(",
"(",
"&",
"o",
")",
".",
"Init",
"(",
")",
")",
"\n",
"err",
"=",
"pTypeDef",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a MapArrayTest
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"MapArrayTest"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/basictypes_model.go#L309-L318 |
14,453 | ardielle/ardielle-go | rdl/basictypes_model.go | UnmarshalJSON | func (pTypeDef *IntOOBTest) UnmarshalJSON(b []byte) error {
var r rawIntOOBTest
err := json.Unmarshal(b, &r)
if err == nil {
o := IntOOBTest(r)
*pTypeDef = o
err = pTypeDef.Validate()
}
return err
} | go | func (pTypeDef *IntOOBTest) UnmarshalJSON(b []byte) error {
var r rawIntOOBTest
err := json.Unmarshal(b, &r)
if err == nil {
o := IntOOBTest(r)
*pTypeDef = o
err = pTypeDef.Validate()
}
return err
} | [
"func",
"(",
"pTypeDef",
"*",
"IntOOBTest",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"r",
"rawIntOOBTest",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"IntOOBTest",
"(",
"r",
")",
"\n",
"*",
"pTypeDef",
"=",
"o",
"\n",
"err",
"=",
"pTypeDef",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a IntOOBTest
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"IntOOBTest"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/basictypes_model.go#L355-L364 |
14,454 | ardielle/ardielle-go | rdl/basictypes_model.go | UnmarshalJSON | func (pTypeDef *NegativeNumberTest) UnmarshalJSON(b []byte) error {
var r rawNegativeNumberTest
err := json.Unmarshal(b, &r)
if err == nil {
o := NegativeNumberTest(r)
*pTypeDef = o
err = pTypeDef.Validate()
}
return err
} | go | func (pTypeDef *NegativeNumberTest) UnmarshalJSON(b []byte) error {
var r rawNegativeNumberTest
err := json.Unmarshal(b, &r)
if err == nil {
o := NegativeNumberTest(r)
*pTypeDef = o
err = pTypeDef.Validate()
}
return err
} | [
"func",
"(",
"pTypeDef",
"*",
"NegativeNumberTest",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"r",
"rawNegativeNumberTest",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"NegativeNumberTest",
"(",
"r",
")",
"\n",
"*",
"pTypeDef",
"=",
"o",
"\n",
"err",
"=",
"pTypeDef",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a NegativeNumberTest
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"NegativeNumberTest"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/basictypes_model.go#L398-L407 |
14,455 | ardielle/ardielle-go | rdl/basictypes_model.go | UnmarshalJSON | func (pTypeDef *UUIDTest) UnmarshalJSON(b []byte) error {
var r rawUUIDTest
err := json.Unmarshal(b, &r)
if err == nil {
o := UUIDTest(r)
*pTypeDef = o
err = pTypeDef.Validate()
}
return err
} | go | func (pTypeDef *UUIDTest) UnmarshalJSON(b []byte) error {
var r rawUUIDTest
err := json.Unmarshal(b, &r)
if err == nil {
o := UUIDTest(r)
*pTypeDef = o
err = pTypeDef.Validate()
}
return err
} | [
"func",
"(",
"pTypeDef",
"*",
"UUIDTest",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"r",
"rawUUIDTest",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"UUIDTest",
"(",
"r",
")",
"\n",
"*",
"pTypeDef",
"=",
"o",
"\n",
"err",
"=",
"pTypeDef",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a UUIDTest
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"UUIDTest"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/basictypes_model.go#L441-L450 |
14,456 | ardielle/ardielle-go | rdl/basictypes_model.go | UnmarshalJSON | func (pTypeDef *TimestampTest) UnmarshalJSON(b []byte) error {
var r rawTimestampTest
err := json.Unmarshal(b, &r)
if err == nil {
o := TimestampTest(r)
*pTypeDef = o
err = pTypeDef.Validate()
}
return err
} | go | func (pTypeDef *TimestampTest) UnmarshalJSON(b []byte) error {
var r rawTimestampTest
err := json.Unmarshal(b, &r)
if err == nil {
o := TimestampTest(r)
*pTypeDef = o
err = pTypeDef.Validate()
}
return err
} | [
"func",
"(",
"pTypeDef",
"*",
"TimestampTest",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"r",
"rawTimestampTest",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"TimestampTest",
"(",
"r",
")",
"\n",
"*",
"pTypeDef",
"=",
"o",
"\n",
"err",
"=",
"pTypeDef",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a TimestampTest
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"TimestampTest"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/basictypes_model.go#L487-L496 |
14,457 | ardielle/ardielle-go | rdl/basictypes_model.go | UnmarshalJSON | func (pTypeDef *Test) UnmarshalJSON(b []byte) error {
var r rawTest
err := json.Unmarshal(b, &r)
if err == nil {
o := Test(r)
*pTypeDef = *((&o).Init())
err = pTypeDef.Validate()
}
return err
} | go | func (pTypeDef *Test) UnmarshalJSON(b []byte) error {
var r rawTest
err := json.Unmarshal(b, &r)
if err == nil {
o := Test(r)
*pTypeDef = *((&o).Init())
err = pTypeDef.Validate()
}
return err
} | [
"func",
"(",
"pTypeDef",
"*",
"Test",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"r",
"rawTest",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"Test",
"(",
"r",
")",
"\n",
"*",
"pTypeDef",
"=",
"*",
"(",
"(",
"&",
"o",
")",
".",
"Init",
"(",
")",
")",
"\n",
"err",
"=",
"pTypeDef",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a Test
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"Test"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/basictypes_model.go#L569-L578 |
14,458 | ardielle/ardielle-go | tbin/polyline_model.go | NewPoint | func NewPoint(init ...*Point) *Point {
var o *Point
if len(init) == 1 {
o = init[0]
} else {
o = new(Point)
}
return o
} | go | func NewPoint(init ...*Point) *Point {
var o *Point
if len(init) == 1 {
o = init[0]
} else {
o = new(Point)
}
return o
} | [
"func",
"NewPoint",
"(",
"init",
"...",
"*",
"Point",
")",
"*",
"Point",
"{",
"var",
"o",
"*",
"Point",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"Point",
")",
"\n",
"}",
"\n",
"return",
"o",
"\n",
"}"
] | //
// NewPoint - creates an initialized Point instance, returns a pointer to it
// | [
"NewPoint",
"-",
"creates",
"an",
"initialized",
"Point",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/polyline_model.go#L28-L36 |
14,459 | ardielle/ardielle-go | tbin/polyline_model.go | UnmarshalJSON | func (pTypeDef *Point) UnmarshalJSON(b []byte) error {
var r rawPoint
err := json.Unmarshal(b, &r)
if err == nil {
o := Point(r)
*pTypeDef = o
err = pTypeDef.Validate()
}
return err
} | go | func (pTypeDef *Point) UnmarshalJSON(b []byte) error {
var r rawPoint
err := json.Unmarshal(b, &r)
if err == nil {
o := Point(r)
*pTypeDef = o
err = pTypeDef.Validate()
}
return err
} | [
"func",
"(",
"pTypeDef",
"*",
"Point",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"r",
"rawPoint",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"Point",
"(",
"r",
")",
"\n",
"*",
"pTypeDef",
"=",
"o",
"\n",
"err",
"=",
"pTypeDef",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a Point
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"Point"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/polyline_model.go#L43-L52 |
14,460 | ardielle/ardielle-go | tbin/polyline_model.go | NewPolyline | func NewPolyline(init ...*Polyline) *Polyline {
var o *Polyline
if len(init) == 1 {
o = init[0]
} else {
o = new(Polyline)
}
return o.Init()
} | go | func NewPolyline(init ...*Polyline) *Polyline {
var o *Polyline
if len(init) == 1 {
o = init[0]
} else {
o = new(Polyline)
}
return o.Init()
} | [
"func",
"NewPolyline",
"(",
"init",
"...",
"*",
"Polyline",
")",
"*",
"Polyline",
"{",
"var",
"o",
"*",
"Polyline",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"Polyline",
")",
"\n",
"}",
"\n",
"return",
"o",
".",
"Init",
"(",
")",
"\n",
"}"
] | //
// NewPolyline - creates an initialized Polyline instance, returns a pointer to it
// | [
"NewPolyline",
"-",
"creates",
"an",
"initialized",
"Polyline",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/polyline_model.go#L71-L79 |
14,461 | ardielle/ardielle-go | tbin/polyline_model.go | UnmarshalJSON | func (pTypeDef *Polyline) UnmarshalJSON(b []byte) error {
var r rawPolyline
err := json.Unmarshal(b, &r)
if err == nil {
o := Polyline(r)
*pTypeDef = *((&o).Init())
err = pTypeDef.Validate()
}
return err
} | go | func (pTypeDef *Polyline) UnmarshalJSON(b []byte) error {
var r rawPolyline
err := json.Unmarshal(b, &r)
if err == nil {
o := Polyline(r)
*pTypeDef = *((&o).Init())
err = pTypeDef.Validate()
}
return err
} | [
"func",
"(",
"pTypeDef",
"*",
"Polyline",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"r",
"rawPolyline",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"Polyline",
"(",
"r",
")",
"\n",
"*",
"pTypeDef",
"=",
"*",
"(",
"(",
"&",
"o",
")",
".",
"Init",
"(",
")",
")",
"\n",
"err",
"=",
"pTypeDef",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a Polyline
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"Polyline"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/polyline_model.go#L96-L105 |
14,462 | ardielle/ardielle-go | tbin/polyline_model.go | NewRect | func NewRect(init ...*Rect) *Rect {
var o *Rect
if len(init) == 1 {
o = init[0]
} else {
o = new(Rect)
}
return o.Init()
} | go | func NewRect(init ...*Rect) *Rect {
var o *Rect
if len(init) == 1 {
o = init[0]
} else {
o = new(Rect)
}
return o.Init()
} | [
"func",
"NewRect",
"(",
"init",
"...",
"*",
"Rect",
")",
"*",
"Rect",
"{",
"var",
"o",
"*",
"Rect",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"Rect",
")",
"\n",
"}",
"\n",
"return",
"o",
".",
"Init",
"(",
")",
"\n",
"}"
] | //
// NewRect - creates an initialized Rect instance, returns a pointer to it
// | [
"NewRect",
"-",
"creates",
"an",
"initialized",
"Rect",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/polyline_model.go#L128-L136 |
14,463 | ardielle/ardielle-go | tbin/polyline_model.go | UnmarshalJSON | func (pTypeDef *Rect) UnmarshalJSON(b []byte) error {
var r rawRect
err := json.Unmarshal(b, &r)
if err == nil {
o := Rect(r)
*pTypeDef = *((&o).Init())
err = pTypeDef.Validate()
}
return err
} | go | func (pTypeDef *Rect) UnmarshalJSON(b []byte) error {
var r rawRect
err := json.Unmarshal(b, &r)
if err == nil {
o := Rect(r)
*pTypeDef = *((&o).Init())
err = pTypeDef.Validate()
}
return err
} | [
"func",
"(",
"pTypeDef",
"*",
"Rect",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"r",
"rawRect",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"Rect",
"(",
"r",
")",
"\n",
"*",
"pTypeDef",
"=",
"*",
"(",
"(",
"&",
"o",
")",
".",
"Init",
"(",
")",
")",
"\n",
"err",
"=",
"pTypeDef",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a Rect
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"Rect"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/polyline_model.go#L156-L165 |
14,464 | ardielle/ardielle-go | tbin/polyline_model.go | MarshalJSON | func (u Shape) MarshalJSON() ([]byte, error) {
switch u.Variant {
case ShapeVariantPolyline:
return json.Marshal(u.Polyline)
case ShapeVariantRect:
return json.Marshal(u.Rect)
default:
return nil, fmt.Errorf("Cannot marshal uninitialized union type Shape")
}
} | go | func (u Shape) MarshalJSON() ([]byte, error) {
switch u.Variant {
case ShapeVariantPolyline:
return json.Marshal(u.Polyline)
case ShapeVariantRect:
return json.Marshal(u.Rect)
default:
return nil, fmt.Errorf("Cannot marshal uninitialized union type Shape")
}
} | [
"func",
"(",
"u",
"Shape",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"switch",
"u",
".",
"Variant",
"{",
"case",
"ShapeVariantPolyline",
":",
"return",
"json",
".",
"Marshal",
"(",
"u",
".",
"Polyline",
")",
"\n",
"case",
"ShapeVariantRect",
":",
"return",
"json",
".",
"Marshal",
"(",
"u",
".",
"Rect",
")",
"\n",
"default",
":",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] | //
// MarshalJSON for Shape
// | [
"MarshalJSON",
"for",
"Shape"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/polyline_model.go#L217-L226 |
14,465 | ardielle/ardielle-go | tbin/polyline_model.go | UnmarshalJSON | func (u *Shape) UnmarshalJSON(b []byte) error {
var tmp interface{}
if err := json.Unmarshal(b, &tmp); err != nil {
return err
}
switch v := tmp.(type) {
case map[string]interface{}:
if makeShapeVariantPolyline(b, u, v) {
return nil
}
if makeShapeVariantRect(b, u, v) {
return nil
}
}
return fmt.Errorf("Cannot unmarshal JSON to union type Shape")
} | go | func (u *Shape) UnmarshalJSON(b []byte) error {
var tmp interface{}
if err := json.Unmarshal(b, &tmp); err != nil {
return err
}
switch v := tmp.(type) {
case map[string]interface{}:
if makeShapeVariantPolyline(b, u, v) {
return nil
}
if makeShapeVariantRect(b, u, v) {
return nil
}
}
return fmt.Errorf("Cannot unmarshal JSON to union type Shape")
} | [
"func",
"(",
"u",
"*",
"Shape",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"tmp",
"interface",
"{",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"tmp",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"switch",
"v",
":=",
"tmp",
".",
"(",
"type",
")",
"{",
"case",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
":",
"if",
"makeShapeVariantPolyline",
"(",
"b",
",",
"u",
",",
"v",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"makeShapeVariantRect",
"(",
"b",
",",
"u",
",",
"v",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | //
// UnmarshalJSON for Shape
// | [
"UnmarshalJSON",
"for",
"Shape"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/polyline_model.go#L273-L288 |
14,466 | ardielle/ardielle-go | tbin/polyline_model.go | NewDrawing | func NewDrawing(init ...*Drawing) *Drawing {
var o *Drawing
if len(init) == 1 {
o = init[0]
} else {
o = new(Drawing)
}
return o.Init()
} | go | func NewDrawing(init ...*Drawing) *Drawing {
var o *Drawing
if len(init) == 1 {
o = init[0]
} else {
o = new(Drawing)
}
return o.Init()
} | [
"func",
"NewDrawing",
"(",
"init",
"...",
"*",
"Drawing",
")",
"*",
"Drawing",
"{",
"var",
"o",
"*",
"Drawing",
"\n",
"if",
"len",
"(",
"init",
")",
"==",
"1",
"{",
"o",
"=",
"init",
"[",
"0",
"]",
"\n",
"}",
"else",
"{",
"o",
"=",
"new",
"(",
"Drawing",
")",
"\n",
"}",
"\n",
"return",
"o",
".",
"Init",
"(",
")",
"\n",
"}"
] | //
// NewDrawing - creates an initialized Drawing instance, returns a pointer to it
// | [
"NewDrawing",
"-",
"creates",
"an",
"initialized",
"Drawing",
"instance",
"returns",
"a",
"pointer",
"to",
"it"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/polyline_model.go#L300-L308 |
14,467 | ardielle/ardielle-go | tbin/polyline_model.go | UnmarshalJSON | func (pTypeDef *Drawing) UnmarshalJSON(b []byte) error {
var r rawDrawing
err := json.Unmarshal(b, &r)
if err == nil {
o := Drawing(r)
*pTypeDef = *((&o).Init())
err = pTypeDef.Validate()
}
return err
} | go | func (pTypeDef *Drawing) UnmarshalJSON(b []byte) error {
var r rawDrawing
err := json.Unmarshal(b, &r)
if err == nil {
o := Drawing(r)
*pTypeDef = *((&o).Init())
err = pTypeDef.Validate()
}
return err
} | [
"func",
"(",
"pTypeDef",
"*",
"Drawing",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"r",
"rawDrawing",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"r",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"o",
":=",
"Drawing",
"(",
"r",
")",
"\n",
"*",
"pTypeDef",
"=",
"*",
"(",
"(",
"&",
"o",
")",
".",
"Init",
"(",
")",
")",
"\n",
"err",
"=",
"pTypeDef",
".",
"Validate",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON is defined for proper JSON decoding of a Drawing
// | [
"UnmarshalJSON",
"is",
"defined",
"for",
"proper",
"JSON",
"decoding",
"of",
"a",
"Drawing"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/polyline_model.go#L325-L334 |
14,468 | ardielle/ardielle-go | rdl/validator.go | Validate | func Validate(schema *Schema, typename string, data interface{}) Validation {
v := getValidator(schema)
return validateWithValidator(v, typename, data)
} | go | func Validate(schema *Schema, typename string, data interface{}) Validation {
v := getValidator(schema)
return validateWithValidator(v, typename, data)
} | [
"func",
"Validate",
"(",
"schema",
"*",
"Schema",
",",
"typename",
"string",
",",
"data",
"interface",
"{",
"}",
")",
"Validation",
"{",
"v",
":=",
"getValidator",
"(",
"schema",
")",
"\n",
"return",
"validateWithValidator",
"(",
"v",
",",
"typename",
",",
"data",
")",
"\n",
"}"
] | // Validate tests the provided generic data against a type in the specified schema. If the typename is empty,
// an attempt to guess the type is made, otherwise the check is done against the single type. | [
"Validate",
"tests",
"the",
"provided",
"generic",
"data",
"against",
"a",
"type",
"in",
"the",
"specified",
"schema",
".",
"If",
"the",
"typename",
"is",
"empty",
"an",
"attempt",
"to",
"guess",
"the",
"type",
"is",
"made",
"otherwise",
"the",
"check",
"is",
"done",
"against",
"the",
"single",
"type",
"."
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/validator.go#L89-L92 |
14,469 | ardielle/ardielle-go | rdl/validator.go | validateWithValidator | func validateWithValidator(validator *validator, typename string, data interface{}) Validation {
typelist := validator.schema.Types
if typelist == nil {
return validator.bad("top level", "Schema contains no types", data, "")
}
if typename == "" {
//iterate over the types until we find the most (defined last) general match
//But: not always useful: if structs are not "closed", they match on almost anything.
for i := len(typelist) - 1; i >= 0; i-- {
t := typelist[i]
tName, _, _ := TypeInfo(t)
v := validator.validate(t, data, string(tName))
if v.Error == "" {
return v
}
}
return validator.bad("top level", "Cannot determine type of data in schema", data, "")
}
context := typename
typedef := validator.registry.FindType(TypeRef(typename))
if typedef != nil {
return validator.validate(typedef, data, context)
}
return validator.bad(context, "No such type", nil, "")
} | go | func validateWithValidator(validator *validator, typename string, data interface{}) Validation {
typelist := validator.schema.Types
if typelist == nil {
return validator.bad("top level", "Schema contains no types", data, "")
}
if typename == "" {
//iterate over the types until we find the most (defined last) general match
//But: not always useful: if structs are not "closed", they match on almost anything.
for i := len(typelist) - 1; i >= 0; i-- {
t := typelist[i]
tName, _, _ := TypeInfo(t)
v := validator.validate(t, data, string(tName))
if v.Error == "" {
return v
}
}
return validator.bad("top level", "Cannot determine type of data in schema", data, "")
}
context := typename
typedef := validator.registry.FindType(TypeRef(typename))
if typedef != nil {
return validator.validate(typedef, data, context)
}
return validator.bad(context, "No such type", nil, "")
} | [
"func",
"validateWithValidator",
"(",
"validator",
"*",
"validator",
",",
"typename",
"string",
",",
"data",
"interface",
"{",
"}",
")",
"Validation",
"{",
"typelist",
":=",
"validator",
".",
"schema",
".",
"Types",
"\n",
"if",
"typelist",
"==",
"nil",
"{",
"return",
"validator",
".",
"bad",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"data",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"typename",
"==",
"\"",
"\"",
"{",
"//iterate over the types until we find the most (defined last) general match",
"//But: not always useful: if structs are not \"closed\", they match on almost anything.",
"for",
"i",
":=",
"len",
"(",
"typelist",
")",
"-",
"1",
";",
"i",
">=",
"0",
";",
"i",
"--",
"{",
"t",
":=",
"typelist",
"[",
"i",
"]",
"\n",
"tName",
",",
"_",
",",
"_",
":=",
"TypeInfo",
"(",
"t",
")",
"\n",
"v",
":=",
"validator",
".",
"validate",
"(",
"t",
",",
"data",
",",
"string",
"(",
"tName",
")",
")",
"\n",
"if",
"v",
".",
"Error",
"==",
"\"",
"\"",
"{",
"return",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"validator",
".",
"bad",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"data",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"context",
":=",
"typename",
"\n",
"typedef",
":=",
"validator",
".",
"registry",
".",
"FindType",
"(",
"TypeRef",
"(",
"typename",
")",
")",
"\n\n",
"if",
"typedef",
"!=",
"nil",
"{",
"return",
"validator",
".",
"validate",
"(",
"typedef",
",",
"data",
",",
"context",
")",
"\n",
"}",
"\n",
"return",
"validator",
".",
"bad",
"(",
"context",
",",
"\"",
"\"",
",",
"nil",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // ValidateWithValidator tests the provided generic data using the supplied validator. If the typename is empty,
// an attempt to guess the type is made, otherwise the check is done against the single type.
// Supplying the validator allows it to be reused between validations rather than constructing anew | [
"ValidateWithValidator",
"tests",
"the",
"provided",
"generic",
"data",
"using",
"the",
"supplied",
"validator",
".",
"If",
"the",
"typename",
"is",
"empty",
"an",
"attempt",
"to",
"guess",
"the",
"type",
"is",
"made",
"otherwise",
"the",
"check",
"is",
"done",
"against",
"the",
"single",
"type",
".",
"Supplying",
"the",
"validator",
"allows",
"it",
"to",
"be",
"reused",
"between",
"validations",
"rather",
"than",
"constructing",
"anew"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/validator.go#L97-L123 |
14,470 | ardielle/ardielle-go | tbin/encoder.go | WriteType | func (enc *Encoder) WriteType(sig *Signature) error {
if enc.tagged {
enc.tagged = false
return nil
}
return enc.compileSignature(sig, &enc.buf) //as a side-effect, this defines new tags
} | go | func (enc *Encoder) WriteType(sig *Signature) error {
if enc.tagged {
enc.tagged = false
return nil
}
return enc.compileSignature(sig, &enc.buf) //as a side-effect, this defines new tags
} | [
"func",
"(",
"enc",
"*",
"Encoder",
")",
"WriteType",
"(",
"sig",
"*",
"Signature",
")",
"error",
"{",
"if",
"enc",
".",
"tagged",
"{",
"enc",
".",
"tagged",
"=",
"false",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"enc",
".",
"compileSignature",
"(",
"sig",
",",
"&",
"enc",
".",
"buf",
")",
"//as a side-effect, this defines new tags",
"\n",
"}"
] | // WriteType takes a signature and writes the tag for it. If it is the first time
// the signature has been encountered, a new tag is allocated and written followed
// by its definition. | [
"WriteType",
"takes",
"a",
"signature",
"and",
"writes",
"the",
"tag",
"for",
"it",
".",
"If",
"it",
"is",
"the",
"first",
"time",
"the",
"signature",
"has",
"been",
"encountered",
"a",
"new",
"tag",
"is",
"allocated",
"and",
"written",
"followed",
"by",
"its",
"definition",
"."
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/encoder.go#L681-L687 |
14,471 | ardielle/ardielle-go | tbin/encoder.go | WriteInt | func (enc *Encoder) WriteInt(n int) error {
return enc.writeUnsigned((n << 1) ^ (n >> 31))
} | go | func (enc *Encoder) WriteInt(n int) error {
return enc.writeUnsigned((n << 1) ^ (n >> 31))
} | [
"func",
"(",
"enc",
"*",
"Encoder",
")",
"WriteInt",
"(",
"n",
"int",
")",
"error",
"{",
"return",
"enc",
".",
"writeUnsigned",
"(",
"(",
"n",
"<<",
"1",
")",
"^",
"(",
"n",
">>",
"31",
")",
")",
"\n",
"}"
] | // WriteInt - write the signed 32 bit int | [
"WriteInt",
"-",
"write",
"the",
"signed",
"32",
"bit",
"int"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/encoder.go#L745-L747 |
14,472 | ardielle/ardielle-go | tbin/encoder.go | WriteBool | func (enc *Encoder) WriteBool(val bool) error {
if val {
return enc.writeUnsigned(1)
}
return enc.writeUnsigned(0)
} | go | func (enc *Encoder) WriteBool(val bool) error {
if val {
return enc.writeUnsigned(1)
}
return enc.writeUnsigned(0)
} | [
"func",
"(",
"enc",
"*",
"Encoder",
")",
"WriteBool",
"(",
"val",
"bool",
")",
"error",
"{",
"if",
"val",
"{",
"return",
"enc",
".",
"writeUnsigned",
"(",
"1",
")",
"\n",
"}",
"\n",
"return",
"enc",
".",
"writeUnsigned",
"(",
"0",
")",
"\n",
"}"
] | // WriteBool - writes the value of the bool | [
"WriteBool",
"-",
"writes",
"the",
"value",
"of",
"the",
"bool"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/encoder.go#L758-L763 |
14,473 | ardielle/ardielle-go | tbin/encoder.go | WriteInt8 | func (enc *Encoder) WriteInt8(val int8) error {
return enc.WriteInt(int(val))
} | go | func (enc *Encoder) WriteInt8(val int8) error {
return enc.WriteInt(int(val))
} | [
"func",
"(",
"enc",
"*",
"Encoder",
")",
"WriteInt8",
"(",
"val",
"int8",
")",
"error",
"{",
"return",
"enc",
".",
"WriteInt",
"(",
"int",
"(",
"val",
")",
")",
"\n",
"}"
] | // WriteInt8 - writes the signed 8 bit integer as a varint | [
"WriteInt8",
"-",
"writes",
"the",
"signed",
"8",
"bit",
"integer",
"as",
"a",
"varint"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/encoder.go#L766-L768 |
14,474 | ardielle/ardielle-go | tbin/encoder.go | WriteInt16 | func (enc *Encoder) WriteInt16(val int16) error {
return enc.WriteInt(int(val))
} | go | func (enc *Encoder) WriteInt16(val int16) error {
return enc.WriteInt(int(val))
} | [
"func",
"(",
"enc",
"*",
"Encoder",
")",
"WriteInt16",
"(",
"val",
"int16",
")",
"error",
"{",
"return",
"enc",
".",
"WriteInt",
"(",
"int",
"(",
"val",
")",
")",
"\n",
"}"
] | // WriteInt16 - writes the signed 16 bit integer as a varint | [
"WriteInt16",
"-",
"writes",
"the",
"signed",
"16",
"bit",
"integer",
"as",
"a",
"varint"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/encoder.go#L771-L773 |
14,475 | ardielle/ardielle-go | tbin/encoder.go | WriteInt32 | func (enc *Encoder) WriteInt32(val int32) error {
return enc.WriteInt(int(val))
} | go | func (enc *Encoder) WriteInt32(val int32) error {
return enc.WriteInt(int(val))
} | [
"func",
"(",
"enc",
"*",
"Encoder",
")",
"WriteInt32",
"(",
"val",
"int32",
")",
"error",
"{",
"return",
"enc",
".",
"WriteInt",
"(",
"int",
"(",
"val",
")",
")",
"\n",
"}"
] | // WriteInt32 - writes the signed 32 bit integer as a varint | [
"WriteInt32",
"-",
"writes",
"the",
"signed",
"32",
"bit",
"integer",
"as",
"a",
"varint"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/encoder.go#L776-L778 |
14,476 | ardielle/ardielle-go | tbin/encoder.go | WriteInt64 | func (enc *Encoder) WriteInt64(nn int64) error {
n := binary.PutVarint(enc.bytebuf, nn)
_, enc.err = enc.buf.Write(enc.bytebuf[:n])
return enc.err
} | go | func (enc *Encoder) WriteInt64(nn int64) error {
n := binary.PutVarint(enc.bytebuf, nn)
_, enc.err = enc.buf.Write(enc.bytebuf[:n])
return enc.err
} | [
"func",
"(",
"enc",
"*",
"Encoder",
")",
"WriteInt64",
"(",
"nn",
"int64",
")",
"error",
"{",
"n",
":=",
"binary",
".",
"PutVarint",
"(",
"enc",
".",
"bytebuf",
",",
"nn",
")",
"\n",
"_",
",",
"enc",
".",
"err",
"=",
"enc",
".",
"buf",
".",
"Write",
"(",
"enc",
".",
"bytebuf",
"[",
":",
"n",
"]",
")",
"\n",
"return",
"enc",
".",
"err",
"\n",
"}"
] | // WriteInt64 - writes the signed 64 bit integer as a varint | [
"WriteInt64",
"-",
"writes",
"the",
"signed",
"64",
"bit",
"integer",
"as",
"a",
"varint"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/encoder.go#L781-L785 |
14,477 | ardielle/ardielle-go | tbin/encoder.go | WriteFloat32 | func (enc *Encoder) WriteFloat32(n float32) error {
bits := math.Float32bits(n)
enc.err = enc.buf.WriteByte(byte(bits >> 24))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits >> 16))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits >> 8))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits))
}
}
}
return enc.err
} | go | func (enc *Encoder) WriteFloat32(n float32) error {
bits := math.Float32bits(n)
enc.err = enc.buf.WriteByte(byte(bits >> 24))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits >> 16))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits >> 8))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits))
}
}
}
return enc.err
} | [
"func",
"(",
"enc",
"*",
"Encoder",
")",
"WriteFloat32",
"(",
"n",
"float32",
")",
"error",
"{",
"bits",
":=",
"math",
".",
"Float32bits",
"(",
"n",
")",
"\n",
"enc",
".",
"err",
"=",
"enc",
".",
"buf",
".",
"WriteByte",
"(",
"byte",
"(",
"bits",
">>",
"24",
")",
")",
"\n",
"if",
"enc",
".",
"err",
"==",
"nil",
"{",
"enc",
".",
"err",
"=",
"enc",
".",
"buf",
".",
"WriteByte",
"(",
"byte",
"(",
"bits",
">>",
"16",
")",
")",
"\n",
"if",
"enc",
".",
"err",
"==",
"nil",
"{",
"enc",
".",
"err",
"=",
"enc",
".",
"buf",
".",
"WriteByte",
"(",
"byte",
"(",
"bits",
">>",
"8",
")",
")",
"\n",
"if",
"enc",
".",
"err",
"==",
"nil",
"{",
"enc",
".",
"err",
"=",
"enc",
".",
"buf",
".",
"WriteByte",
"(",
"byte",
"(",
"bits",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"enc",
".",
"err",
"\n",
"}"
] | // WriteFloat32 - writes the signed 32 bit float as a varint | [
"WriteFloat32",
"-",
"writes",
"the",
"signed",
"32",
"bit",
"float",
"as",
"a",
"varint"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/encoder.go#L788-L801 |
14,478 | ardielle/ardielle-go | tbin/encoder.go | WriteFloat64 | func (enc *Encoder) WriteFloat64(n float64) error {
bits := math.Float64bits(n)
enc.err = enc.buf.WriteByte(byte(bits >> 56))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits >> 48))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits >> 40))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits >> 32))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits >> 24))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits >> 16))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits >> 8))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits))
}
}
}
}
}
}
}
return enc.err
} | go | func (enc *Encoder) WriteFloat64(n float64) error {
bits := math.Float64bits(n)
enc.err = enc.buf.WriteByte(byte(bits >> 56))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits >> 48))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits >> 40))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits >> 32))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits >> 24))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits >> 16))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits >> 8))
if enc.err == nil {
enc.err = enc.buf.WriteByte(byte(bits))
}
}
}
}
}
}
}
return enc.err
} | [
"func",
"(",
"enc",
"*",
"Encoder",
")",
"WriteFloat64",
"(",
"n",
"float64",
")",
"error",
"{",
"bits",
":=",
"math",
".",
"Float64bits",
"(",
"n",
")",
"\n",
"enc",
".",
"err",
"=",
"enc",
".",
"buf",
".",
"WriteByte",
"(",
"byte",
"(",
"bits",
">>",
"56",
")",
")",
"\n",
"if",
"enc",
".",
"err",
"==",
"nil",
"{",
"enc",
".",
"err",
"=",
"enc",
".",
"buf",
".",
"WriteByte",
"(",
"byte",
"(",
"bits",
">>",
"48",
")",
")",
"\n",
"if",
"enc",
".",
"err",
"==",
"nil",
"{",
"enc",
".",
"err",
"=",
"enc",
".",
"buf",
".",
"WriteByte",
"(",
"byte",
"(",
"bits",
">>",
"40",
")",
")",
"\n",
"if",
"enc",
".",
"err",
"==",
"nil",
"{",
"enc",
".",
"err",
"=",
"enc",
".",
"buf",
".",
"WriteByte",
"(",
"byte",
"(",
"bits",
">>",
"32",
")",
")",
"\n",
"if",
"enc",
".",
"err",
"==",
"nil",
"{",
"enc",
".",
"err",
"=",
"enc",
".",
"buf",
".",
"WriteByte",
"(",
"byte",
"(",
"bits",
">>",
"24",
")",
")",
"\n",
"if",
"enc",
".",
"err",
"==",
"nil",
"{",
"enc",
".",
"err",
"=",
"enc",
".",
"buf",
".",
"WriteByte",
"(",
"byte",
"(",
"bits",
">>",
"16",
")",
")",
"\n",
"if",
"enc",
".",
"err",
"==",
"nil",
"{",
"enc",
".",
"err",
"=",
"enc",
".",
"buf",
".",
"WriteByte",
"(",
"byte",
"(",
"bits",
">>",
"8",
")",
")",
"\n",
"if",
"enc",
".",
"err",
"==",
"nil",
"{",
"enc",
".",
"err",
"=",
"enc",
".",
"buf",
".",
"WriteByte",
"(",
"byte",
"(",
"bits",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"enc",
".",
"err",
"\n",
"}"
] | // WriteFloat64 - writes the signed 64 bit float as a varint | [
"WriteFloat64",
"-",
"writes",
"the",
"signed",
"64",
"bit",
"float",
"as",
"a",
"varint"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/encoder.go#L804-L829 |
14,479 | ardielle/ardielle-go | rdl/uuid.go | Equal | func (u UUID) Equal(another UUID) bool {
for i, b := range u {
if b != another[i] {
return false
}
}
return true
} | go | func (u UUID) Equal(another UUID) bool {
for i, b := range u {
if b != another[i] {
return false
}
}
return true
} | [
"func",
"(",
"u",
"UUID",
")",
"Equal",
"(",
"another",
"UUID",
")",
"bool",
"{",
"for",
"i",
",",
"b",
":=",
"range",
"u",
"{",
"if",
"b",
"!=",
"another",
"[",
"i",
"]",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"true",
"\n",
"}"
] | //
// Equal - return true if another UUID is equal to this one
// | [
"Equal",
"-",
"return",
"true",
"if",
"another",
"UUID",
"is",
"equal",
"to",
"this",
"one"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/uuid.go#L21-L28 |
14,480 | ardielle/ardielle-go | rdl/uuid.go | ParseUUID | func ParseUUID(s string) UUID {
if len(s) == 36+9 {
if strings.ToLower(s[:9]) != "urn:uuid:" {
return nil
}
s = s[9:]
} else if len(s) != 36 {
return nil
}
if s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-' {
return nil
}
uuid := make([]byte, 16)
for i, x := range []int{
0, 2, 4, 6,
9, 11,
14, 16,
19, 21,
24, 26, 28, 30, 32, 34} {
var v int64
var err error
if v, err = strconv.ParseInt(s[x:x+2], 16, 16); err != nil {
return nil
}
uuid[i] = byte(v)
}
return uuid
} | go | func ParseUUID(s string) UUID {
if len(s) == 36+9 {
if strings.ToLower(s[:9]) != "urn:uuid:" {
return nil
}
s = s[9:]
} else if len(s) != 36 {
return nil
}
if s[8] != '-' || s[13] != '-' || s[18] != '-' || s[23] != '-' {
return nil
}
uuid := make([]byte, 16)
for i, x := range []int{
0, 2, 4, 6,
9, 11,
14, 16,
19, 21,
24, 26, 28, 30, 32, 34} {
var v int64
var err error
if v, err = strconv.ParseInt(s[x:x+2], 16, 16); err != nil {
return nil
}
uuid[i] = byte(v)
}
return uuid
} | [
"func",
"ParseUUID",
"(",
"s",
"string",
")",
"UUID",
"{",
"if",
"len",
"(",
"s",
")",
"==",
"36",
"+",
"9",
"{",
"if",
"strings",
".",
"ToLower",
"(",
"s",
"[",
":",
"9",
"]",
")",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"s",
"=",
"s",
"[",
"9",
":",
"]",
"\n",
"}",
"else",
"if",
"len",
"(",
"s",
")",
"!=",
"36",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"if",
"s",
"[",
"8",
"]",
"!=",
"'-'",
"||",
"s",
"[",
"13",
"]",
"!=",
"'-'",
"||",
"s",
"[",
"18",
"]",
"!=",
"'-'",
"||",
"s",
"[",
"23",
"]",
"!=",
"'-'",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"uuid",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"16",
")",
"\n",
"for",
"i",
",",
"x",
":=",
"range",
"[",
"]",
"int",
"{",
"0",
",",
"2",
",",
"4",
",",
"6",
",",
"9",
",",
"11",
",",
"14",
",",
"16",
",",
"19",
",",
"21",
",",
"24",
",",
"26",
",",
"28",
",",
"30",
",",
"32",
",",
"34",
"}",
"{",
"var",
"v",
"int64",
"\n",
"var",
"err",
"error",
"\n",
"if",
"v",
",",
"err",
"=",
"strconv",
".",
"ParseInt",
"(",
"s",
"[",
"x",
":",
"x",
"+",
"2",
"]",
",",
"16",
",",
"16",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"uuid",
"[",
"i",
"]",
"=",
"byte",
"(",
"v",
")",
"\n",
"}",
"\n",
"return",
"uuid",
"\n",
"}"
] | //
// ParseUUID - parse the string to produce a UUID
// | [
"ParseUUID",
"-",
"parse",
"the",
"string",
"to",
"produce",
"a",
"UUID"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/uuid.go#L33-L60 |
14,481 | ardielle/ardielle-go | rdl/uuid.go | String | func (u UUID) String() string {
if u == nil || len(u) != 16 {
return "00000000-0000-0000-0000-000000000000"
}
b := []byte(u)
return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x", b[:4], b[4:6], b[6:8], b[8:10], b[10:])
} | go | func (u UUID) String() string {
if u == nil || len(u) != 16 {
return "00000000-0000-0000-0000-000000000000"
}
b := []byte(u)
return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x", b[:4], b[4:6], b[6:8], b[8:10], b[10:])
} | [
"func",
"(",
"u",
"UUID",
")",
"String",
"(",
")",
"string",
"{",
"if",
"u",
"==",
"nil",
"||",
"len",
"(",
"u",
")",
"!=",
"16",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"b",
":=",
"[",
"]",
"byte",
"(",
"u",
")",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"b",
"[",
":",
"4",
"]",
",",
"b",
"[",
"4",
":",
"6",
"]",
",",
"b",
"[",
"6",
":",
"8",
"]",
",",
"b",
"[",
"8",
":",
"10",
"]",
",",
"b",
"[",
"10",
":",
"]",
")",
"\n",
"}"
] | //
// String produces the standard "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" representaion of a UUID.
// | [
"String",
"produces",
"the",
"standard",
"xxxxxxxx",
"-",
"xxxx",
"-",
"xxxx",
"-",
"xxxx",
"-",
"xxxxxxxxxxxx",
"representaion",
"of",
"a",
"UUID",
"."
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/uuid.go#L75-L81 |
14,482 | ardielle/ardielle-go | rdl/uuid.go | UnmarshalJSON | func (u *UUID) UnmarshalJSON(b []byte) error {
var j string
err := json.Unmarshal(b, &j)
if err == nil {
v := ParseUUID(string(j))
if v != nil {
*u = v
} else {
err = fmt.Errorf("Bad UUID: %v", string(j))
}
}
return err
} | go | func (u *UUID) UnmarshalJSON(b []byte) error {
var j string
err := json.Unmarshal(b, &j)
if err == nil {
v := ParseUUID(string(j))
if v != nil {
*u = v
} else {
err = fmt.Errorf("Bad UUID: %v", string(j))
}
}
return err
} | [
"func",
"(",
"u",
"*",
"UUID",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"j",
"string",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"j",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"v",
":=",
"ParseUUID",
"(",
"string",
"(",
"j",
")",
")",
"\n",
"if",
"v",
"!=",
"nil",
"{",
"*",
"u",
"=",
"v",
"\n",
"}",
"else",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"j",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON parses a JSON string in standard UUID format.
// | [
"UnmarshalJSON",
"parses",
"a",
"JSON",
"string",
"in",
"standard",
"UUID",
"format",
"."
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/uuid.go#L93-L105 |
14,483 | ardielle/ardielle-go | gen/gomodel/gomodel.go | Generate | func Generate(schema *rdl.Schema, params *GeneratorParams) error {
name := strings.ToLower(string(schema.Name))
outdir := params.Outdir
if outdir == "" {
outdir = "."
name = name + "_model.go"
} else if strings.HasSuffix(outdir, ".go") {
name = filepath.Base(outdir)
outdir = filepath.Dir(outdir)
} else {
name = name + "_model.go"
}
err := os.MkdirAll(outdir, 0755)
if err != nil {
return err
}
filepath := outdir + "/" + name
out, file, _, err := genutil.OutputWriter(filepath, "", ".go")
if err != nil {
return err
}
if file != nil {
defer func() {
file.Close()
err := goFmt(filepath)
if err != nil {
fmt.Println("Warning: could not format go code:", err)
}
}()
}
gen := &modelGenerator{
registry: rdl.NewTypeRegistry(schema),
schema: schema,
writer: out,
librdl: params.LibRdl,
prefixEnums: params.PrefixEnums,
precise: params.PreciseTypes,
err: nil,
untaggedUnions: params.UntaggedUnions,
ns: params.Namespace,
rdl: schema.Name == "rdl",
}
gen.emitHeader(params.Banner)
if gen.err == nil {
for _, t := range schema.Types {
gen.emitType(t)
}
}
out.Flush()
if gen.err == nil {
if params.GenerateSchema {
gen.err = GenerateGoSchema(params.Banner, schema, outdir, params.Namespace, params.LibRdl, params.PrefixEnums)
}
}
return gen.err
} | go | func Generate(schema *rdl.Schema, params *GeneratorParams) error {
name := strings.ToLower(string(schema.Name))
outdir := params.Outdir
if outdir == "" {
outdir = "."
name = name + "_model.go"
} else if strings.HasSuffix(outdir, ".go") {
name = filepath.Base(outdir)
outdir = filepath.Dir(outdir)
} else {
name = name + "_model.go"
}
err := os.MkdirAll(outdir, 0755)
if err != nil {
return err
}
filepath := outdir + "/" + name
out, file, _, err := genutil.OutputWriter(filepath, "", ".go")
if err != nil {
return err
}
if file != nil {
defer func() {
file.Close()
err := goFmt(filepath)
if err != nil {
fmt.Println("Warning: could not format go code:", err)
}
}()
}
gen := &modelGenerator{
registry: rdl.NewTypeRegistry(schema),
schema: schema,
writer: out,
librdl: params.LibRdl,
prefixEnums: params.PrefixEnums,
precise: params.PreciseTypes,
err: nil,
untaggedUnions: params.UntaggedUnions,
ns: params.Namespace,
rdl: schema.Name == "rdl",
}
gen.emitHeader(params.Banner)
if gen.err == nil {
for _, t := range schema.Types {
gen.emitType(t)
}
}
out.Flush()
if gen.err == nil {
if params.GenerateSchema {
gen.err = GenerateGoSchema(params.Banner, schema, outdir, params.Namespace, params.LibRdl, params.PrefixEnums)
}
}
return gen.err
} | [
"func",
"Generate",
"(",
"schema",
"*",
"rdl",
".",
"Schema",
",",
"params",
"*",
"GeneratorParams",
")",
"error",
"{",
"name",
":=",
"strings",
".",
"ToLower",
"(",
"string",
"(",
"schema",
".",
"Name",
")",
")",
"\n",
"outdir",
":=",
"params",
".",
"Outdir",
"\n",
"if",
"outdir",
"==",
"\"",
"\"",
"{",
"outdir",
"=",
"\"",
"\"",
"\n",
"name",
"=",
"name",
"+",
"\"",
"\"",
"\n",
"}",
"else",
"if",
"strings",
".",
"HasSuffix",
"(",
"outdir",
",",
"\"",
"\"",
")",
"{",
"name",
"=",
"filepath",
".",
"Base",
"(",
"outdir",
")",
"\n",
"outdir",
"=",
"filepath",
".",
"Dir",
"(",
"outdir",
")",
"\n",
"}",
"else",
"{",
"name",
"=",
"name",
"+",
"\"",
"\"",
"\n",
"}",
"\n",
"err",
":=",
"os",
".",
"MkdirAll",
"(",
"outdir",
",",
"0755",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"filepath",
":=",
"outdir",
"+",
"\"",
"\"",
"+",
"name",
"\n",
"out",
",",
"file",
",",
"_",
",",
"err",
":=",
"genutil",
".",
"OutputWriter",
"(",
"filepath",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"file",
"!=",
"nil",
"{",
"defer",
"func",
"(",
")",
"{",
"file",
".",
"Close",
"(",
")",
"\n",
"err",
":=",
"goFmt",
"(",
"filepath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"gen",
":=",
"&",
"modelGenerator",
"{",
"registry",
":",
"rdl",
".",
"NewTypeRegistry",
"(",
"schema",
")",
",",
"schema",
":",
"schema",
",",
"writer",
":",
"out",
",",
"librdl",
":",
"params",
".",
"LibRdl",
",",
"prefixEnums",
":",
"params",
".",
"PrefixEnums",
",",
"precise",
":",
"params",
".",
"PreciseTypes",
",",
"err",
":",
"nil",
",",
"untaggedUnions",
":",
"params",
".",
"UntaggedUnions",
",",
"ns",
":",
"params",
".",
"Namespace",
",",
"rdl",
":",
"schema",
".",
"Name",
"==",
"\"",
"\"",
",",
"}",
"\n",
"gen",
".",
"emitHeader",
"(",
"params",
".",
"Banner",
")",
"\n",
"if",
"gen",
".",
"err",
"==",
"nil",
"{",
"for",
"_",
",",
"t",
":=",
"range",
"schema",
".",
"Types",
"{",
"gen",
".",
"emitType",
"(",
"t",
")",
"\n",
"}",
"\n",
"}",
"\n",
"out",
".",
"Flush",
"(",
")",
"\n",
"if",
"gen",
".",
"err",
"==",
"nil",
"{",
"if",
"params",
".",
"GenerateSchema",
"{",
"gen",
".",
"err",
"=",
"GenerateGoSchema",
"(",
"params",
".",
"Banner",
",",
"schema",
",",
"outdir",
",",
"params",
".",
"Namespace",
",",
"params",
".",
"LibRdl",
",",
"params",
".",
"PrefixEnums",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"gen",
".",
"err",
"\n",
"}"
] | // GenerateGoModel generates the model code for the types defined in the RDL schema. | [
"GenerateGoModel",
"generates",
"the",
"model",
"code",
"for",
"the",
"types",
"defined",
"in",
"the",
"RDL",
"schema",
"."
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/gen/gomodel/gomodel.go#L51-L106 |
14,484 | ardielle/ardielle-go | rdl/util.go | ExportToJSON | func ExportToJSON(schema *Schema, outpath string) error {
out, file, _, err := outputWriter(outpath, string(schema.Name), ".json")
if err != nil {
return err
}
err = WriteJSON(schema, out)
if file != nil {
file.Close()
}
return err
} | go | func ExportToJSON(schema *Schema, outpath string) error {
out, file, _, err := outputWriter(outpath, string(schema.Name), ".json")
if err != nil {
return err
}
err = WriteJSON(schema, out)
if file != nil {
file.Close()
}
return err
} | [
"func",
"ExportToJSON",
"(",
"schema",
"*",
"Schema",
",",
"outpath",
"string",
")",
"error",
"{",
"out",
",",
"file",
",",
"_",
",",
"err",
":=",
"outputWriter",
"(",
"outpath",
",",
"string",
"(",
"schema",
".",
"Name",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"WriteJSON",
"(",
"schema",
",",
"out",
")",
"\n",
"if",
"file",
"!=",
"nil",
"{",
"file",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // ExportToJSON - v2 schema export to JSON. If out is empty, dump to stdout. | [
"ExportToJSON",
"-",
"v2",
"schema",
"export",
"to",
"JSON",
".",
"If",
"out",
"is",
"empty",
"dump",
"to",
"stdout",
"."
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/util.go#L452-L462 |
14,485 | ardielle/ardielle-go | rdl/util.go | WriteJSON | func WriteJSON(schema *Schema, out *bufio.Writer) error {
j, err := json.MarshalIndent(schema, "", " ")
if err != nil {
return err
}
fmt.Fprintf(out, "%s", j)
out.Flush()
return nil
} | go | func WriteJSON(schema *Schema, out *bufio.Writer) error {
j, err := json.MarshalIndent(schema, "", " ")
if err != nil {
return err
}
fmt.Fprintf(out, "%s", j)
out.Flush()
return nil
} | [
"func",
"WriteJSON",
"(",
"schema",
"*",
"Schema",
",",
"out",
"*",
"bufio",
".",
"Writer",
")",
"error",
"{",
"j",
",",
"err",
":=",
"json",
".",
"MarshalIndent",
"(",
"schema",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintf",
"(",
"out",
",",
"\"",
"\"",
",",
"j",
")",
"\n",
"out",
".",
"Flush",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // WriteJSON - v2 schema export to JSON | [
"WriteJSON",
"-",
"v2",
"schema",
"export",
"to",
"JSON"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/util.go#L465-L473 |
14,486 | ardielle/ardielle-go | rdl/types.go | TypeInfo | func TypeInfo(t *Type) (TypeName, TypeRef, string) {
switch t.Variant {
case TypeVariantAliasTypeDef:
td := t.AliasTypeDef
return td.Name, td.Type, td.Comment
case TypeVariantStringTypeDef:
td := t.StringTypeDef
return td.Name, td.Type, td.Comment
case TypeVariantNumberTypeDef:
td := t.NumberTypeDef
return td.Name, td.Type, td.Comment
case TypeVariantArrayTypeDef:
td := t.ArrayTypeDef
return td.Name, td.Type, td.Comment
case TypeVariantMapTypeDef:
td := t.MapTypeDef
return td.Name, td.Type, td.Comment
case TypeVariantStructTypeDef:
td := t.StructTypeDef
return td.Name, td.Type, td.Comment
case TypeVariantBytesTypeDef:
td := t.BytesTypeDef
return td.Name, td.Type, td.Comment
case TypeVariantEnumTypeDef:
td := t.EnumTypeDef
return td.Name, td.Type, td.Comment
case TypeVariantUnionTypeDef:
td := t.UnionTypeDef
return td.Name, td.Type, td.Comment
case TypeVariantBaseType:
td := t.BaseType
s := namesBaseType[int(*td)]
return TypeName(s), TypeRef(s), ""
default:
panic("whoops")
}
} | go | func TypeInfo(t *Type) (TypeName, TypeRef, string) {
switch t.Variant {
case TypeVariantAliasTypeDef:
td := t.AliasTypeDef
return td.Name, td.Type, td.Comment
case TypeVariantStringTypeDef:
td := t.StringTypeDef
return td.Name, td.Type, td.Comment
case TypeVariantNumberTypeDef:
td := t.NumberTypeDef
return td.Name, td.Type, td.Comment
case TypeVariantArrayTypeDef:
td := t.ArrayTypeDef
return td.Name, td.Type, td.Comment
case TypeVariantMapTypeDef:
td := t.MapTypeDef
return td.Name, td.Type, td.Comment
case TypeVariantStructTypeDef:
td := t.StructTypeDef
return td.Name, td.Type, td.Comment
case TypeVariantBytesTypeDef:
td := t.BytesTypeDef
return td.Name, td.Type, td.Comment
case TypeVariantEnumTypeDef:
td := t.EnumTypeDef
return td.Name, td.Type, td.Comment
case TypeVariantUnionTypeDef:
td := t.UnionTypeDef
return td.Name, td.Type, td.Comment
case TypeVariantBaseType:
td := t.BaseType
s := namesBaseType[int(*td)]
return TypeName(s), TypeRef(s), ""
default:
panic("whoops")
}
} | [
"func",
"TypeInfo",
"(",
"t",
"*",
"Type",
")",
"(",
"TypeName",
",",
"TypeRef",
",",
"string",
")",
"{",
"switch",
"t",
".",
"Variant",
"{",
"case",
"TypeVariantAliasTypeDef",
":",
"td",
":=",
"t",
".",
"AliasTypeDef",
"\n",
"return",
"td",
".",
"Name",
",",
"td",
".",
"Type",
",",
"td",
".",
"Comment",
"\n",
"case",
"TypeVariantStringTypeDef",
":",
"td",
":=",
"t",
".",
"StringTypeDef",
"\n",
"return",
"td",
".",
"Name",
",",
"td",
".",
"Type",
",",
"td",
".",
"Comment",
"\n",
"case",
"TypeVariantNumberTypeDef",
":",
"td",
":=",
"t",
".",
"NumberTypeDef",
"\n",
"return",
"td",
".",
"Name",
",",
"td",
".",
"Type",
",",
"td",
".",
"Comment",
"\n",
"case",
"TypeVariantArrayTypeDef",
":",
"td",
":=",
"t",
".",
"ArrayTypeDef",
"\n",
"return",
"td",
".",
"Name",
",",
"td",
".",
"Type",
",",
"td",
".",
"Comment",
"\n",
"case",
"TypeVariantMapTypeDef",
":",
"td",
":=",
"t",
".",
"MapTypeDef",
"\n",
"return",
"td",
".",
"Name",
",",
"td",
".",
"Type",
",",
"td",
".",
"Comment",
"\n",
"case",
"TypeVariantStructTypeDef",
":",
"td",
":=",
"t",
".",
"StructTypeDef",
"\n",
"return",
"td",
".",
"Name",
",",
"td",
".",
"Type",
",",
"td",
".",
"Comment",
"\n",
"case",
"TypeVariantBytesTypeDef",
":",
"td",
":=",
"t",
".",
"BytesTypeDef",
"\n",
"return",
"td",
".",
"Name",
",",
"td",
".",
"Type",
",",
"td",
".",
"Comment",
"\n",
"case",
"TypeVariantEnumTypeDef",
":",
"td",
":=",
"t",
".",
"EnumTypeDef",
"\n",
"return",
"td",
".",
"Name",
",",
"td",
".",
"Type",
",",
"td",
".",
"Comment",
"\n",
"case",
"TypeVariantUnionTypeDef",
":",
"td",
":=",
"t",
".",
"UnionTypeDef",
"\n",
"return",
"td",
".",
"Name",
",",
"td",
".",
"Type",
",",
"td",
".",
"Comment",
"\n",
"case",
"TypeVariantBaseType",
":",
"td",
":=",
"t",
".",
"BaseType",
"\n",
"s",
":=",
"namesBaseType",
"[",
"int",
"(",
"*",
"td",
")",
"]",
"\n",
"return",
"TypeName",
"(",
"s",
")",
",",
"TypeRef",
"(",
"s",
")",
",",
"\"",
"\"",
"\n",
"default",
":",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] | // TypeInfo returns common info that every type shares. | [
"TypeInfo",
"returns",
"common",
"info",
"that",
"every",
"type",
"shares",
"."
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/types.go#L78-L114 |
14,487 | ardielle/ardielle-go | rdl/types.go | BaseType | func (reg *typeRegistry) BaseType(t *Type) BaseType {
var bt BaseType
if t == nil {
return bt //the zero value
}
tName, tType, _ := TypeInfo(t)
for TypeRef(tName) != tType {
tt := reg.FindType(tType)
if tt == nil {
return bt //the zero value
}
tName, tType, _ = TypeInfo(tt)
}
n, _ := reg.baseTypes[string(tName)]
return n
} | go | func (reg *typeRegistry) BaseType(t *Type) BaseType {
var bt BaseType
if t == nil {
return bt //the zero value
}
tName, tType, _ := TypeInfo(t)
for TypeRef(tName) != tType {
tt := reg.FindType(tType)
if tt == nil {
return bt //the zero value
}
tName, tType, _ = TypeInfo(tt)
}
n, _ := reg.baseTypes[string(tName)]
return n
} | [
"func",
"(",
"reg",
"*",
"typeRegistry",
")",
"BaseType",
"(",
"t",
"*",
"Type",
")",
"BaseType",
"{",
"var",
"bt",
"BaseType",
"\n",
"if",
"t",
"==",
"nil",
"{",
"return",
"bt",
"//the zero value",
"\n",
"}",
"\n",
"tName",
",",
"tType",
",",
"_",
":=",
"TypeInfo",
"(",
"t",
")",
"\n",
"for",
"TypeRef",
"(",
"tName",
")",
"!=",
"tType",
"{",
"tt",
":=",
"reg",
".",
"FindType",
"(",
"tType",
")",
"\n",
"if",
"tt",
"==",
"nil",
"{",
"return",
"bt",
"//the zero value",
"\n",
"}",
"\n",
"tName",
",",
"tType",
",",
"_",
"=",
"TypeInfo",
"(",
"tt",
")",
"\n",
"}",
"\n",
"n",
",",
"_",
":=",
"reg",
".",
"baseTypes",
"[",
"string",
"(",
"tName",
")",
"]",
"\n",
"return",
"n",
"\n",
"}"
] | //
// BaseTypeName returns the name of the RDL base type of the type specified by the given name
// | [
"BaseTypeName",
"returns",
"the",
"name",
"of",
"the",
"RDL",
"base",
"type",
"of",
"the",
"type",
"specified",
"by",
"the",
"given",
"name"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/types.go#L167-L182 |
14,488 | ardielle/ardielle-go | rdl/types.go | IsArrayType | func (reg *typeRegistry) IsArrayType(t *Type) bool {
return reg.BaseType(t) == BaseTypeArray
} | go | func (reg *typeRegistry) IsArrayType(t *Type) bool {
return reg.BaseType(t) == BaseTypeArray
} | [
"func",
"(",
"reg",
"*",
"typeRegistry",
")",
"IsArrayType",
"(",
"t",
"*",
"Type",
")",
"bool",
"{",
"return",
"reg",
".",
"BaseType",
"(",
"t",
")",
"==",
"BaseTypeArray",
"\n",
"}"
] | // IsArrayType returns true if the type has an Array base type | [
"IsArrayType",
"returns",
"true",
"if",
"the",
"type",
"has",
"an",
"Array",
"base",
"type"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/types.go#L198-L200 |
14,489 | ardielle/ardielle-go | rdl/types.go | IsArrayTypeName | func (reg *typeRegistry) IsArrayTypeName(tn TypeRef) bool {
t := reg.FindType(tn)
if t == nil {
return false
}
return reg.IsArrayType(t)
} | go | func (reg *typeRegistry) IsArrayTypeName(tn TypeRef) bool {
t := reg.FindType(tn)
if t == nil {
return false
}
return reg.IsArrayType(t)
} | [
"func",
"(",
"reg",
"*",
"typeRegistry",
")",
"IsArrayTypeName",
"(",
"tn",
"TypeRef",
")",
"bool",
"{",
"t",
":=",
"reg",
".",
"FindType",
"(",
"tn",
")",
"\n",
"if",
"t",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"reg",
".",
"IsArrayType",
"(",
"t",
")",
"\n",
"}"
] | // IsArrayTypeName returns true if the type name identifies a type with an Array base type | [
"IsArrayTypeName",
"returns",
"true",
"if",
"the",
"type",
"name",
"identifies",
"a",
"type",
"with",
"an",
"Array",
"base",
"type"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/types.go#L203-L209 |
14,490 | ardielle/ardielle-go | rdl/types.go | IsBaseTypeName | func (reg *typeRegistry) IsBaseTypeName(name TypeRef) bool {
if name != "" {
lower := strings.ToLower(string(name))
for _, n := range namesBaseType {
if lower == strings.ToLower(n) {
return true
}
}
}
return false
} | go | func (reg *typeRegistry) IsBaseTypeName(name TypeRef) bool {
if name != "" {
lower := strings.ToLower(string(name))
for _, n := range namesBaseType {
if lower == strings.ToLower(n) {
return true
}
}
}
return false
} | [
"func",
"(",
"reg",
"*",
"typeRegistry",
")",
"IsBaseTypeName",
"(",
"name",
"TypeRef",
")",
"bool",
"{",
"if",
"name",
"!=",
"\"",
"\"",
"{",
"lower",
":=",
"strings",
".",
"ToLower",
"(",
"string",
"(",
"name",
")",
")",
"\n",
"for",
"_",
",",
"n",
":=",
"range",
"namesBaseType",
"{",
"if",
"lower",
"==",
"strings",
".",
"ToLower",
"(",
"n",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // IsBaseTypeName returns true if the type name is one of the base types | [
"IsBaseTypeName",
"returns",
"true",
"if",
"the",
"type",
"name",
"is",
"one",
"of",
"the",
"base",
"types"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/types.go#L212-L222 |
14,491 | ardielle/ardielle-go | rdl/types.go | IsStringType | func (reg *typeRegistry) IsStringType(t *Type) bool {
return reg.BaseType(t) == BaseTypeString
} | go | func (reg *typeRegistry) IsStringType(t *Type) bool {
return reg.BaseType(t) == BaseTypeString
} | [
"func",
"(",
"reg",
"*",
"typeRegistry",
")",
"IsStringType",
"(",
"t",
"*",
"Type",
")",
"bool",
"{",
"return",
"reg",
".",
"BaseType",
"(",
"t",
")",
"==",
"BaseTypeString",
"\n",
"}"
] | // IsStringType returns true if the type has a String base type | [
"IsStringType",
"returns",
"true",
"if",
"the",
"type",
"has",
"a",
"String",
"base",
"type"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/types.go#L225-L227 |
14,492 | ardielle/ardielle-go | rdl/types.go | IsStringTypeName | func (reg *typeRegistry) IsStringTypeName(tn TypeRef) bool {
t := reg.FindType(tn)
if t == nil {
return false
}
return reg.IsStringType(t)
} | go | func (reg *typeRegistry) IsStringTypeName(tn TypeRef) bool {
t := reg.FindType(tn)
if t == nil {
return false
}
return reg.IsStringType(t)
} | [
"func",
"(",
"reg",
"*",
"typeRegistry",
")",
"IsStringTypeName",
"(",
"tn",
"TypeRef",
")",
"bool",
"{",
"t",
":=",
"reg",
".",
"FindType",
"(",
"tn",
")",
"\n",
"if",
"t",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"reg",
".",
"IsStringType",
"(",
"t",
")",
"\n",
"}"
] | // IsStringTypeName returns true if the type with the given name has a String base type | [
"IsStringTypeName",
"returns",
"true",
"if",
"the",
"type",
"with",
"the",
"given",
"name",
"has",
"a",
"String",
"base",
"type"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/types.go#L230-L236 |
14,493 | ardielle/ardielle-go | rdl/timestamp.go | String | func (ts Timestamp) String() string {
if ts.IsZero() {
return ""
}
return fmt.Sprintf("%d-%02d-%02dT%02d:%02d:%02d.%03dZ",
ts.Year(), ts.Month(), ts.Day(),
ts.Hour(), ts.Minute(), ts.Second(), ts.Nanosecond()/1000000)
} | go | func (ts Timestamp) String() string {
if ts.IsZero() {
return ""
}
return fmt.Sprintf("%d-%02d-%02dT%02d:%02d:%02d.%03dZ",
ts.Year(), ts.Month(), ts.Day(),
ts.Hour(), ts.Minute(), ts.Second(), ts.Nanosecond()/1000000)
} | [
"func",
"(",
"ts",
"Timestamp",
")",
"String",
"(",
")",
"string",
"{",
"if",
"ts",
".",
"IsZero",
"(",
")",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"ts",
".",
"Year",
"(",
")",
",",
"ts",
".",
"Month",
"(",
")",
",",
"ts",
".",
"Day",
"(",
")",
",",
"ts",
".",
"Hour",
"(",
")",
",",
"ts",
".",
"Minute",
"(",
")",
",",
"ts",
".",
"Second",
"(",
")",
",",
"ts",
".",
"Nanosecond",
"(",
")",
"/",
"1000000",
")",
"\n",
"}"
] | //
// String - Show the Timestamp in RFC3339 format, UTC, millisecond resolution
// | [
"String",
"-",
"Show",
"the",
"Timestamp",
"in",
"RFC3339",
"format",
"UTC",
"millisecond",
"resolution"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/timestamp.go#L33-L40 |
14,494 | ardielle/ardielle-go | rdl/timestamp.go | UnmarshalJSON | func (ts *Timestamp) UnmarshalJSON(b []byte) error {
var j string
err := json.Unmarshal(b, &j)
if err == nil {
tsp, err := TimestampParse(string(j))
if err == nil {
*ts = tsp
}
}
return err
} | go | func (ts *Timestamp) UnmarshalJSON(b []byte) error {
var j string
err := json.Unmarshal(b, &j)
if err == nil {
tsp, err := TimestampParse(string(j))
if err == nil {
*ts = tsp
}
}
return err
} | [
"func",
"(",
"ts",
"*",
"Timestamp",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"j",
"string",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"j",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"tsp",
",",
"err",
":=",
"TimestampParse",
"(",
"string",
"(",
"j",
")",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"*",
"ts",
"=",
"tsp",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | //
// UnmarshalJSON - parse a Timestamp from a JSON string
// | [
"UnmarshalJSON",
"-",
"parse",
"a",
"Timestamp",
"from",
"a",
"JSON",
"string"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/timestamp.go#L52-L62 |
14,495 | ardielle/ardielle-go | rdl/timestamp.go | Equal | func (ts Timestamp) Equal(ts2 Timestamp) bool {
return ts.Millis() == ts2.Millis()
} | go | func (ts Timestamp) Equal(ts2 Timestamp) bool {
return ts.Millis() == ts2.Millis()
} | [
"func",
"(",
"ts",
"Timestamp",
")",
"Equal",
"(",
"ts2",
"Timestamp",
")",
"bool",
"{",
"return",
"ts",
".",
"Millis",
"(",
")",
"==",
"ts2",
".",
"Millis",
"(",
")",
"\n",
"}"
] | //
// Equal - returns true if two timestamps have the same value, to millisecond accuracy
// The JSON representation of dates is only millisecond resolution.
// | [
"Equal",
"-",
"returns",
"true",
"if",
"two",
"timestamps",
"have",
"the",
"same",
"value",
"to",
"millisecond",
"accuracy",
"The",
"JSON",
"representation",
"of",
"dates",
"is",
"only",
"millisecond",
"resolution",
"."
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/timestamp.go#L94-L96 |
14,496 | ardielle/ardielle-go | rdl/timestamp.go | TimestampParse | func TimestampParse(s string) (Timestamp, error) {
layout := "2006-01-02T15:04:05.999Z"
t, e := time.Parse(layout, s)
if e != nil {
if strings.HasSuffix(s, "+00:00") || strings.HasSuffix(s, "-00:00") {
t, e = time.Parse(layout, s[:len(s)-6]+"Z")
} else if strings.HasSuffix(s, "+0000") || strings.HasSuffix(s, "-0000") {
t, e = time.Parse(layout, s[:len(s)-5]+"Z")
}
if e != nil {
var ts Timestamp
return ts, e
}
}
return Timestamp{t}, nil
} | go | func TimestampParse(s string) (Timestamp, error) {
layout := "2006-01-02T15:04:05.999Z"
t, e := time.Parse(layout, s)
if e != nil {
if strings.HasSuffix(s, "+00:00") || strings.HasSuffix(s, "-00:00") {
t, e = time.Parse(layout, s[:len(s)-6]+"Z")
} else if strings.HasSuffix(s, "+0000") || strings.HasSuffix(s, "-0000") {
t, e = time.Parse(layout, s[:len(s)-5]+"Z")
}
if e != nil {
var ts Timestamp
return ts, e
}
}
return Timestamp{t}, nil
} | [
"func",
"TimestampParse",
"(",
"s",
"string",
")",
"(",
"Timestamp",
",",
"error",
")",
"{",
"layout",
":=",
"\"",
"\"",
"\n",
"t",
",",
"e",
":=",
"time",
".",
"Parse",
"(",
"layout",
",",
"s",
")",
"\n",
"if",
"e",
"!=",
"nil",
"{",
"if",
"strings",
".",
"HasSuffix",
"(",
"s",
",",
"\"",
"\"",
")",
"||",
"strings",
".",
"HasSuffix",
"(",
"s",
",",
"\"",
"\"",
")",
"{",
"t",
",",
"e",
"=",
"time",
".",
"Parse",
"(",
"layout",
",",
"s",
"[",
":",
"len",
"(",
"s",
")",
"-",
"6",
"]",
"+",
"\"",
"\"",
")",
"\n",
"}",
"else",
"if",
"strings",
".",
"HasSuffix",
"(",
"s",
",",
"\"",
"\"",
")",
"||",
"strings",
".",
"HasSuffix",
"(",
"s",
",",
"\"",
"\"",
")",
"{",
"t",
",",
"e",
"=",
"time",
".",
"Parse",
"(",
"layout",
",",
"s",
"[",
":",
"len",
"(",
"s",
")",
"-",
"5",
"]",
"+",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"e",
"!=",
"nil",
"{",
"var",
"ts",
"Timestamp",
"\n",
"return",
"ts",
",",
"e",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"Timestamp",
"{",
"t",
"}",
",",
"nil",
"\n",
"}"
] | // TimestampParse - parses the string and returns a Timestamp, or error
// | [
"TimestampParse",
"-",
"parses",
"the",
"string",
"and",
"returns",
"a",
"Timestamp",
"or",
"error"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/timestamp.go#L108-L123 |
14,497 | ardielle/ardielle-go | rdl/timestamp.go | TimestampFromEpoch | func TimestampFromEpoch(secondsSinceEpoch float64) Timestamp {
sec := int64(secondsSinceEpoch)
nsec := int64((secondsSinceEpoch - float64(sec) + 0.0000005) * 1000000000.0)
return Timestamp{time.Unix(sec, nsec).UTC()}
} | go | func TimestampFromEpoch(secondsSinceEpoch float64) Timestamp {
sec := int64(secondsSinceEpoch)
nsec := int64((secondsSinceEpoch - float64(sec) + 0.0000005) * 1000000000.0)
return Timestamp{time.Unix(sec, nsec).UTC()}
} | [
"func",
"TimestampFromEpoch",
"(",
"secondsSinceEpoch",
"float64",
")",
"Timestamp",
"{",
"sec",
":=",
"int64",
"(",
"secondsSinceEpoch",
")",
"\n",
"nsec",
":=",
"int64",
"(",
"(",
"secondsSinceEpoch",
"-",
"float64",
"(",
"sec",
")",
"+",
"0.0000005",
")",
"*",
"1000000000.0",
")",
"\n",
"return",
"Timestamp",
"{",
"time",
".",
"Unix",
"(",
"sec",
",",
"nsec",
")",
".",
"UTC",
"(",
")",
"}",
"\n",
"}"
] | //
// TimestampFromEpoch creates a new Timestamp from the specified time.Time
// | [
"TimestampFromEpoch",
"creates",
"a",
"new",
"Timestamp",
"from",
"the",
"specified",
"time",
".",
"Time"
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/rdl/timestamp.go#L135-L139 |
14,498 | ardielle/ardielle-go | tbin/api.go | Marshal | func Marshal(data interface{}) ([]byte, error) {
enc := NewEncoder(nil)
enc.Encode(data)
return enc.Bytes(), enc.Error()
} | go | func Marshal(data interface{}) ([]byte, error) {
enc := NewEncoder(nil)
enc.Encode(data)
return enc.Bytes(), enc.Error()
} | [
"func",
"Marshal",
"(",
"data",
"interface",
"{",
"}",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"enc",
":=",
"NewEncoder",
"(",
"nil",
")",
"\n",
"enc",
".",
"Encode",
"(",
"data",
")",
"\n",
"return",
"enc",
".",
"Bytes",
"(",
")",
",",
"enc",
".",
"Error",
"(",
")",
"\n",
"}"
] | //
// Marshal - Marshal the specified data to TBin, returning a byte array or error.
// | [
"Marshal",
"-",
"Marshal",
"the",
"specified",
"data",
"to",
"TBin",
"returning",
"a",
"byte",
"array",
"or",
"error",
"."
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/api.go#L29-L33 |
14,499 | ardielle/ardielle-go | tbin/api.go | NewEncoder | func NewEncoder(w io.Writer) *Encoder {
enc := Encoder{syms: make(map[string]int, 0), tags: make(map[string]*tagDef, 0), nextTag: FirstUserTag}
enc.out = w
enc.bytebuf = make([]byte, 32)
enc.writeHeader()
return &enc
} | go | func NewEncoder(w io.Writer) *Encoder {
enc := Encoder{syms: make(map[string]int, 0), tags: make(map[string]*tagDef, 0), nextTag: FirstUserTag}
enc.out = w
enc.bytebuf = make([]byte, 32)
enc.writeHeader()
return &enc
} | [
"func",
"NewEncoder",
"(",
"w",
"io",
".",
"Writer",
")",
"*",
"Encoder",
"{",
"enc",
":=",
"Encoder",
"{",
"syms",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"int",
",",
"0",
")",
",",
"tags",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"tagDef",
",",
"0",
")",
",",
"nextTag",
":",
"FirstUserTag",
"}",
"\n",
"enc",
".",
"out",
"=",
"w",
"\n",
"enc",
".",
"bytebuf",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"32",
")",
"\n",
"enc",
".",
"writeHeader",
"(",
")",
"\n",
"return",
"&",
"enc",
"\n",
"}"
] | // NewEncoder - create and return a new Encoder. This is a "session" for tbin, i.e. accumulated
// state for this encoder can make repeated Marshal calls more efficient. | [
"NewEncoder",
"-",
"create",
"and",
"return",
"a",
"new",
"Encoder",
".",
"This",
"is",
"a",
"session",
"for",
"tbin",
"i",
".",
"e",
".",
"accumulated",
"state",
"for",
"this",
"encoder",
"can",
"make",
"repeated",
"Marshal",
"calls",
"more",
"efficient",
"."
] | c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff | https://github.com/ardielle/ardielle-go/blob/c4ab435c6f1ae2ece59bdd174b5b27c4f9828cff/tbin/api.go#L53-L59 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.