_id
stringlengths 2
7
| title
stringlengths 1
118
| partition
stringclasses 3
values | text
stringlengths 52
85.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q182100
|
NewPaymentResult
|
test
|
func NewPaymentResult(code PaymentResultCode, value interface{}) (result PaymentResult, err error) {
result.Code = code
switch PaymentResultCode(code) {
case PaymentResultCodePaymentSuccess:
// void
default:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182101
|
ValidEnum
|
test
|
func (e PathPaymentResultCode) ValidEnum(v int32) bool {
_, ok := pathPaymentResultCodeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182102
|
ArmForSwitch
|
test
|
func (u PathPaymentResult) ArmForSwitch(sw int32) (string, bool) {
switch PathPaymentResultCode(sw) {
case PathPaymentResultCodePathPaymentSuccess:
return "Success", true
case PathPaymentResultCodePathPaymentNoIssuer:
return "NoIssuer", true
default:
return "", true
}
}
|
go
|
{
"resource": ""
}
|
q182103
|
NewPathPaymentResult
|
test
|
func NewPathPaymentResult(code PathPaymentResultCode, value interface{}) (result PathPaymentResult, err error) {
result.Code = code
switch PathPaymentResultCode(code) {
case PathPaymentResultCodePathPaymentSuccess:
tv, ok := value.(PathPaymentResultSuccess)
if !ok {
err = fmt.Errorf("invalid value, must be PathPaymentResultSuccess")
return
}
result.Success = &tv
case PathPaymentResultCodePathPaymentNoIssuer:
tv, ok := value.(Asset)
if !ok {
err = fmt.Errorf("invalid value, must be Asset")
return
}
result.NoIssuer = &tv
default:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182104
|
MustNoIssuer
|
test
|
func (u PathPaymentResult) MustNoIssuer() Asset {
val, ok := u.GetNoIssuer()
if !ok {
panic("arm NoIssuer is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182105
|
GetNoIssuer
|
test
|
func (u PathPaymentResult) GetNoIssuer() (result Asset, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Code))
if armName == "NoIssuer" {
result = *u.NoIssuer
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182106
|
ValidEnum
|
test
|
func (e ManageOfferResultCode) ValidEnum(v int32) bool {
_, ok := manageOfferResultCodeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182107
|
ValidEnum
|
test
|
func (e ManageOfferEffect) ValidEnum(v int32) bool {
_, ok := manageOfferEffectMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182108
|
ArmForSwitch
|
test
|
func (u ManageOfferSuccessResultOffer) ArmForSwitch(sw int32) (string, bool) {
switch ManageOfferEffect(sw) {
case ManageOfferEffectManageOfferCreated:
return "Offer", true
case ManageOfferEffectManageOfferUpdated:
return "Offer", true
default:
return "", true
}
}
|
go
|
{
"resource": ""
}
|
q182109
|
NewManageOfferSuccessResultOffer
|
test
|
func NewManageOfferSuccessResultOffer(effect ManageOfferEffect, value interface{}) (result ManageOfferSuccessResultOffer, err error) {
result.Effect = effect
switch ManageOfferEffect(effect) {
case ManageOfferEffectManageOfferCreated:
tv, ok := value.(OfferEntry)
if !ok {
err = fmt.Errorf("invalid value, must be OfferEntry")
return
}
result.Offer = &tv
case ManageOfferEffectManageOfferUpdated:
tv, ok := value.(OfferEntry)
if !ok {
err = fmt.Errorf("invalid value, must be OfferEntry")
return
}
result.Offer = &tv
default:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182110
|
ArmForSwitch
|
test
|
func (u ManageOfferResult) ArmForSwitch(sw int32) (string, bool) {
switch ManageOfferResultCode(sw) {
case ManageOfferResultCodeManageOfferSuccess:
return "Success", true
default:
return "", true
}
}
|
go
|
{
"resource": ""
}
|
q182111
|
NewManageOfferResult
|
test
|
func NewManageOfferResult(code ManageOfferResultCode, value interface{}) (result ManageOfferResult, err error) {
result.Code = code
switch ManageOfferResultCode(code) {
case ManageOfferResultCodeManageOfferSuccess:
tv, ok := value.(ManageOfferSuccessResult)
if !ok {
err = fmt.Errorf("invalid value, must be ManageOfferSuccessResult")
return
}
result.Success = &tv
default:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182112
|
ValidEnum
|
test
|
func (e SetOptionsResultCode) ValidEnum(v int32) bool {
_, ok := setOptionsResultCodeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182113
|
ArmForSwitch
|
test
|
func (u SetOptionsResult) ArmForSwitch(sw int32) (string, bool) {
switch SetOptionsResultCode(sw) {
case SetOptionsResultCodeSetOptionsSuccess:
return "", true
default:
return "", true
}
}
|
go
|
{
"resource": ""
}
|
q182114
|
NewSetOptionsResult
|
test
|
func NewSetOptionsResult(code SetOptionsResultCode, value interface{}) (result SetOptionsResult, err error) {
result.Code = code
switch SetOptionsResultCode(code) {
case SetOptionsResultCodeSetOptionsSuccess:
// void
default:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182115
|
ValidEnum
|
test
|
func (e ChangeTrustResultCode) ValidEnum(v int32) bool {
_, ok := changeTrustResultCodeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182116
|
ArmForSwitch
|
test
|
func (u ChangeTrustResult) ArmForSwitch(sw int32) (string, bool) {
switch ChangeTrustResultCode(sw) {
case ChangeTrustResultCodeChangeTrustSuccess:
return "", true
default:
return "", true
}
}
|
go
|
{
"resource": ""
}
|
q182117
|
NewChangeTrustResult
|
test
|
func NewChangeTrustResult(code ChangeTrustResultCode, value interface{}) (result ChangeTrustResult, err error) {
result.Code = code
switch ChangeTrustResultCode(code) {
case ChangeTrustResultCodeChangeTrustSuccess:
// void
default:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182118
|
ValidEnum
|
test
|
func (e AllowTrustResultCode) ValidEnum(v int32) bool {
_, ok := allowTrustResultCodeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182119
|
ArmForSwitch
|
test
|
func (u AllowTrustResult) ArmForSwitch(sw int32) (string, bool) {
switch AllowTrustResultCode(sw) {
case AllowTrustResultCodeAllowTrustSuccess:
return "", true
default:
return "", true
}
}
|
go
|
{
"resource": ""
}
|
q182120
|
NewAllowTrustResult
|
test
|
func NewAllowTrustResult(code AllowTrustResultCode, value interface{}) (result AllowTrustResult, err error) {
result.Code = code
switch AllowTrustResultCode(code) {
case AllowTrustResultCodeAllowTrustSuccess:
// void
default:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182121
|
ValidEnum
|
test
|
func (e AccountMergeResultCode) ValidEnum(v int32) bool {
_, ok := accountMergeResultCodeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182122
|
ArmForSwitch
|
test
|
func (u AccountMergeResult) ArmForSwitch(sw int32) (string, bool) {
switch AccountMergeResultCode(sw) {
case AccountMergeResultCodeAccountMergeSuccess:
return "SourceAccountBalance", true
default:
return "", true
}
}
|
go
|
{
"resource": ""
}
|
q182123
|
NewAccountMergeResult
|
test
|
func NewAccountMergeResult(code AccountMergeResultCode, value interface{}) (result AccountMergeResult, err error) {
result.Code = code
switch AccountMergeResultCode(code) {
case AccountMergeResultCodeAccountMergeSuccess:
tv, ok := value.(Int64)
if !ok {
err = fmt.Errorf("invalid value, must be Int64")
return
}
result.SourceAccountBalance = &tv
default:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182124
|
MustSourceAccountBalance
|
test
|
func (u AccountMergeResult) MustSourceAccountBalance() Int64 {
val, ok := u.GetSourceAccountBalance()
if !ok {
panic("arm SourceAccountBalance is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182125
|
GetSourceAccountBalance
|
test
|
func (u AccountMergeResult) GetSourceAccountBalance() (result Int64, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Code))
if armName == "SourceAccountBalance" {
result = *u.SourceAccountBalance
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182126
|
ValidEnum
|
test
|
func (e InflationResultCode) ValidEnum(v int32) bool {
_, ok := inflationResultCodeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182127
|
ArmForSwitch
|
test
|
func (u InflationResult) ArmForSwitch(sw int32) (string, bool) {
switch InflationResultCode(sw) {
case InflationResultCodeInflationSuccess:
return "Payouts", true
default:
return "", true
}
}
|
go
|
{
"resource": ""
}
|
q182128
|
NewInflationResult
|
test
|
func NewInflationResult(code InflationResultCode, value interface{}) (result InflationResult, err error) {
result.Code = code
switch InflationResultCode(code) {
case InflationResultCodeInflationSuccess:
tv, ok := value.([]InflationPayout)
if !ok {
err = fmt.Errorf("invalid value, must be []InflationPayout")
return
}
result.Payouts = &tv
default:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182129
|
MustPayouts
|
test
|
func (u InflationResult) MustPayouts() []InflationPayout {
val, ok := u.GetPayouts()
if !ok {
panic("arm Payouts is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182130
|
GetPayouts
|
test
|
func (u InflationResult) GetPayouts() (result []InflationPayout, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Code))
if armName == "Payouts" {
result = *u.Payouts
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182131
|
ValidEnum
|
test
|
func (e ManageDataResultCode) ValidEnum(v int32) bool {
_, ok := manageDataResultCodeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182132
|
ArmForSwitch
|
test
|
func (u ManageDataResult) ArmForSwitch(sw int32) (string, bool) {
switch ManageDataResultCode(sw) {
case ManageDataResultCodeManageDataSuccess:
return "", true
default:
return "", true
}
}
|
go
|
{
"resource": ""
}
|
q182133
|
NewManageDataResult
|
test
|
func NewManageDataResult(code ManageDataResultCode, value interface{}) (result ManageDataResult, err error) {
result.Code = code
switch ManageDataResultCode(code) {
case ManageDataResultCodeManageDataSuccess:
// void
default:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182134
|
ValidEnum
|
test
|
func (e OperationResultCode) ValidEnum(v int32) bool {
_, ok := operationResultCodeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182135
|
ArmForSwitch
|
test
|
func (u OperationResultTr) ArmForSwitch(sw int32) (string, bool) {
switch OperationType(sw) {
case OperationTypeCreateAccount:
return "CreateAccountResult", true
case OperationTypePayment:
return "PaymentResult", true
case OperationTypePathPayment:
return "PathPaymentResult", true
case OperationTypeManageOffer:
return "ManageOfferResult", true
case OperationTypeCreatePassiveOffer:
return "CreatePassiveOfferResult", true
case OperationTypeSetOptions:
return "SetOptionsResult", true
case OperationTypeChangeTrust:
return "ChangeTrustResult", true
case OperationTypeAllowTrust:
return "AllowTrustResult", true
case OperationTypeAccountMerge:
return "AccountMergeResult", true
case OperationTypeInflation:
return "InflationResult", true
case OperationTypeManageData:
return "ManageDataResult", true
}
return "-", false
}
|
go
|
{
"resource": ""
}
|
q182136
|
NewOperationResultTr
|
test
|
func NewOperationResultTr(aType OperationType, value interface{}) (result OperationResultTr, err error) {
result.Type = aType
switch OperationType(aType) {
case OperationTypeCreateAccount:
tv, ok := value.(CreateAccountResult)
if !ok {
err = fmt.Errorf("invalid value, must be CreateAccountResult")
return
}
result.CreateAccountResult = &tv
case OperationTypePayment:
tv, ok := value.(PaymentResult)
if !ok {
err = fmt.Errorf("invalid value, must be PaymentResult")
return
}
result.PaymentResult = &tv
case OperationTypePathPayment:
tv, ok := value.(PathPaymentResult)
if !ok {
err = fmt.Errorf("invalid value, must be PathPaymentResult")
return
}
result.PathPaymentResult = &tv
case OperationTypeManageOffer:
tv, ok := value.(ManageOfferResult)
if !ok {
err = fmt.Errorf("invalid value, must be ManageOfferResult")
return
}
result.ManageOfferResult = &tv
case OperationTypeCreatePassiveOffer:
tv, ok := value.(ManageOfferResult)
if !ok {
err = fmt.Errorf("invalid value, must be ManageOfferResult")
return
}
result.CreatePassiveOfferResult = &tv
case OperationTypeSetOptions:
tv, ok := value.(SetOptionsResult)
if !ok {
err = fmt.Errorf("invalid value, must be SetOptionsResult")
return
}
result.SetOptionsResult = &tv
case OperationTypeChangeTrust:
tv, ok := value.(ChangeTrustResult)
if !ok {
err = fmt.Errorf("invalid value, must be ChangeTrustResult")
return
}
result.ChangeTrustResult = &tv
case OperationTypeAllowTrust:
tv, ok := value.(AllowTrustResult)
if !ok {
err = fmt.Errorf("invalid value, must be AllowTrustResult")
return
}
result.AllowTrustResult = &tv
case OperationTypeAccountMerge:
tv, ok := value.(AccountMergeResult)
if !ok {
err = fmt.Errorf("invalid value, must be AccountMergeResult")
return
}
result.AccountMergeResult = &tv
case OperationTypeInflation:
tv, ok := value.(InflationResult)
if !ok {
err = fmt.Errorf("invalid value, must be InflationResult")
return
}
result.InflationResult = &tv
case OperationTypeManageData:
tv, ok := value.(ManageDataResult)
if !ok {
err = fmt.Errorf("invalid value, must be ManageDataResult")
return
}
result.ManageDataResult = &tv
}
return
}
|
go
|
{
"resource": ""
}
|
q182137
|
MustCreateAccountResult
|
test
|
func (u OperationResultTr) MustCreateAccountResult() CreateAccountResult {
val, ok := u.GetCreateAccountResult()
if !ok {
panic("arm CreateAccountResult is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182138
|
GetCreateAccountResult
|
test
|
func (u OperationResultTr) GetCreateAccountResult() (result CreateAccountResult, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "CreateAccountResult" {
result = *u.CreateAccountResult
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182139
|
MustPaymentResult
|
test
|
func (u OperationResultTr) MustPaymentResult() PaymentResult {
val, ok := u.GetPaymentResult()
if !ok {
panic("arm PaymentResult is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182140
|
GetPaymentResult
|
test
|
func (u OperationResultTr) GetPaymentResult() (result PaymentResult, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "PaymentResult" {
result = *u.PaymentResult
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182141
|
MustPathPaymentResult
|
test
|
func (u OperationResultTr) MustPathPaymentResult() PathPaymentResult {
val, ok := u.GetPathPaymentResult()
if !ok {
panic("arm PathPaymentResult is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182142
|
GetPathPaymentResult
|
test
|
func (u OperationResultTr) GetPathPaymentResult() (result PathPaymentResult, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "PathPaymentResult" {
result = *u.PathPaymentResult
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182143
|
MustManageOfferResult
|
test
|
func (u OperationResultTr) MustManageOfferResult() ManageOfferResult {
val, ok := u.GetManageOfferResult()
if !ok {
panic("arm ManageOfferResult is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182144
|
GetManageOfferResult
|
test
|
func (u OperationResultTr) GetManageOfferResult() (result ManageOfferResult, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "ManageOfferResult" {
result = *u.ManageOfferResult
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182145
|
MustCreatePassiveOfferResult
|
test
|
func (u OperationResultTr) MustCreatePassiveOfferResult() ManageOfferResult {
val, ok := u.GetCreatePassiveOfferResult()
if !ok {
panic("arm CreatePassiveOfferResult is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182146
|
MustSetOptionsResult
|
test
|
func (u OperationResultTr) MustSetOptionsResult() SetOptionsResult {
val, ok := u.GetSetOptionsResult()
if !ok {
panic("arm SetOptionsResult is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182147
|
GetSetOptionsResult
|
test
|
func (u OperationResultTr) GetSetOptionsResult() (result SetOptionsResult, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "SetOptionsResult" {
result = *u.SetOptionsResult
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182148
|
MustChangeTrustResult
|
test
|
func (u OperationResultTr) MustChangeTrustResult() ChangeTrustResult {
val, ok := u.GetChangeTrustResult()
if !ok {
panic("arm ChangeTrustResult is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182149
|
GetChangeTrustResult
|
test
|
func (u OperationResultTr) GetChangeTrustResult() (result ChangeTrustResult, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "ChangeTrustResult" {
result = *u.ChangeTrustResult
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182150
|
MustAllowTrustResult
|
test
|
func (u OperationResultTr) MustAllowTrustResult() AllowTrustResult {
val, ok := u.GetAllowTrustResult()
if !ok {
panic("arm AllowTrustResult is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182151
|
GetAllowTrustResult
|
test
|
func (u OperationResultTr) GetAllowTrustResult() (result AllowTrustResult, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "AllowTrustResult" {
result = *u.AllowTrustResult
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182152
|
MustAccountMergeResult
|
test
|
func (u OperationResultTr) MustAccountMergeResult() AccountMergeResult {
val, ok := u.GetAccountMergeResult()
if !ok {
panic("arm AccountMergeResult is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182153
|
GetAccountMergeResult
|
test
|
func (u OperationResultTr) GetAccountMergeResult() (result AccountMergeResult, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "AccountMergeResult" {
result = *u.AccountMergeResult
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182154
|
MustInflationResult
|
test
|
func (u OperationResultTr) MustInflationResult() InflationResult {
val, ok := u.GetInflationResult()
if !ok {
panic("arm InflationResult is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182155
|
GetInflationResult
|
test
|
func (u OperationResultTr) GetInflationResult() (result InflationResult, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "InflationResult" {
result = *u.InflationResult
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182156
|
MustManageDataResult
|
test
|
func (u OperationResultTr) MustManageDataResult() ManageDataResult {
val, ok := u.GetManageDataResult()
if !ok {
panic("arm ManageDataResult is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182157
|
GetManageDataResult
|
test
|
func (u OperationResultTr) GetManageDataResult() (result ManageDataResult, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "ManageDataResult" {
result = *u.ManageDataResult
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182158
|
ArmForSwitch
|
test
|
func (u OperationResult) ArmForSwitch(sw int32) (string, bool) {
switch OperationResultCode(sw) {
case OperationResultCodeOpInner:
return "Tr", true
default:
return "", true
}
}
|
go
|
{
"resource": ""
}
|
q182159
|
NewOperationResult
|
test
|
func NewOperationResult(code OperationResultCode, value interface{}) (result OperationResult, err error) {
result.Code = code
switch OperationResultCode(code) {
case OperationResultCodeOpInner:
tv, ok := value.(OperationResultTr)
if !ok {
err = fmt.Errorf("invalid value, must be OperationResultTr")
return
}
result.Tr = &tv
default:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182160
|
MustTr
|
test
|
func (u OperationResult) MustTr() OperationResultTr {
val, ok := u.GetTr()
if !ok {
panic("arm Tr is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182161
|
GetTr
|
test
|
func (u OperationResult) GetTr() (result OperationResultTr, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Code))
if armName == "Tr" {
result = *u.Tr
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182162
|
ValidEnum
|
test
|
func (e TransactionResultCode) ValidEnum(v int32) bool {
_, ok := transactionResultCodeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182163
|
ArmForSwitch
|
test
|
func (u TransactionResultResult) ArmForSwitch(sw int32) (string, bool) {
switch TransactionResultCode(sw) {
case TransactionResultCodeTxSuccess:
return "Results", true
case TransactionResultCodeTxFailed:
return "Results", true
default:
return "", true
}
}
|
go
|
{
"resource": ""
}
|
q182164
|
NewTransactionResultResult
|
test
|
func NewTransactionResultResult(code TransactionResultCode, value interface{}) (result TransactionResultResult, err error) {
result.Code = code
switch TransactionResultCode(code) {
case TransactionResultCodeTxSuccess:
tv, ok := value.([]OperationResult)
if !ok {
err = fmt.Errorf("invalid value, must be []OperationResult")
return
}
result.Results = &tv
case TransactionResultCodeTxFailed:
tv, ok := value.([]OperationResult)
if !ok {
err = fmt.Errorf("invalid value, must be []OperationResult")
return
}
result.Results = &tv
default:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182165
|
MustResults
|
test
|
func (u TransactionResultResult) MustResults() []OperationResult {
val, ok := u.GetResults()
if !ok {
panic("arm Results is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182166
|
GetResults
|
test
|
func (u TransactionResultResult) GetResults() (result []OperationResult, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Code))
if armName == "Results" {
result = *u.Results
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182167
|
NewTransactionResultExt
|
test
|
func NewTransactionResultExt(v int32, value interface{}) (result TransactionResultExt, err error) {
result.V = v
switch int32(v) {
case 0:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182168
|
NewStellarValueExt
|
test
|
func NewStellarValueExt(v int32, value interface{}) (result StellarValueExt, err error) {
result.V = v
switch int32(v) {
case 0:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182169
|
NewLedgerHeaderExt
|
test
|
func NewLedgerHeaderExt(v int32, value interface{}) (result LedgerHeaderExt, err error) {
result.V = v
switch int32(v) {
case 0:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182170
|
ValidEnum
|
test
|
func (e LedgerUpgradeType) ValidEnum(v int32) bool {
_, ok := ledgerUpgradeTypeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182171
|
ArmForSwitch
|
test
|
func (u LedgerUpgrade) ArmForSwitch(sw int32) (string, bool) {
switch LedgerUpgradeType(sw) {
case LedgerUpgradeTypeLedgerUpgradeVersion:
return "NewLedgerVersion", true
case LedgerUpgradeTypeLedgerUpgradeBaseFee:
return "NewBaseFee", true
case LedgerUpgradeTypeLedgerUpgradeMaxTxSetSize:
return "NewMaxTxSetSize", true
}
return "-", false
}
|
go
|
{
"resource": ""
}
|
q182172
|
NewLedgerUpgrade
|
test
|
func NewLedgerUpgrade(aType LedgerUpgradeType, value interface{}) (result LedgerUpgrade, err error) {
result.Type = aType
switch LedgerUpgradeType(aType) {
case LedgerUpgradeTypeLedgerUpgradeVersion:
tv, ok := value.(Uint32)
if !ok {
err = fmt.Errorf("invalid value, must be Uint32")
return
}
result.NewLedgerVersion = &tv
case LedgerUpgradeTypeLedgerUpgradeBaseFee:
tv, ok := value.(Uint32)
if !ok {
err = fmt.Errorf("invalid value, must be Uint32")
return
}
result.NewBaseFee = &tv
case LedgerUpgradeTypeLedgerUpgradeMaxTxSetSize:
tv, ok := value.(Uint32)
if !ok {
err = fmt.Errorf("invalid value, must be Uint32")
return
}
result.NewMaxTxSetSize = &tv
}
return
}
|
go
|
{
"resource": ""
}
|
q182173
|
MustNewLedgerVersion
|
test
|
func (u LedgerUpgrade) MustNewLedgerVersion() Uint32 {
val, ok := u.GetNewLedgerVersion()
if !ok {
panic("arm NewLedgerVersion is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182174
|
GetNewLedgerVersion
|
test
|
func (u LedgerUpgrade) GetNewLedgerVersion() (result Uint32, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "NewLedgerVersion" {
result = *u.NewLedgerVersion
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182175
|
MustNewBaseFee
|
test
|
func (u LedgerUpgrade) MustNewBaseFee() Uint32 {
val, ok := u.GetNewBaseFee()
if !ok {
panic("arm NewBaseFee is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182176
|
GetNewBaseFee
|
test
|
func (u LedgerUpgrade) GetNewBaseFee() (result Uint32, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "NewBaseFee" {
result = *u.NewBaseFee
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182177
|
MustNewMaxTxSetSize
|
test
|
func (u LedgerUpgrade) MustNewMaxTxSetSize() Uint32 {
val, ok := u.GetNewMaxTxSetSize()
if !ok {
panic("arm NewMaxTxSetSize is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182178
|
GetNewMaxTxSetSize
|
test
|
func (u LedgerUpgrade) GetNewMaxTxSetSize() (result Uint32, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "NewMaxTxSetSize" {
result = *u.NewMaxTxSetSize
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182179
|
ArmForSwitch
|
test
|
func (u LedgerKey) ArmForSwitch(sw int32) (string, bool) {
switch LedgerEntryType(sw) {
case LedgerEntryTypeAccount:
return "Account", true
case LedgerEntryTypeTrustline:
return "TrustLine", true
case LedgerEntryTypeOffer:
return "Offer", true
case LedgerEntryTypeData:
return "Data", true
}
return "-", false
}
|
go
|
{
"resource": ""
}
|
q182180
|
NewLedgerKey
|
test
|
func NewLedgerKey(aType LedgerEntryType, value interface{}) (result LedgerKey, err error) {
result.Type = aType
switch LedgerEntryType(aType) {
case LedgerEntryTypeAccount:
tv, ok := value.(LedgerKeyAccount)
if !ok {
err = fmt.Errorf("invalid value, must be LedgerKeyAccount")
return
}
result.Account = &tv
case LedgerEntryTypeTrustline:
tv, ok := value.(LedgerKeyTrustLine)
if !ok {
err = fmt.Errorf("invalid value, must be LedgerKeyTrustLine")
return
}
result.TrustLine = &tv
case LedgerEntryTypeOffer:
tv, ok := value.(LedgerKeyOffer)
if !ok {
err = fmt.Errorf("invalid value, must be LedgerKeyOffer")
return
}
result.Offer = &tv
case LedgerEntryTypeData:
tv, ok := value.(LedgerKeyData)
if !ok {
err = fmt.Errorf("invalid value, must be LedgerKeyData")
return
}
result.Data = &tv
}
return
}
|
go
|
{
"resource": ""
}
|
q182181
|
ValidEnum
|
test
|
func (e BucketEntryType) ValidEnum(v int32) bool {
_, ok := bucketEntryTypeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182182
|
ArmForSwitch
|
test
|
func (u BucketEntry) ArmForSwitch(sw int32) (string, bool) {
switch BucketEntryType(sw) {
case BucketEntryTypeLiveentry:
return "LiveEntry", true
case BucketEntryTypeDeadentry:
return "DeadEntry", true
}
return "-", false
}
|
go
|
{
"resource": ""
}
|
q182183
|
NewBucketEntry
|
test
|
func NewBucketEntry(aType BucketEntryType, value interface{}) (result BucketEntry, err error) {
result.Type = aType
switch BucketEntryType(aType) {
case BucketEntryTypeLiveentry:
tv, ok := value.(LedgerEntry)
if !ok {
err = fmt.Errorf("invalid value, must be LedgerEntry")
return
}
result.LiveEntry = &tv
case BucketEntryTypeDeadentry:
tv, ok := value.(LedgerKey)
if !ok {
err = fmt.Errorf("invalid value, must be LedgerKey")
return
}
result.DeadEntry = &tv
}
return
}
|
go
|
{
"resource": ""
}
|
q182184
|
MustLiveEntry
|
test
|
func (u BucketEntry) MustLiveEntry() LedgerEntry {
val, ok := u.GetLiveEntry()
if !ok {
panic("arm LiveEntry is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182185
|
GetLiveEntry
|
test
|
func (u BucketEntry) GetLiveEntry() (result LedgerEntry, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "LiveEntry" {
result = *u.LiveEntry
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182186
|
MustDeadEntry
|
test
|
func (u BucketEntry) MustDeadEntry() LedgerKey {
val, ok := u.GetDeadEntry()
if !ok {
panic("arm DeadEntry is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182187
|
GetDeadEntry
|
test
|
func (u BucketEntry) GetDeadEntry() (result LedgerKey, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "DeadEntry" {
result = *u.DeadEntry
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182188
|
NewTransactionHistoryEntryExt
|
test
|
func NewTransactionHistoryEntryExt(v int32, value interface{}) (result TransactionHistoryEntryExt, err error) {
result.V = v
switch int32(v) {
case 0:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182189
|
ArmForSwitch
|
test
|
func (u TransactionHistoryResultEntryExt) ArmForSwitch(sw int32) (string, bool) {
switch int32(sw) {
case 0:
return "", true
}
return "-", false
}
|
go
|
{
"resource": ""
}
|
q182190
|
NewTransactionHistoryResultEntryExt
|
test
|
func NewTransactionHistoryResultEntryExt(v int32, value interface{}) (result TransactionHistoryResultEntryExt, err error) {
result.V = v
switch int32(v) {
case 0:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182191
|
NewLedgerHeaderHistoryEntryExt
|
test
|
func NewLedgerHeaderHistoryEntryExt(v int32, value interface{}) (result LedgerHeaderHistoryEntryExt, err error) {
result.V = v
switch int32(v) {
case 0:
// void
}
return
}
|
go
|
{
"resource": ""
}
|
q182192
|
NewScpHistoryEntry
|
test
|
func NewScpHistoryEntry(v int32, value interface{}) (result ScpHistoryEntry, err error) {
result.V = v
switch int32(v) {
case 0:
tv, ok := value.(ScpHistoryEntryV0)
if !ok {
err = fmt.Errorf("invalid value, must be ScpHistoryEntryV0")
return
}
result.V0 = &tv
}
return
}
|
go
|
{
"resource": ""
}
|
q182193
|
ValidEnum
|
test
|
func (e LedgerEntryChangeType) ValidEnum(v int32) bool {
_, ok := ledgerEntryChangeTypeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182194
|
ArmForSwitch
|
test
|
func (u LedgerEntryChange) ArmForSwitch(sw int32) (string, bool) {
switch LedgerEntryChangeType(sw) {
case LedgerEntryChangeTypeLedgerEntryCreated:
return "Created", true
case LedgerEntryChangeTypeLedgerEntryUpdated:
return "Updated", true
case LedgerEntryChangeTypeLedgerEntryRemoved:
return "Removed", true
case LedgerEntryChangeTypeLedgerEntryState:
return "State", true
}
return "-", false
}
|
go
|
{
"resource": ""
}
|
q182195
|
NewLedgerEntryChange
|
test
|
func NewLedgerEntryChange(aType LedgerEntryChangeType, value interface{}) (result LedgerEntryChange, err error) {
result.Type = aType
switch LedgerEntryChangeType(aType) {
case LedgerEntryChangeTypeLedgerEntryCreated:
tv, ok := value.(LedgerEntry)
if !ok {
err = fmt.Errorf("invalid value, must be LedgerEntry")
return
}
result.Created = &tv
case LedgerEntryChangeTypeLedgerEntryUpdated:
tv, ok := value.(LedgerEntry)
if !ok {
err = fmt.Errorf("invalid value, must be LedgerEntry")
return
}
result.Updated = &tv
case LedgerEntryChangeTypeLedgerEntryRemoved:
tv, ok := value.(LedgerKey)
if !ok {
err = fmt.Errorf("invalid value, must be LedgerKey")
return
}
result.Removed = &tv
case LedgerEntryChangeTypeLedgerEntryState:
tv, ok := value.(LedgerEntry)
if !ok {
err = fmt.Errorf("invalid value, must be LedgerEntry")
return
}
result.State = &tv
}
return
}
|
go
|
{
"resource": ""
}
|
q182196
|
MustCreated
|
test
|
func (u LedgerEntryChange) MustCreated() LedgerEntry {
val, ok := u.GetCreated()
if !ok {
panic("arm Created is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182197
|
GetCreated
|
test
|
func (u LedgerEntryChange) GetCreated() (result LedgerEntry, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "Created" {
result = *u.Created
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182198
|
MustUpdated
|
test
|
func (u LedgerEntryChange) MustUpdated() LedgerEntry {
val, ok := u.GetUpdated()
if !ok {
panic("arm Updated is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182199
|
GetUpdated
|
test
|
func (u LedgerEntryChange) GetUpdated() (result LedgerEntry, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "Updated" {
result = *u.Updated
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.