package tg
import (
"context"
"errors"
"fmt"
"sort"
"strings"
"go.uber.org/multierr"
"github.com/gotd/td/bin"
"github.com/gotd/td/tdjson"
"github.com/gotd/td/tdp"
"github.com/gotd/td/tgerr"
)
var (
_ = bin .Buffer {}
_ = context .Background ()
_ = fmt .Stringer (nil )
_ = strings .Builder {}
_ = errors .Is
_ = multierr .AppendInto
_ = sort .Ints
_ = tdp .Format
_ = tgerr .Error {}
_ = tdjson .Encoder {}
)
type HelpPeerColorsNotModified struct {
}
const HelpPeerColorsNotModifiedTypeID = 0x2ba1f5ce
func (p HelpPeerColorsNotModified ) construct () HelpPeerColorsClass { return &p }
var (
_ bin .Encoder = &HelpPeerColorsNotModified {}
_ bin .Decoder = &HelpPeerColorsNotModified {}
_ bin .BareEncoder = &HelpPeerColorsNotModified {}
_ bin .BareDecoder = &HelpPeerColorsNotModified {}
_ HelpPeerColorsClass = &HelpPeerColorsNotModified {}
)
func (p *HelpPeerColorsNotModified ) Zero () bool {
if p == nil {
return true
}
return true
}
func (p *HelpPeerColorsNotModified ) String () string {
if p == nil {
return "HelpPeerColorsNotModified(nil)"
}
type Alias HelpPeerColorsNotModified
return fmt .Sprintf ("HelpPeerColorsNotModified%+v" , Alias (*p ))
}
func (*HelpPeerColorsNotModified ) TypeID () uint32 {
return HelpPeerColorsNotModifiedTypeID
}
func (*HelpPeerColorsNotModified ) TypeName () string {
return "help.peerColorsNotModified"
}
func (p *HelpPeerColorsNotModified ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "help.peerColorsNotModified" ,
ID : HelpPeerColorsNotModifiedTypeID ,
}
if p == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {}
return typ
}
func (p *HelpPeerColorsNotModified ) Encode (b *bin .Buffer ) error {
if p == nil {
return fmt .Errorf ("can't encode help.peerColorsNotModified#2ba1f5ce as nil" )
}
b .PutID (HelpPeerColorsNotModifiedTypeID )
return p .EncodeBare (b )
}
func (p *HelpPeerColorsNotModified ) EncodeBare (b *bin .Buffer ) error {
if p == nil {
return fmt .Errorf ("can't encode help.peerColorsNotModified#2ba1f5ce as nil" )
}
return nil
}
func (p *HelpPeerColorsNotModified ) Decode (b *bin .Buffer ) error {
if p == nil {
return fmt .Errorf ("can't decode help.peerColorsNotModified#2ba1f5ce to nil" )
}
if err := b .ConsumeID (HelpPeerColorsNotModifiedTypeID ); err != nil {
return fmt .Errorf ("unable to decode help.peerColorsNotModified#2ba1f5ce: %w" , err )
}
return p .DecodeBare (b )
}
func (p *HelpPeerColorsNotModified ) DecodeBare (b *bin .Buffer ) error {
if p == nil {
return fmt .Errorf ("can't decode help.peerColorsNotModified#2ba1f5ce to nil" )
}
return nil
}
type HelpPeerColors struct {
Hash int
Colors []HelpPeerColorOption
}
const HelpPeerColorsTypeID = 0xf8ed08
func (p HelpPeerColors ) construct () HelpPeerColorsClass { return &p }
var (
_ bin .Encoder = &HelpPeerColors {}
_ bin .Decoder = &HelpPeerColors {}
_ bin .BareEncoder = &HelpPeerColors {}
_ bin .BareDecoder = &HelpPeerColors {}
_ HelpPeerColorsClass = &HelpPeerColors {}
)
func (p *HelpPeerColors ) Zero () bool {
if p == nil {
return true
}
if !(p .Hash == 0 ) {
return false
}
if !(p .Colors == nil ) {
return false
}
return true
}
func (p *HelpPeerColors ) String () string {
if p == nil {
return "HelpPeerColors(nil)"
}
type Alias HelpPeerColors
return fmt .Sprintf ("HelpPeerColors%+v" , Alias (*p ))
}
func (p *HelpPeerColors ) FillFrom (from interface {
GetHash () (value int )
GetColors () (value []HelpPeerColorOption )
}) {
p .Hash = from .GetHash ()
p .Colors = from .GetColors ()
}
func (*HelpPeerColors ) TypeID () uint32 {
return HelpPeerColorsTypeID
}
func (*HelpPeerColors ) TypeName () string {
return "help.peerColors"
}
func (p *HelpPeerColors ) TypeInfo () tdp .Type {
typ := tdp .Type {
Name : "help.peerColors" ,
ID : HelpPeerColorsTypeID ,
}
if p == nil {
typ .Null = true
return typ
}
typ .Fields = []tdp .Field {
{
Name : "Hash" ,
SchemaName : "hash" ,
},
{
Name : "Colors" ,
SchemaName : "colors" ,
},
}
return typ
}
func (p *HelpPeerColors ) Encode (b *bin .Buffer ) error {
if p == nil {
return fmt .Errorf ("can't encode help.peerColors#f8ed08 as nil" )
}
b .PutID (HelpPeerColorsTypeID )
return p .EncodeBare (b )
}
func (p *HelpPeerColors ) EncodeBare (b *bin .Buffer ) error {
if p == nil {
return fmt .Errorf ("can't encode help.peerColors#f8ed08 as nil" )
}
b .PutInt (p .Hash )
b .PutVectorHeader (len (p .Colors ))
for idx , v := range p .Colors {
if err := v .Encode (b ); err != nil {
return fmt .Errorf ("unable to encode help.peerColors#f8ed08: field colors element with index %d: %w" , idx , err )
}
}
return nil
}
func (p *HelpPeerColors ) Decode (b *bin .Buffer ) error {
if p == nil {
return fmt .Errorf ("can't decode help.peerColors#f8ed08 to nil" )
}
if err := b .ConsumeID (HelpPeerColorsTypeID ); err != nil {
return fmt .Errorf ("unable to decode help.peerColors#f8ed08: %w" , err )
}
return p .DecodeBare (b )
}
func (p *HelpPeerColors ) DecodeBare (b *bin .Buffer ) error {
if p == nil {
return fmt .Errorf ("can't decode help.peerColors#f8ed08 to nil" )
}
{
value , err := b .Int ()
if err != nil {
return fmt .Errorf ("unable to decode help.peerColors#f8ed08: field hash: %w" , err )
}
p .Hash = value
}
{
headerLen , err := b .VectorHeader ()
if err != nil {
return fmt .Errorf ("unable to decode help.peerColors#f8ed08: field colors: %w" , err )
}
if headerLen > 0 {
p .Colors = make ([]HelpPeerColorOption , 0 , headerLen %bin .PreallocateLimit )
}
for idx := 0 ; idx < headerLen ; idx ++ {
var value HelpPeerColorOption
if err := value .Decode (b ); err != nil {
return fmt .Errorf ("unable to decode help.peerColors#f8ed08: field colors: %w" , err )
}
p .Colors = append (p .Colors , value )
}
}
return nil
}
func (p *HelpPeerColors ) GetHash () (value int ) {
if p == nil {
return
}
return p .Hash
}
func (p *HelpPeerColors ) GetColors () (value []HelpPeerColorOption ) {
if p == nil {
return
}
return p .Colors
}
const HelpPeerColorsClassName = "help.PeerColors"
type HelpPeerColorsClass interface {
bin .Encoder
bin .Decoder
bin .BareEncoder
bin .BareDecoder
construct () HelpPeerColorsClass
TypeID () uint32
TypeName () string
String () string
Zero () bool
AsModified () (*HelpPeerColors , bool )
}
func (p *HelpPeerColorsNotModified ) AsModified () (*HelpPeerColors , bool ) {
return nil , false
}
func (p *HelpPeerColors ) AsModified () (*HelpPeerColors , bool ) {
return p , true
}
func DecodeHelpPeerColors (buf *bin .Buffer ) (HelpPeerColorsClass , error ) {
id , err := buf .PeekID ()
if err != nil {
return nil , err
}
switch id {
case HelpPeerColorsNotModifiedTypeID :
v := HelpPeerColorsNotModified {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode HelpPeerColorsClass: %w" , err )
}
return &v , nil
case HelpPeerColorsTypeID :
v := HelpPeerColors {}
if err := v .Decode (buf ); err != nil {
return nil , fmt .Errorf ("unable to decode HelpPeerColorsClass: %w" , err )
}
return &v , nil
default :
return nil , fmt .Errorf ("unable to decode HelpPeerColorsClass: %w" , bin .NewUnexpectedID (id ))
}
}
type HelpPeerColorsBox struct {
PeerColors HelpPeerColorsClass
}
func (b *HelpPeerColorsBox ) Decode (buf *bin .Buffer ) error {
if b == nil {
return fmt .Errorf ("unable to decode HelpPeerColorsBox to nil" )
}
v , err := DecodeHelpPeerColors (buf )
if err != nil {
return fmt .Errorf ("unable to decode boxed value: %w" , err )
}
b .PeerColors = v
return nil
}
func (b *HelpPeerColorsBox ) Encode (buf *bin .Buffer ) error {
if b == nil || b .PeerColors == nil {
return fmt .Errorf ("unable to encode HelpPeerColorsClass as nil" )
}
return b .PeerColors .Encode (buf )
}
The pages are generated with Golds v0.6.7 . (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu .
PR and bug reports are welcome and can be submitted to the issue list .
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds .