_id
stringlengths 2
7
| title
stringlengths 1
118
| partition
stringclasses 3
values | text
stringlengths 52
85.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q182200
|
MustRemoved
|
test
|
func (u LedgerEntryChange) MustRemoved() LedgerKey {
val, ok := u.GetRemoved()
if !ok {
panic("arm Removed is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182201
|
GetRemoved
|
test
|
func (u LedgerEntryChange) GetRemoved() (result LedgerKey, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "Removed" {
result = *u.Removed
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182202
|
MustState
|
test
|
func (u LedgerEntryChange) MustState() LedgerEntry {
val, ok := u.GetState()
if !ok {
panic("arm State is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182203
|
GetState
|
test
|
func (u LedgerEntryChange) GetState() (result LedgerEntry, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "State" {
result = *u.State
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182204
|
NewTransactionMeta
|
test
|
func NewTransactionMeta(v int32, value interface{}) (result TransactionMeta, err error) {
result.V = v
switch int32(v) {
case 0:
tv, ok := value.([]OperationMeta)
if !ok {
err = fmt.Errorf("invalid value, must be []OperationMeta")
return
}
result.Operations = &tv
}
return
}
|
go
|
{
"resource": ""
}
|
q182205
|
MustOperations
|
test
|
func (u TransactionMeta) MustOperations() []OperationMeta {
val, ok := u.GetOperations()
if !ok {
panic("arm Operations is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182206
|
GetOperations
|
test
|
func (u TransactionMeta) GetOperations() (result []OperationMeta, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.V))
if armName == "Operations" {
result = *u.Operations
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182207
|
ValidEnum
|
test
|
func (e ErrorCode) ValidEnum(v int32) bool {
_, ok := errorCodeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182208
|
ValidEnum
|
test
|
func (e IpAddrType) ValidEnum(v int32) bool {
_, ok := ipAddrTypeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182209
|
ArmForSwitch
|
test
|
func (u PeerAddressIp) ArmForSwitch(sw int32) (string, bool) {
switch IpAddrType(sw) {
case IpAddrTypeIPv4:
return "Ipv4", true
case IpAddrTypeIPv6:
return "Ipv6", true
}
return "-", false
}
|
go
|
{
"resource": ""
}
|
q182210
|
NewPeerAddressIp
|
test
|
func NewPeerAddressIp(aType IpAddrType, value interface{}) (result PeerAddressIp, err error) {
result.Type = aType
switch IpAddrType(aType) {
case IpAddrTypeIPv4:
tv, ok := value.([4]byte)
if !ok {
err = fmt.Errorf("invalid value, must be [4]byte")
return
}
result.Ipv4 = &tv
case IpAddrTypeIPv6:
tv, ok := value.([16]byte)
if !ok {
err = fmt.Errorf("invalid value, must be [16]byte")
return
}
result.Ipv6 = &tv
}
return
}
|
go
|
{
"resource": ""
}
|
q182211
|
MustIpv4
|
test
|
func (u PeerAddressIp) MustIpv4() [4]byte {
val, ok := u.GetIpv4()
if !ok {
panic("arm Ipv4 is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182212
|
GetIpv4
|
test
|
func (u PeerAddressIp) GetIpv4() (result [4]byte, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "Ipv4" {
result = *u.Ipv4
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182213
|
MustIpv6
|
test
|
func (u PeerAddressIp) MustIpv6() [16]byte {
val, ok := u.GetIpv6()
if !ok {
panic("arm Ipv6 is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182214
|
GetIpv6
|
test
|
func (u PeerAddressIp) GetIpv6() (result [16]byte, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "Ipv6" {
result = *u.Ipv6
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182215
|
ValidEnum
|
test
|
func (e MessageType) ValidEnum(v int32) bool {
_, ok := messageTypeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182216
|
ArmForSwitch
|
test
|
func (u StellarMessage) ArmForSwitch(sw int32) (string, bool) {
switch MessageType(sw) {
case MessageTypeErrorMsg:
return "Error", true
case MessageTypeHello:
return "Hello", true
case MessageTypeAuth:
return "Auth", true
case MessageTypeDontHave:
return "DontHave", true
case MessageTypeGetPeers:
return "", true
case MessageTypePeers:
return "Peers", true
case MessageTypeGetTxSet:
return "TxSetHash", true
case MessageTypeTxSet:
return "TxSet", true
case MessageTypeTransaction:
return "Transaction", true
case MessageTypeGetScpQuorumset:
return "QSetHash", true
case MessageTypeScpQuorumset:
return "QSet", true
case MessageTypeScpMessage:
return "Envelope", true
case MessageTypeGetScpState:
return "GetScpLedgerSeq", true
}
return "-", false
}
|
go
|
{
"resource": ""
}
|
q182217
|
NewStellarMessage
|
test
|
func NewStellarMessage(aType MessageType, value interface{}) (result StellarMessage, err error) {
result.Type = aType
switch MessageType(aType) {
case MessageTypeErrorMsg:
tv, ok := value.(Error)
if !ok {
err = fmt.Errorf("invalid value, must be Error")
return
}
result.Error = &tv
case MessageTypeHello:
tv, ok := value.(Hello)
if !ok {
err = fmt.Errorf("invalid value, must be Hello")
return
}
result.Hello = &tv
case MessageTypeAuth:
tv, ok := value.(Auth)
if !ok {
err = fmt.Errorf("invalid value, must be Auth")
return
}
result.Auth = &tv
case MessageTypeDontHave:
tv, ok := value.(DontHave)
if !ok {
err = fmt.Errorf("invalid value, must be DontHave")
return
}
result.DontHave = &tv
case MessageTypeGetPeers:
// void
case MessageTypePeers:
tv, ok := value.([]PeerAddress)
if !ok {
err = fmt.Errorf("invalid value, must be []PeerAddress")
return
}
result.Peers = &tv
case MessageTypeGetTxSet:
tv, ok := value.(Uint256)
if !ok {
err = fmt.Errorf("invalid value, must be Uint256")
return
}
result.TxSetHash = &tv
case MessageTypeTxSet:
tv, ok := value.(TransactionSet)
if !ok {
err = fmt.Errorf("invalid value, must be TransactionSet")
return
}
result.TxSet = &tv
case MessageTypeTransaction:
tv, ok := value.(TransactionEnvelope)
if !ok {
err = fmt.Errorf("invalid value, must be TransactionEnvelope")
return
}
result.Transaction = &tv
case MessageTypeGetScpQuorumset:
tv, ok := value.(Uint256)
if !ok {
err = fmt.Errorf("invalid value, must be Uint256")
return
}
result.QSetHash = &tv
case MessageTypeScpQuorumset:
tv, ok := value.(ScpQuorumSet)
if !ok {
err = fmt.Errorf("invalid value, must be ScpQuorumSet")
return
}
result.QSet = &tv
case MessageTypeScpMessage:
tv, ok := value.(ScpEnvelope)
if !ok {
err = fmt.Errorf("invalid value, must be ScpEnvelope")
return
}
result.Envelope = &tv
case MessageTypeGetScpState:
tv, ok := value.(Uint32)
if !ok {
err = fmt.Errorf("invalid value, must be Uint32")
return
}
result.GetScpLedgerSeq = &tv
}
return
}
|
go
|
{
"resource": ""
}
|
q182218
|
MustError
|
test
|
func (u StellarMessage) MustError() Error {
val, ok := u.GetError()
if !ok {
panic("arm Error is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182219
|
GetError
|
test
|
func (u StellarMessage) GetError() (result Error, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "Error" {
result = *u.Error
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182220
|
MustHello
|
test
|
func (u StellarMessage) MustHello() Hello {
val, ok := u.GetHello()
if !ok {
panic("arm Hello is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182221
|
GetHello
|
test
|
func (u StellarMessage) GetHello() (result Hello, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "Hello" {
result = *u.Hello
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182222
|
MustAuth
|
test
|
func (u StellarMessage) MustAuth() Auth {
val, ok := u.GetAuth()
if !ok {
panic("arm Auth is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182223
|
GetAuth
|
test
|
func (u StellarMessage) GetAuth() (result Auth, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "Auth" {
result = *u.Auth
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182224
|
MustDontHave
|
test
|
func (u StellarMessage) MustDontHave() DontHave {
val, ok := u.GetDontHave()
if !ok {
panic("arm DontHave is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182225
|
GetDontHave
|
test
|
func (u StellarMessage) GetDontHave() (result DontHave, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "DontHave" {
result = *u.DontHave
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182226
|
MustPeers
|
test
|
func (u StellarMessage) MustPeers() []PeerAddress {
val, ok := u.GetPeers()
if !ok {
panic("arm Peers is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182227
|
GetPeers
|
test
|
func (u StellarMessage) GetPeers() (result []PeerAddress, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "Peers" {
result = *u.Peers
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182228
|
MustTxSetHash
|
test
|
func (u StellarMessage) MustTxSetHash() Uint256 {
val, ok := u.GetTxSetHash()
if !ok {
panic("arm TxSetHash is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182229
|
GetTxSetHash
|
test
|
func (u StellarMessage) GetTxSetHash() (result Uint256, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "TxSetHash" {
result = *u.TxSetHash
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182230
|
MustTxSet
|
test
|
func (u StellarMessage) MustTxSet() TransactionSet {
val, ok := u.GetTxSet()
if !ok {
panic("arm TxSet is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182231
|
GetTxSet
|
test
|
func (u StellarMessage) GetTxSet() (result TransactionSet, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "TxSet" {
result = *u.TxSet
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182232
|
MustTransaction
|
test
|
func (u StellarMessage) MustTransaction() TransactionEnvelope {
val, ok := u.GetTransaction()
if !ok {
panic("arm Transaction is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182233
|
GetTransaction
|
test
|
func (u StellarMessage) GetTransaction() (result TransactionEnvelope, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "Transaction" {
result = *u.Transaction
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182234
|
MustQSetHash
|
test
|
func (u StellarMessage) MustQSetHash() Uint256 {
val, ok := u.GetQSetHash()
if !ok {
panic("arm QSetHash is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182235
|
GetQSetHash
|
test
|
func (u StellarMessage) GetQSetHash() (result Uint256, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "QSetHash" {
result = *u.QSetHash
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182236
|
MustQSet
|
test
|
func (u StellarMessage) MustQSet() ScpQuorumSet {
val, ok := u.GetQSet()
if !ok {
panic("arm QSet is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182237
|
GetQSet
|
test
|
func (u StellarMessage) GetQSet() (result ScpQuorumSet, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "QSet" {
result = *u.QSet
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182238
|
MustEnvelope
|
test
|
func (u StellarMessage) MustEnvelope() ScpEnvelope {
val, ok := u.GetEnvelope()
if !ok {
panic("arm Envelope is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182239
|
GetEnvelope
|
test
|
func (u StellarMessage) GetEnvelope() (result ScpEnvelope, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "Envelope" {
result = *u.Envelope
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182240
|
MustGetScpLedgerSeq
|
test
|
func (u StellarMessage) MustGetScpLedgerSeq() Uint32 {
val, ok := u.GetGetScpLedgerSeq()
if !ok {
panic("arm GetScpLedgerSeq is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182241
|
GetGetScpLedgerSeq
|
test
|
func (u StellarMessage) GetGetScpLedgerSeq() (result Uint32, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "GetScpLedgerSeq" {
result = *u.GetScpLedgerSeq
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182242
|
ArmForSwitch
|
test
|
func (u AuthenticatedMessage) ArmForSwitch(sw int32) (string, bool) {
switch Uint32(sw) {
case 0:
return "V0", true
}
return "-", false
}
|
go
|
{
"resource": ""
}
|
q182243
|
NewAuthenticatedMessage
|
test
|
func NewAuthenticatedMessage(v Uint32, value interface{}) (result AuthenticatedMessage, err error) {
result.V = v
switch Uint32(v) {
case 0:
tv, ok := value.(AuthenticatedMessageV0)
if !ok {
err = fmt.Errorf("invalid value, must be AuthenticatedMessageV0")
return
}
result.V0 = &tv
}
return
}
|
go
|
{
"resource": ""
}
|
q182244
|
ValidEnum
|
test
|
func (e ScpStatementType) ValidEnum(v int32) bool {
_, ok := scpStatementTypeMap[v]
return ok
}
|
go
|
{
"resource": ""
}
|
q182245
|
ArmForSwitch
|
test
|
func (u ScpStatementPledges) ArmForSwitch(sw int32) (string, bool) {
switch ScpStatementType(sw) {
case ScpStatementTypeScpStPrepare:
return "Prepare", true
case ScpStatementTypeScpStConfirm:
return "Confirm", true
case ScpStatementTypeScpStExternalize:
return "Externalize", true
case ScpStatementTypeScpStNominate:
return "Nominate", true
}
return "-", false
}
|
go
|
{
"resource": ""
}
|
q182246
|
NewScpStatementPledges
|
test
|
func NewScpStatementPledges(aType ScpStatementType, value interface{}) (result ScpStatementPledges, err error) {
result.Type = aType
switch ScpStatementType(aType) {
case ScpStatementTypeScpStPrepare:
tv, ok := value.(ScpStatementPrepare)
if !ok {
err = fmt.Errorf("invalid value, must be ScpStatementPrepare")
return
}
result.Prepare = &tv
case ScpStatementTypeScpStConfirm:
tv, ok := value.(ScpStatementConfirm)
if !ok {
err = fmt.Errorf("invalid value, must be ScpStatementConfirm")
return
}
result.Confirm = &tv
case ScpStatementTypeScpStExternalize:
tv, ok := value.(ScpStatementExternalize)
if !ok {
err = fmt.Errorf("invalid value, must be ScpStatementExternalize")
return
}
result.Externalize = &tv
case ScpStatementTypeScpStNominate:
tv, ok := value.(ScpNomination)
if !ok {
err = fmt.Errorf("invalid value, must be ScpNomination")
return
}
result.Nominate = &tv
}
return
}
|
go
|
{
"resource": ""
}
|
q182247
|
MustPrepare
|
test
|
func (u ScpStatementPledges) MustPrepare() ScpStatementPrepare {
val, ok := u.GetPrepare()
if !ok {
panic("arm Prepare is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182248
|
GetPrepare
|
test
|
func (u ScpStatementPledges) GetPrepare() (result ScpStatementPrepare, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "Prepare" {
result = *u.Prepare
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182249
|
MustConfirm
|
test
|
func (u ScpStatementPledges) MustConfirm() ScpStatementConfirm {
val, ok := u.GetConfirm()
if !ok {
panic("arm Confirm is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182250
|
GetConfirm
|
test
|
func (u ScpStatementPledges) GetConfirm() (result ScpStatementConfirm, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "Confirm" {
result = *u.Confirm
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182251
|
MustExternalize
|
test
|
func (u ScpStatementPledges) MustExternalize() ScpStatementExternalize {
val, ok := u.GetExternalize()
if !ok {
panic("arm Externalize is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182252
|
GetExternalize
|
test
|
func (u ScpStatementPledges) GetExternalize() (result ScpStatementExternalize, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "Externalize" {
result = *u.Externalize
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182253
|
MustNominate
|
test
|
func (u ScpStatementPledges) MustNominate() ScpNomination {
val, ok := u.GetNominate()
if !ok {
panic("arm Nominate is not set")
}
return val
}
|
go
|
{
"resource": ""
}
|
q182254
|
GetNominate
|
test
|
func (u ScpStatementPledges) GetNominate() (result ScpNomination, ok bool) {
armName, _ := u.ArmForSwitch(int32(u.Type))
if armName == "Nominate" {
result = *u.Nominate
ok = true
}
return
}
|
go
|
{
"resource": ""
}
|
q182255
|
SafeUnmarshalBase64
|
test
|
func SafeUnmarshalBase64(data string, dest interface{}) error {
count := &countWriter{}
l := len(data)
b64 := io.TeeReader(strings.NewReader(data), count)
raw := base64.NewDecoder(base64.StdEncoding, b64)
_, err := Unmarshal(raw, dest)
if err != nil {
return err
}
if count.Count != l {
return fmt.Errorf("input not fully consumed. expected to read: %d, actual: %d", l, count.Count)
}
return nil
}
|
go
|
{
"resource": ""
}
|
q182256
|
SafeUnmarshal
|
test
|
func SafeUnmarshal(data []byte, dest interface{}) error {
r := bytes.NewReader(data)
n, err := Unmarshal(r, dest)
if err != nil {
return err
}
if n != len(data) {
return fmt.Errorf("input not fully consumed. expected to read: %d, actual: %d", len(data), n)
}
return nil
}
|
go
|
{
"resource": ""
}
|
q182257
|
SendAmount
|
test
|
func (pr *PathPaymentResult) SendAmount() Int64 {
s, ok := pr.GetSuccess()
if !ok {
return 0
}
if len(s.Offers) == 0 {
return s.Last.Amount
}
sa := s.Offers[0].AssetBought
var ret Int64
for _, o := range s.Offers {
if o.AssetBought.String() != sa.String() {
break
}
ret += o.AmountBought
}
return ret
}
|
go
|
{
"resource": ""
}
|
q182258
|
LoadAccount
|
test
|
func (c *Client) LoadAccount(accountID string) (account Account, err error) {
c.initHTTPClient()
resp, err := c.Client.Get(c.URL + "/accounts/" + accountID)
if err != nil {
return
}
err = decodeResponse(resp, &account)
return
}
|
go
|
{
"resource": ""
}
|
q182259
|
SequenceForAccount
|
test
|
func (c *Client) SequenceForAccount(
accountID string,
) (xdr.SequenceNumber, error) {
a, err := c.LoadAccount(accountID)
if err != nil {
return 0, err
}
seq, err := strconv.ParseUint(a.Sequence, 10, 64)
if err != nil {
return 0, err
}
return xdr.SequenceNumber(seq), nil
}
|
go
|
{
"resource": ""
}
|
q182260
|
SubmitTransaction
|
test
|
func (c *Client) SubmitTransaction(transactionEnvelopeXdr string) (response TransactionSuccess, err error) {
v := url.Values{}
v.Set("tx", transactionEnvelopeXdr)
c.initHTTPClient()
resp, err := c.Client.PostForm(c.URL+"/transactions", v)
if err != nil {
return
}
err = decodeResponse(resp, &response)
return
}
|
go
|
{
"resource": ""
}
|
q182261
|
Equals
|
test
|
func (key *LedgerKey) Equals(other LedgerKey) bool {
if key.Type != other.Type {
return false
}
switch key.Type {
case LedgerEntryTypeAccount:
l := key.MustAccount()
r := other.MustAccount()
return l.AccountId.Equals(r.AccountId)
case LedgerEntryTypeData:
l := key.MustData()
r := other.MustData()
return l.AccountId.Equals(r.AccountId) && l.DataName == r.DataName
case LedgerEntryTypeOffer:
l := key.MustOffer()
r := other.MustOffer()
return l.SellerId.Equals(r.SellerId) && l.OfferId == r.OfferId
case LedgerEntryTypeTrustline:
l := key.MustTrustLine()
r := other.MustTrustLine()
return l.AccountId.Equals(r.AccountId) && l.Asset.Equals(r.Asset)
default:
panic(fmt.Errorf("Unknown ledger key type: %v", key.Type))
}
}
|
go
|
{
"resource": ""
}
|
q182262
|
SetAccount
|
test
|
func (key *LedgerKey) SetAccount(account AccountId) error {
data := LedgerKeyAccount{account}
nkey, err := NewLedgerKey(LedgerEntryTypeAccount, data)
if err != nil {
return err
}
*key = nkey
return nil
}
|
go
|
{
"resource": ""
}
|
q182263
|
SetData
|
test
|
func (key *LedgerKey) SetData(account AccountId, name string) error {
data := LedgerKeyData{account, String64(name)}
nkey, err := NewLedgerKey(LedgerEntryTypeData, data)
if err != nil {
return err
}
*key = nkey
return nil
}
|
go
|
{
"resource": ""
}
|
q182264
|
SetOffer
|
test
|
func (key *LedgerKey) SetOffer(account AccountId, id uint64) error {
data := LedgerKeyOffer{account, Uint64(id)}
nkey, err := NewLedgerKey(LedgerEntryTypeOffer, data)
if err != nil {
return err
}
*key = nkey
return nil
}
|
go
|
{
"resource": ""
}
|
q182265
|
SetTrustline
|
test
|
func (key *LedgerKey) SetTrustline(account AccountId, line Asset) error {
data := LedgerKeyTrustLine{account, line}
nkey, err := NewLedgerKey(LedgerEntryTypeTrustline, data)
if err != nil {
return err
}
*key = nkey
return nil
}
|
go
|
{
"resource": ""
}
|
q182266
|
Add
|
test
|
func (b *CHDBuilder) Add(key []byte, value []byte) {
b.keys = append(b.keys, key)
b.values = append(b.values, value)
}
|
go
|
{
"resource": ""
}
|
q182267
|
tryHash
|
test
|
func tryHash(hasher *chdHasher, seen map[uint64]bool, keys [][]byte, values [][]byte, indices []uint16, bucket *bucket, ri uint16, r uint64) bool {
// Track duplicates within this bucket.
duplicate := make(map[uint64]bool)
// Make hashes for each entry in the bucket.
hashes := make([]uint64, len(bucket.keys))
for i, k := range bucket.keys {
h := hasher.Table(r, k)
hashes[i] = h
if seen[h] {
return false
}
if duplicate[h] {
return false
}
duplicate[h] = true
}
// Update seen hashes
for _, h := range hashes {
seen[h] = true
}
// Add the hash index.
indices[bucket.index] = ri
// Update the the hash table.
for i, h := range hashes {
keys[h] = bucket.keys[i]
values[h] = bucket.values[i]
}
return true
}
|
go
|
{
"resource": ""
}
|
q182268
|
HashIndexFromKey
|
test
|
func (h *chdHasher) HashIndexFromKey(b []byte) uint64 {
return (hasher(b) ^ h.r[0]) % h.buckets
}
|
go
|
{
"resource": ""
}
|
q182269
|
ReadInt
|
test
|
func (b *sliceReader) ReadInt() uint64 {
return uint64(binary.LittleEndian.Uint32(b.Read(4)))
}
|
go
|
{
"resource": ""
}
|
q182270
|
Read
|
test
|
func Read(r io.Reader) (*CHD, error) {
b, err := ioutil.ReadAll(r)
if err != nil {
return nil, err
}
return Mmap(b)
}
|
go
|
{
"resource": ""
}
|
q182271
|
Get
|
test
|
func (c *CHD) Get(key []byte) []byte {
r0 := c.r[0]
h := hasher(key) ^ r0
i := h % uint64(len(c.indices))
ri := c.indices[i]
// This can occur if there were unassigned slots in the hash table.
if ri >= uint16(len(c.r)) {
return nil
}
r := c.r[ri]
ti := (h ^ r) % uint64(len(c.keys))
// fmt.Printf("r[0]=%d, h=%d, i=%d, ri=%d, r=%d, ti=%d\n", c.r[0], h, i, ri, r, ti)
k := c.keys[ti]
if bytes.Compare(k, key) != 0 {
return nil
}
v := c.values[ti]
return v
}
|
go
|
{
"resource": ""
}
|
q182272
|
Iterate
|
test
|
func (c *CHD) Iterate() *Iterator {
if len(c.keys) == 0 {
return nil
}
return &Iterator{c: c}
}
|
go
|
{
"resource": ""
}
|
q182273
|
Write
|
test
|
func (c *CHD) Write(w io.Writer) error {
write := func(nd ...interface{}) error {
for _, d := range nd {
if err := binary.Write(w, binary.LittleEndian, d); err != nil {
return err
}
}
return nil
}
data := []interface{}{
uint32(len(c.r)), c.r,
uint32(len(c.indices)), c.indices,
uint32(len(c.keys)),
}
if err := write(data...); err != nil {
return err
}
for i := range c.keys {
k, v := c.keys[i], c.values[i]
if err := write(uint32(len(k)), uint32(len(v))); err != nil {
return err
}
if _, err := w.Write(k); err != nil {
return err
}
if _, err := w.Write(v); err != nil {
return err
}
}
return nil
}
|
go
|
{
"resource": ""
}
|
q182274
|
RegisterDatasources
|
test
|
func RegisterDatasources(path string) error {
cs := C.CString(path)
defer C.free(unsafe.Pointer(cs))
if C.mapnik_register_datasources(cs) == 0 {
e := C.GoString(C.mapnik_register_last_error())
if e != "" {
return errors.New("registering datasources: " + e)
}
return errors.New("error while registering datasources")
}
return nil
}
|
go
|
{
"resource": ""
}
|
q182275
|
RegisterFonts
|
test
|
func RegisterFonts(path string) error {
cs := C.CString(path)
defer C.free(unsafe.Pointer(cs))
if C.mapnik_register_fonts(cs) == 0 {
e := C.GoString(C.mapnik_register_last_error())
if e != "" {
return errors.New("registering fonts: " + e)
}
return errors.New("error while registering fonts")
}
return nil
}
|
go
|
{
"resource": ""
}
|
q182276
|
New
|
test
|
func New() *Map {
return &Map{
m: C.mapnik_map(C.uint(800), C.uint(600)),
width: 800,
height: 600,
}
}
|
go
|
{
"resource": ""
}
|
q182277
|
NewSized
|
test
|
func NewSized(width, height int) *Map {
return &Map{
m: C.mapnik_map(C.uint(width), C.uint(height)),
width: width,
height: height,
}
}
|
go
|
{
"resource": ""
}
|
q182278
|
Load
|
test
|
func (m *Map) Load(stylesheet string) error {
cs := C.CString(stylesheet)
defer C.free(unsafe.Pointer(cs))
if C.mapnik_map_load(m.m, cs) != 0 {
return m.lastError()
}
return nil
}
|
go
|
{
"resource": ""
}
|
q182279
|
Resize
|
test
|
func (m *Map) Resize(width, height int) {
C.mapnik_map_resize(m.m, C.uint(width), C.uint(height))
m.width = width
m.height = height
}
|
go
|
{
"resource": ""
}
|
q182280
|
Free
|
test
|
func (m *Map) Free() {
C.mapnik_map_free(m.m)
m.m = nil
}
|
go
|
{
"resource": ""
}
|
q182281
|
SRS
|
test
|
func (m *Map) SRS() string {
return C.GoString(C.mapnik_map_get_srs(m.m))
}
|
go
|
{
"resource": ""
}
|
q182282
|
ZoomAll
|
test
|
func (m *Map) ZoomAll() error {
if C.mapnik_map_zoom_all(m.m) != 0 {
return m.lastError()
}
return nil
}
|
go
|
{
"resource": ""
}
|
q182283
|
ZoomTo
|
test
|
func (m *Map) ZoomTo(minx, miny, maxx, maxy float64) {
bbox := C.mapnik_bbox(C.double(minx), C.double(miny), C.double(maxx), C.double(maxy))
defer C.mapnik_bbox_free(bbox)
C.mapnik_map_zoom_to_box(m.m, bbox)
}
|
go
|
{
"resource": ""
}
|
q182284
|
Render
|
test
|
func (m *Map) Render(opts RenderOpts) ([]byte, error) {
scaleFactor := opts.ScaleFactor
if scaleFactor == 0.0 {
scaleFactor = 1.0
}
i := C.mapnik_map_render_to_image(m.m, C.double(opts.Scale), C.double(scaleFactor))
if i == nil {
return nil, m.lastError()
}
defer C.mapnik_image_free(i)
if opts.Format == "raw" {
size := 0
raw := C.mapnik_image_to_raw(i, (*C.size_t)(unsafe.Pointer(&size)))
return C.GoBytes(unsafe.Pointer(raw), C.int(size)), nil
}
var format *C.char
if opts.Format != "" {
format = C.CString(opts.Format)
} else {
format = C.CString("png256")
}
b := C.mapnik_image_to_blob(i, format)
if b == nil {
return nil, errors.New("mapnik: " + C.GoString(C.mapnik_image_last_error(i)))
}
C.free(unsafe.Pointer(format))
defer C.mapnik_image_blob_free(b)
return C.GoBytes(unsafe.Pointer(b.ptr), C.int(b.len)), nil
}
|
go
|
{
"resource": ""
}
|
q182285
|
RenderImage
|
test
|
func (m *Map) RenderImage(opts RenderOpts) (*image.NRGBA, error) {
scaleFactor := opts.ScaleFactor
if scaleFactor == 0.0 {
scaleFactor = 1.0
}
i := C.mapnik_map_render_to_image(m.m, C.double(opts.Scale), C.double(scaleFactor))
if i == nil {
return nil, m.lastError()
}
defer C.mapnik_image_free(i)
size := 0
raw := C.mapnik_image_to_raw(i, (*C.size_t)(unsafe.Pointer(&size)))
b := C.GoBytes(unsafe.Pointer(raw), C.int(size))
img := &image.NRGBA{
Pix: b,
Stride: int(m.width * 4),
Rect: image.Rect(0, 0, int(m.width), int(m.height)),
}
return img, nil
}
|
go
|
{
"resource": ""
}
|
q182286
|
RenderToFile
|
test
|
func (m *Map) RenderToFile(opts RenderOpts, path string) error {
scaleFactor := opts.ScaleFactor
if scaleFactor == 0.0 {
scaleFactor = 1.0
}
cs := C.CString(path)
defer C.free(unsafe.Pointer(cs))
var format *C.char
if opts.Format != "" {
format = C.CString(opts.Format)
} else {
format = C.CString("png256")
}
defer C.free(unsafe.Pointer(format))
if C.mapnik_map_render_to_file(m.m, cs, C.double(opts.Scale), C.double(scaleFactor), format) != 0 {
return m.lastError()
}
return nil
}
|
go
|
{
"resource": ""
}
|
q182287
|
SetBufferSize
|
test
|
func (m *Map) SetBufferSize(s int) {
C.mapnik_map_set_buffer_size(m.m, C.int(s))
}
|
go
|
{
"resource": ""
}
|
q182288
|
Search
|
test
|
func Search(st string, mx time.Duration) ([]SearchResponse, error) {
conn, err := listenForSearchResponses()
if err != nil {
return nil, err
}
defer conn.Close()
searchBytes, broadcastAddr := buildSearchRequest(st, mx)
// Write search bytes on the wire so all devices can respond
_, err = conn.WriteTo(searchBytes, broadcastAddr)
if err != nil {
return nil, err
}
return readSearchResponses(conn, mx)
}
|
go
|
{
"resource": ""
}
|
q182289
|
Get
|
test
|
func (p *blockingPool) Get() (net.Conn, error) {
//in case that pool is closed or pool.conns is set to nil
conns := p.conns
if conns == nil {
return nil, ErrClosed
}
select {
case conn := <-conns:
if time.Since(conn.start) > p.livetime {
if conn.Conn != nil {
conn.Conn.Close()
conn.Conn = nil
}
}
if conn.Conn == nil {
var err error
conn.Conn, err = p.factory()
if err != nil {
conn.start = time.Now()
p.put(conn)
return nil, err
}
}
conn.unusable = false
return conn, nil
case <-time.After(time.Second*p.timeout):
return nil, ErrTimeout
}
}
|
go
|
{
"resource": ""
}
|
q182290
|
put
|
test
|
func (p *blockingPool) put(conn *WrappedConn) error {
//in case that pool is closed and pool.conns is set to nil
conns := p.conns
if conns == nil {
//conn.Conn is possibly nil coz factory() may fail, in which case conn is immediately
//put back to the pool
if conn.Conn != nil {
conn.Conn.Close()
conn.Conn = nil
}
return ErrClosed
}
//if conn is marked unusable, underlying net.Conn is set to nil
if conn.unusable {
if conn.Conn != nil {
conn.Conn.Close()
conn.Conn = nil
}
}
//It is impossible to block as number of connections is never more than length of channel
conns <-conn
return nil
}
|
go
|
{
"resource": ""
}
|
q182291
|
MonoToStereoF32
|
test
|
func MonoToStereoF32(buf *audio.Float32Buffer) error {
if buf == nil || buf.Format == nil || buf.Format.NumChannels != 1 {
return audio.ErrInvalidBuffer
}
stereoData := make([]float32, len(buf.Data)*2)
var j int
for i := 0; i < len(buf.Data); i++ {
stereoData[j] = buf.Data[i]
j++
stereoData[j] = buf.Data[i]
j++
}
buf.Data = stereoData
buf.Format.NumChannels = 2
return nil
}
|
go
|
{
"resource": ""
}
|
q182292
|
BitCrush
|
test
|
func BitCrush(buf *audio.FloatBuffer, factor float64) {
stepSize := crusherStepSize * factor
for i := 0; i < len(buf.Data); i++ {
frac, exp := math.Frexp(buf.Data[i])
frac = signum(frac) * math.Floor(math.Abs(frac)/stepSize+0.5) * stepSize
buf.Data[i] = math.Ldexp(frac, exp)
}
}
|
go
|
{
"resource": ""
}
|
q182293
|
NormalizeMax
|
test
|
func NormalizeMax(buf *audio.FloatBuffer) {
if buf == nil {
return
}
max := 0.0
for i := 0; i < len(buf.Data); i++ {
if math.Abs(buf.Data[i]) > max {
max = math.Abs(buf.Data[i])
}
}
if max != 0.0 {
for i := 0; i < len(buf.Data); i++ {
buf.Data[i] /= max
}
}
}
|
go
|
{
"resource": ""
}
|
q182294
|
Gain
|
test
|
func Gain(buf *audio.FloatBuffer, multiplier float64) error {
if buf == nil {
return audio.ErrInvalidBuffer
}
for i := 0; i < len(buf.Data); i++ {
buf.Data[i] *= multiplier
}
return nil
}
|
go
|
{
"resource": ""
}
|
q182295
|
MonoDownmix
|
test
|
func MonoDownmix(buf *audio.FloatBuffer) error {
if buf == nil || buf.Format == nil {
return audio.ErrInvalidBuffer
}
nChans := buf.Format.NumChannels
if nChans < 2 {
return nil
}
nChansF := float64(nChans)
frameCount := buf.NumFrames()
newData := make([]float64, frameCount)
for i := 0; i < frameCount; i++ {
newData[i] = 0
for j := 0; j < nChans; j++ {
newData[i] += buf.Data[i*nChans+j]
}
newData[i] /= nChansF
}
buf.Data = newData
buf.Format.NumChannels = 1
return nil
}
|
go
|
{
"resource": ""
}
|
q182296
|
Quantize
|
test
|
func Quantize(buf *audio.FloatBuffer, bitDepth int) {
if buf == nil {
return
}
max := math.Pow(2, float64(bitDepth)) - 1
bufLen := len(buf.Data)
for i := 0; i < bufLen; i++ {
buf.Data[i] = round((buf.Data[i]+1)*max)/max - 1.0
}
}
|
go
|
{
"resource": ""
}
|
q182297
|
PCMScale
|
test
|
func PCMScale(buf *audio.FloatBuffer, bitDepth int) error {
if buf == nil || buf.Format == nil {
return audio.ErrInvalidBuffer
}
factor := math.Pow(2, 8*float64(bitDepth/8)-1)
for i := 0; i < len(buf.Data); i++ {
buf.Data[i] *= factor
}
return nil
}
|
go
|
{
"resource": ""
}
|
q182298
|
StereoPan
|
test
|
func StereoPan(buf *audio.FloatBuffer, pan float64) error {
if buf == nil || buf.Format == nil || buf.Format.NumChannels != 2 {
return audio.ErrInvalidBuffer
}
if pan < 0 || pan > 1 {
return errors.New("invalid pan value, should be betwen 0 and 1")
}
if pan == 0.5 {
return nil
}
if pan < 0.5 {
for i := 0; i+2 <= len(buf.Data); i += 2 {
buf.Data[i+1] *= (pan * 2)
}
} else {
for i := 0; i+2 <= len(buf.Data); i += 2 {
buf.Data[i] *= ((1 - pan) * 2)
}
}
return nil
}
|
go
|
{
"resource": ""
}
|
q182299
|
Leader
|
test
|
func (f *Follower) Leader() string {
f.lock.Lock()
defer f.lock.Unlock()
return f.leader
}
|
go
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.